2 comments about Real Time Systems and Programming Languages: Ada 95, Real-Time Java and Real-Time C/POSIX (3rd Edition).

1. This book is no good for students, as it has exercises with answers only available to lecturers though a password system.
   The examples are ok but do not help for the exercises so it makes the book imcomplete and very dissappointing, If you need help for real time systems then this is not the book for you, If you just want to read a book this might be ok, but learning is not going to be done.
   (...)



2. This book is great because it covers all the important concepts quite well. I think it is a must for those into real-time programming.

3 comments about Developing Professional Java Applets.

1. I bought this book more than one year ago. But the more I use it the more I like it.Although the book was written for JDK1.0.2, the ideas are still valid. The book is project oriented. The authors used only two chapters to talk about Java and the rest of the book guides users to develop non-trivial projects. I learn a lot by doing these projects. No other books match this one. If the authors will update this book for new JDK, I will jump to buy it.



2. The code applet for spreatsheet project (part 2), in cap. 3 is incomplete. The library lose the Cd of this book, and I writte the code, but it's not compile!



3. This book is sensational, but it needs to be updated to the new language version specially about event-treatment.

5 comments about Special Edition Using Java 2, Standard Edition (Special Edition Using...).

1. Excellent book!!! Even somebody like me could understand it and write couple of programs! I will say book had something to do with it. Best one by far.



2. I had the great happiness of receiving this book as a gift of a dear friend. I am a beginner in the Java programming. For me, this it is an excellent book, their authors wrote it with a lot of grace and with a lot of ability so that the reader understood it. Don't doubt to buy this book. If I could give to this 6 stars, then I would give him 10.



3. This is very good book. As I take this book when I wann to Start Java again from Starting point. So can say that I've some knowledege of java and I wann to recall it with some good examples. And also I wann to touch which I never touch like Java Beans, Thearding, networking etc. and I found that this book really helpful for me.
   One more thing I wann to say that this book would be more useful if authore cover some more tpoics like security, little bit introduction of servlet, jsp etc.
   Anyway, I've full marks to this book.
   Pranav



4. This book has good breadth, but fundamentally fails to help the reader understand Java.

   I am a Java trainer, and have used many books and training material. I recently chose this book for a class because of its breadth. Unfortunately, I had to write a lot of supplemental information to make up for the book's lack of clarity and structure.

   A book should simplify key concepts by highlighting key points, using diagrams, etc. This book doesn't do that. It's like a brain dump, where the authors talk and talk about a given topic, but in a way that lacks structure. There is no flow or progression of concepts.

   The book also has poor layout. Books should be designed with an eye toward ease of reading. Are key points highlighted? Are diagrams effective? If you're in a bookstore open the book to a random page. Are the highlighted sections important? Is the conceptual outline of the page apparent? For me, the answer is no.

   Here's one of the highlighted paragraphs I've chosen at random:
   "The ability to specify indexes when working with a List places an additional burden on you as a programmer. You must always ensure that any index you pass to a List method is greater than or equal to zero, and less than or equal to the size of the collection minus one. Each List method that accpets an indx throws an IndexOutOfBoundsException at runtime when this is not the case."

   Rather than highlighting this key point with this dense paragraph, the author could have provided a simple diagram and an example. The reader would have understood the point immediately, rather than having to read and re-read a prose explaination.

   Diagrams are similarly poor. There are a few diagrams, but they are not effective at communicating concepts. It's as if an editor said "we need a diagram" so someone whipped one out, whether or not it was effective.

   In summary, this book has good breadth but is poor at helping the reader understand Java.




5. The book is old but have information that can help you even in 2007.

No comments about Mastering XMI: Java Programming with XMI, XML, and UML (With CD-ROM).

5 comments about JXTA in a Nutshell.

1. Just read the book it is well organized and as a full
   JXTA auctioning example. If you are looking for serious
   JXTA programming that's the book you want to have.



2. JXTA in a Nutshell contains lot of information into not a lot of space. It is the best book on the market for learning JXTA. It is worth reading, even if it is your first JXTA book. The book is fairly complete, with a full reference to the JXTA Java API and the JXTA protocols. There is a great deal of valuable information in the book, and it will serve quite well as a desktop reference.
   The book is organized well, leading the user through the JXTA
   core concepts. I particularly appreciate the way the book
   has been orginized making it easier to find the specific information I want (discovery, pipe, peergroup, etc). In addition, I also liked the extra sections dealing with the
   JXTA protocol specification to better understand JXTA.
   In all, this book is the only JXTA book I need, but it will doubtless be one that I refer to repeatedly as I develop with the JXTA platform.



3. I learned many new things about JXTA reading this book. Overall, I would say that this is the best JXTA coverage I've seen in any book. So, if you're looking for a JXTA book I believe you'll be extremely pleased with this book.

   I'd been looking for a JXTA book for some time, but I didn't want a simple quick reference that left me wondering how to code for JXTA applications. I also didn't care to read through a API reference in order to understand what JXTA was all about. This book is something completely and impressively different.

   This is a great book for newcomers to JXTA, though I suspect anyone who's developed in Java will be able to follow along quite well. In fact, it's the author's writing style that makes learning JXTA almost effortless. The examples are numerous, easy to follow. The authors frequently tie the concepts together nicely and it's plain to see how the examples may be incorporated into larger applications. I like that approach.

   Another thing I especially appreciated was the author's effort to provide useful tips for solving real-world problems. I can hardly imagine buying another JXTA book because I believe I've found most, if not all, of what I need.




4. The book explains in very clear language almost every aspect of JXTA P2P programming and gives a good overview of all common JXTA concepts (Pipes, advertisements, discovery, peergroups). You'll learn how to design, implement, test and deploy your JXTA P2P programs. The book does a great job by identifying and providing solutions to common P2P pitfalls. I recommend this book to every programmer out there. If you are serious about writing JXTA programs this is the book to get.



5. According to the title, JXTA in a nutshell teaches how to write JXTA application in a short time.
   This book has a coverage of every part of JXTA technology, well explained and clear.
   The book has a problem, it was writen in year 2002 and some examples doesn't work!.

2 comments about Beginning J2EE 1.4.

1. I bought this book a month ago. It is a piece of junk. The book mentions deploytool that it was old version. You could not follow how to run j2ee from this book at all. You will be stuck every pages and got a headache like me. You have to find the answer from the Internet. Lots of people who bought this book have problems too, pls check wrox forum. No one helps you. The author disappears. Lots of error, out of dated.... Don't waste your money.... I will not buy book from WROX again



2. This book has been updated for the J2EE 1.4 SDK final, and is being published by Apress. The ISBN for this edition is 1590593413.

No comments about Software Security - Theories and Systems: Second Mext-WSF-JSPS International Symposium, ISSS 2003, Tokyo, Japan, November 4-6, 2003 (Lecture Notes in Computer Science).

1 comments about Understanding Java.

1. As a professional trainer of occupational retraining programs in Software Engineering the available university level texts ususally breal down into the "Everything You Ever Wanted To Know But Were Frightened To Death To ask" with their overwhelming amount of details; or the "We Understand The Principles, So Who Needs To Know The Details". Barry Cornelius's work is a refreshing break from both venues, but not without meeting the needs of both the "Hands On" how-do-you do it practioners as well as the "help-me-understand-the-concept" theorists.

   If for no other reason than to hear Barry's very powerful ideas on the role of interfaces in Java software development, it is worth purchasing and reading the book. I promise you you won't regret it.

   Yoel Ben-Avraham
   Lecturer, Software Engineering

5 comments about Fundamentals of OOP and Data Structures in Java.

1. Dr. Wiener and Dr. Pinion have distinguished them selves once again as long time academicians in the Object Oriented Programming paradigm. This book is not for the casual Java programmer. It becomes obvious as you study this book that the authors are truly dedicated to OOP. This excellent CS-2 level textbook is uniquely divided into two parts: (1) Foundations and (2) Data Structures. Part One provides the student of Java as well as the professional Java programmer a comprehensively in-depth review of the fundamental building blocks so necessary for competency in OOP with the Java programming language. This section is populated with rich examples to enhance student understanding. Each chapter concludes with reinforcement exercises uniquely designed to support learning objectives. The authors have developed an exceptional thread of continuity throughout Part One to lead you into Part Two. The student should not skip/jump any section for Part One is uniquely compressed stressing the absolute essentials in OOP, which in-fact superbly prepares the reader for Part Two "Data Structures."

   Part Two is where the authors truly demonstrate their years of experience in academia teaching the concepts of the Abstract Data Type (ADT). Their previous teaching experience in several programming languages is brought to light in their comprehensive approach as they lead the student into this prime area supporting object-oriented software development. Again as in the first section, each chapter is uniquely inclusive of clearly designed examples to support the student's understanding of the ADT concepts so essential for the OOP student or professional programmer. The authors provide a multitude of interface code listings and classes that extend and implement other classes uniquely designed to enhance student understanding. They also provide a rich set of exercises which supports the students understanding requiring the student to complete as programming assignments. To ease the students testing their code, the authors have provided an excellent set of GUI Lab applications, which are uniquely designed for the various programming exercises.

   I teach Java programming at the CS-1 level and personally have used several of the author's examples to support my class lectures in preparation for the students' entry into the second level CS-2.

   This comprehensive CS-2 level textbook is well worth considering for both the academic and professional teaching environments.




2. September 8, 2000

   It is customary as Professor of Computer Science at Long Island University for me routinely to review and select textbooks about Object-Oriented programming and Data Structures in Java and other programming languages for both undergraduate and graduate classes. Almost every day the Computer Science professors receive desk copies of new computer textbooks from publishing houses. Most textbooks are unacceptable for one reason or another. Either they don't cover their subject adequately; appear to be written for the author's peers rather than for the student, or coded examples don't work so the book is rejected.

   Recently, while attempting to select a textbook on Object-Oriented programming and Data Structures in Java for both undergraduate and graduate seminars for the fall term 2000, I discovered one outstanding book: Fundamentals of OOP and Data Structures in Java by Richard Wiener and Lewis J. Pinson, published by Cambridge University Press, ISBN No. 0-521-66220-6.

   Fundamentals of OOP and Data Structures in Java is written in a clear, concise style with numerous examples that WORK. This textbook is written with students in mind, not the authors' peers. It is evident that Professors Wiener and Pinson understand data structures, their intended use in any programming environment, and when and how to use them. Conceptually, their presentation makes this book a must for any class that focuses on Data Structures and Object-Oriented programming in Java. I particularly like "Part Two: Data Structures." This section discusses "Abstract Data Types," "Containers as Abstract Data Types," and the classic data structures themselves. No important topic is bypassed or perfunctorily treated. Clear explanations and examples abound.

   Students, professors, or anyone interested in object-oriented programming and data structures in Java, BUY THIS BOOK!

   Professor Dwight Peltzer Dept. of Computer Science Long Island University Brookville, NY




3. September 8, 2000

   It is customary as Professor of Computer Science at Long Island University for me routinely to review and select textbooks about Object-Oriented programming and Data Structures in Java and other programming languages for both undergraduate and graduate classes. Almost every day the Computer Science professors receive desk copies of new computer textbooks from publishing houses. Most textbooks are unacceptable for one reason or another. Either they don't cover their subject adequately; appear to be written for the author's peers rather than for the student, or coded examples don't work so the book is rejected.

   Recently, while attempting to select a textbook on Object-Oriented programming and Data Structures in Java for both undergraduate and graduate seminars for the fall term 2000, I discovered one outstanding book: Fundamentals of OOP and Data Structures in Java by Richard Wiener and Lewis J. Pinson, published by Cambridge University Press, ISBN No. 0-521-66220-6.

   Fundamentals of OOP and Data Structures in Java is written in a clear, concise style with numerous examples that WORK. This textbook is written with students in mind, not the authors' peers. It is evident that Professors Wiener and Pinson understand data structures, their intended use in any programming environment, and when and how to use them. Conceptually, their presentation makes this book a must for any class that focuses on Data Structures and Object-Oriented programming in Java. I particularly like "Part Two: Data Structures." This section discusses "Abstract Data Types," "Containers as Abstract Data Types," and the classic data structures themselves. No important topic is bypassed or perfunctorily treated. Clear explanations and examples abound.

   Students, professors, or anyone interested in object-oriented programming and data structures in Java, BUY THIS BOOK!

   Professor Dwight Peltzer Dept. of Computer Science Long Island University Brookville, NY




4. The relative newness and the complexity of Java have created an enormous amount of difficulty for those who teach it in the CS curriculums around the world. While the structure of the computer science major is also not a stable entity, there are some constants that must be covered. A course in data structures is a staple in the beginning, generally being taken after the first course in programming in the main language used in the major. The problem has been that Java is such a large language, there are so many different ways to teach the first course. This has required textbooks in data structures using Java to either assume very little or to assume too much.
   This book takes a middle, very effective approach. The assumptions are that the reader has a good deal of programming knowledge, but not necessarily in Java or any other object-oriented language. Part one is devoted to a survey of object-oriented programming in general and how it is done in Java in particular. An instructor could use it to prep the students familiar with programming in other languages or to fill the holes of any material not covered in previous courses.
   The main point of the book is of course the coverage and explanation of the standard data structures used in programming. These structures are described by a combination of explanation and a great deal of source code. To help prevent the cramps in the fingers and brain that would come from typing it all in, all source code is available online. This is especially helpful because exercises are included at the end of the chapters and many of them involve modification of the code in the text. Turning good code into bad code by mucking with it and then correcting it is far and away the best way to learn to program, since that is how we program anyway. This is a backhand way of saying that the exercises make excellent short, yet challenging programming assignments.
   Data structures has often been the course where computer science students are set on the track to performing significant work in the field. Good data structures texts in Java have been lacking, so this book fills a significant void. Definitely worth examining for adoption.



5. After reading the first three chapters, I had to conclude that the book was too dated to use. Here are some of its problems:
   
   (1) The book and previous reviewers speak of code that can be downloaded from the publisher's web site; the publisher no longer makes such downloads available.
   
   (2) With respect to software design methodologies, the author embraces "design by contract" which was championed by Bertrand Meyer in 1997 in "Object-Oriented Software Construction." This approach has pretty much been left by the wayside, with "patterns" being the currently touted approach. The author also adheres to a design methodology which rigidly classifies object messages as being either commands (methods that change the internal state of the object) or queries (methods that report back on the object's internal state). When it was time to implement stacks, this rigid adherence put him in a quandry. Traditionally "popping" a stack results in both situtations: the topmost value is returned by the pop (like a query) and the internal state of the stack is changed (like a command). To adhere to the command/query dichotomy, the author made popping a two-process. "Pop" changes the internal state of the stack, storing the topmost element in an internal field and reducing the size of the stack by one. However in order to restrict popping to "command" status, the topmost value is not reported back to the invoking code. Instead the user has to issue a subsequent "query" requesting the value of the topmost element. This implementation is oblivious to the impact that such a two-step process would have in a threaded environment. If thread_2 issues a pop command after thread_1 pops, but prior to thread_1 querying for the topmost value, the topmost element would be lost forever.
   
   (3) The author makes use of Java classes that have since been deprecated. For instance he uses the Vector class, which has been more or less replaced by ArrayList.
   
   (4) The author's convention for naming methods isn't in line with the current, prevailing conventions. For "commands" he uses various action words followed by a noun which describes the field being impacted by the command. For "queries" he restricts the name to a noun or noun phrase which describes the field value that's being returned. However it is now more common to see "commands" named "setField()" and "queries" named "getField()". Many IDE's automatically create method names utilizing the "set" and "get" naming convention.
   
   For these reasons, I can no longer recommend the book.

1 comments about Creating Components: Object Oriented, Concurrent, and Distributed Computing in Java.

1. This book provides a good introduction to Concurrent and Object Oriented Programming in Java. I was fortunate enough to take Dr. Kann's class last semester, while this book was being finalized. This is probably the best book I have been assigned as a class textbook while in school, both in readability, and usefulness.

   Reading this book will make programming concurrent applications in Java easy, just by following the design patterns in the text. Use of notification objects and synchronization is well explained. If you'd like to understand object oriented concepts such as composition and classification in an easy to understand way, this book will help. Throughout the course of the book, the reader can watch the construction of a concurrent program from beginning to end. The concurrent program (the animator), is also a handy class which can be used to perform simple multithreaded animations.

   The section on distributed computing (Java RMI) implements a simple chat client/server in Java which can be used across the internet. Very easy to write your own chat program in Java using the material in this book.

   Code included in the book should have you up and running quickly. If you're ready to start utilizing the full power of java objects and multithreading, buy this book.