No comments about Java 5: Objects First.

3 comments about PHP: The Complete Reference.

1. As a software developer, I primarily work with the ASP.NET technology and have been learning to apply Ajax to my work. A small segment of my work is with PHP/MySQL. I picked-up this book at Barnes & Noble (my Sunday library and Starbucks experience) and found the subject of Ajax to be very well explained.
   
   I purchased this book solely for the Chapters 12 and 13 coverage of Ajax and have found it to be worth the purchase price alone. I look forward to reading the rest of the book as a refresher for my PHP development.



2. This book is okay as a beginning reference. The title may give the impression that it's a book you'll want to keep on your shelf and return to frequently for years to come. That probably won't be the case for most readers who go on to write a lot of PHP, so a better title might have been "Getting Started with PHP", or something like that. The banner on the back of the book, which says "Your One-Stop Guide to Web Development with PHP", is a lot more predictive of the book's contents.
   
   It contains a lot of fluff that fills way more pages than are justified for the amount of information given, such as examples built-up in stages, leading to a lot of needlessly redundant example code. This might make sense for complex examples, but the examples in this book are all very simple, so the extra use of paper is wasteful.
   
   Personally, I don't like the author's tendency to follow his own explanations with expressions like "Not bad!", "Nice!", and "Pretty good!". I appreciate when authors use a conversational tone to some extent (Scott Meyers is the best at this, I think), but doing this constantly throughout the book goes too far for my taste. Others might enjoy this style of writing though.
   
   I would say this book seems to be targeted toward readers who are absolutely new to programming. If you're coming from any kind of programming background at all, or like to be challenged, then you might not be very satisfied with this book. One good thing is that it's so simple and the examples take up so much space, you can read the whole thing in just a few hours.
   
   I've also noticed quite a few typos, even in the example code (e.g. "close" where they meant "clone"), but I don't see an erratum posted on the McGraw-Hill website yet. I'm sure that's because the book was published only recently. The source code is all there though, as advertised. Still, it would have been nice if they'd done a better job of editing the text.
   
   Maybe the overall nature of this book is consistent with "The Complete Reference" series by McGraw-Hill. This was the first title I'd read in that series, so I had no certain expectations. In the future, I'll know better what to expect from "The Complete Reference" books.



3. PHP, The Complete Reference may be a good book to start learning from. In addition, it does touch on most of the major topics.
   
   However, calling it "Complete" is a joke. I have been writing software for over 40 years, and this is the first language "reference" book I have found that does not fully describe the built-in functions supported by the language. For example, on pages 82-84 the author lists about 100 string functions in a 2 column table. The first column is the function name, and the 2nd column is a single phrase that states the purpose of the function. No syntax is shown, no arguments, no return value information and no usage information. In the few pages that follow, there are in-line examples of a couple of the 90+ functions.
   
   The same is true for other groups of functions. Having to go online to find out information that should be in a "complete reference" obviates the need for a book. At the price charged for this book, you'd be better off using the abundant information available online.

No comments about Objects, Abstraction, Data Structures and Design: Using Java.

5 comments about Learn to Program with Java.

1. If you have no programming experience and want to learn the mindset of writing computer programs using java, then buy this book. Otherwise, pass this by for another Java intro.



2. I took an intro to programming course with Java at my university a few years ago. The professor was really bad (barely spoke English) and needless to say, I hardly got anything out of the class. I was feeling a little anxious about future programming classes so I picked up this book at the recommendation of a friend. I was truly impressed with it. I really liked the classlike setting in the book which made you feel like you were actually participating in a course, not just reading another programming book. The explanations are worded in everyday terms so you don't have to be a software engineer to figure out what is going on. In fact, Smiley actually goes way more in depth than most first semester Java courses, yet presents the information so well that you don't even notice how much you are learning. This is probably the best book I have seen to teach yourself Java and would recommend it to anyone.



3. This book is the best for a beginning programmer with no experience. It guides you through the basics and does not bore you or assume that you know C or C++ like most other Java books. I have wanted to pick up some programming for a while and John Smiley's book was the only one I have been able to read from cover to cover and get something out of. I got the electronic version at his website.



4. I am 48 yo, I have/had no programming experience, I am not a native english speaker and I needed to learn Java.
   
   I tried the Head First series but at chapter 5 they had me lost. I tried a good italian book "Java 6" by De Sio (I am italian) but it is too advanced for me. I tried "Think in Java" by Eckel and I was lost into his sea of words and the continuous referring to C language basics.
   
   Then I found prof. Smiley site and I finally saw the light!
   
   If you are new to Java you'll be amazed at how good at teaching Prof. Smiley is.
   
   He saved my IT career.
   
   So if you are Java beginners you MUST study this book and visit his site at www.johnsmiley.com
   
   You won't regret it!



5. I've just finished my Object-Oriented Programming I (OOP I) class and we used this book. This is one of those text book that is really entertaining to read. It may sound weird but REALLY! it is. The book takes you to an adventure while learning at the same time. The author tells a "story" about his class and guides the reader to learning from both the students' and teachers' perspective. Yes, some teachers may learn from his teaching style--taking student's input while catering to their educational needs at the same time, whatever level of retention they may have. But, the only problem I see (personaly) about the book is that there are times when I noticed that the Figures (Fig. 1.1, Fig. 2.3,, etc) for some reason, did not come in the right place while I am intently reading the text. If rating comes in halves, I would give this book a 4 1/2 stars.

No comments about Java Card for E-Payment Applications.

5 comments about Unit Testing in Java: How Tests Drive the Code (The Morgan Kaufmann Series in Software Engineering and Programming).

1. Very good book for mastering the basics. Covers quite a bit of ground in a short period. Lots of references and examples make it easy to understand. I have worked with unit testing using JUnit for a couple of years and also enjoy the site www.developertesting.com by the folks at Agitar Software. I have recently taken unit testing to a new level using the Agitator, see www.agitar.com I highly recommend it!



2. I like this kind of book. It is practical and informative without being wordy or pretentious. It introduces test-driven development with a focus on Java and Java tools, but its lessons can be applied fairly well to any OO language such as C#, C++, Python etc. The book covers a pretty broad range of topics including an introduction to the principles of test-first development, mock objects, persistence, Web development, EJBs, and user interfaces, among others. Each topic is covered in sufficient detail to get started and points out the hazards one should be aware of. This book is also well-researched and contains a good list of references. Overall this is a solid, well-organized effort that deserves space on the bookshelf of any developer getting into test-driven development.



3. This is a very readable introduction to unit testing, a good first book for anyone wanting a sound approach to software testing.
   
   The main text is divided into two parts. The first is a clear introduction to the basics of the JUnit test framework. The pace is gentle, and the entire discussion is built around sample code - very helpful for the beginner who thinks in concrete terms. Link (the author) omits the JUnit API information that's already available in JUnit's JavaDoc pages. Those are just the basic words available in the framework; Link's goal is to put them together into meaningful test phrases. Throughout this half of the book, the reader is shown a number of common situations with non-obvious solutions. At each step, Link presents a little theory (plus some nice references), a little refactoring to improve the system's testability, and enough sample code to make the solution clear. This isn't a textbook on the theory of testing. Still, by the end of this first section, the reader has been exposed to many ideas: coverage metrics, internet resources, design and implementation for testability, and a lot more.
   
   The book is heavily oriented towards Java, partly because of the relative wealth of test tools available and because of Java features and APIs that support automated testing. Having chosen Java, it is natural to ask testing for unique features of the Java environment: GUIs, persistence, EJB, servlets, RMI, and more. Link covers those in the book's second half. Many of these chapters are specific to Java technologies and APIs. Some, like the GUI discussion, have value beyond the Java specifics they discuss. Even if the language and APIs change, many of the techniques will work well in any GUI programming environment. This section ends at a strategic level: introducing testing into existing workflows, handling of legacy systems, and management issues.
   
   Link has written a very helpful introduction to testing. It has enough specifics to get a beginner started, or to help an old hand deal with the problems of complex systems. The book's practical orientation skips a lot of the history and theory of testing, including tests that deal with qualitative performance issues rather than basic correctness. Anyone reading this book by itself might not realize just how broad and deep the subject really is. Link does at least mention the major ideas in the field, though, and prepares the reader for more advanced discussions.
   
   //wiredweird



4. For a short book like this I'm very impressed with it's breadth of coverage. It stars by covering JUnit and the test first methodology. It then covers testing a variety of types of code, including very notably HTML and GUI code. The last chapter, which is one of it's best is on the importance of unit testing in the entire lifecycle of development. This is an instant classic in the under-covered world of unit testing. A must buy for both QA and Developer alike.



5. This was the second unit testing book that I read after Hunt & Thomas's /Pragmatic Unit Testing/, and it did an admirable job helping me progress beyond the basics. It has especially good overviews of Test-Driven Development, the guts of JUnit, and mock objects. I found it less useful (i.e. less detailed) when it turned to testing J2EE and database functionality. I found J.B. Rainsberger's /JUnit in Action/ a much more authoritative reference. But this book got back on track at the end with its sections on HTML and GUI testing, which fill in a lot of the gaps in Rainsberger's book. In the end, I give both books 4 stars because they complement each other well, although /JUnit in Action/ is, by far, a much better overall reference.

No comments about Java 2D API Graphics.

5 comments about A Little Java, A Few Patterns.

1. If you're looking for a curiosity, buy this book-like object. If you're at all interested in a practical volume on patterns and Java, you'd learn more by by watching the patterns your money made as you throw it into the breeze.

   The book's format is horribly non-conventional, and that may appeal to the egghead in some people, but for the vast majority of people, you'll be very unhappy you purchased this useless book. In fact, to prevent anyone else from getting burned, I won't be looking to sell mine as a used book, just to keep it off the market; if you're an egghead looking for a coffee table book, buy it from someone else.




2. Decades ago, a predecessor of this book introduced me to Lisp. At first, the
   cutsey Q&A style put me off, but that book, "The Little Lisper", succeeded very
   well in its goal of creating a Lisp-speaking recursive mindset for me. Likewise
   this book creates a Java-speaking, object-oriented mindset. However, not the mindset
   you may think you want when you start reading. This book is a true sequel to "The
   Little Lisper" and not an out-of-the-box Java patterns book. My first reaction
   was "this is really neat but not necessarily too useful". Wrong. It wasn't long
   before I was designing an open source Java package that stacks Swing objects in
   a way strongly reminiscent of the stacked pizza toppings in this book. Who
   knows? You, too, may end up stacking boxes rather than thinking within them.



3. I first read and enjoyed "The Little Lisper" in College (1990ish). It was entertained and educated at the same time. This was the first book I saw that "broke the mold" of computer programming texts.
   
   I bought "A little Java, A Few Patterns" because it was recommended to me. I was very pleasantly suprised to see the same approach used in the Little Lisper. I enjoyed this new book just as much and learned even more.
   
   This is a book for thinking programmers. It won't teach you Java syntax. It will help you learn how to think about what you are doing.



4. I read this book about 7 years ago; it is still in my bookshelf. I actually learned a lot of OO ideas from this little book which I think had been deceptively titled; it should have been named "A little book of OO patterns in java" -I thought it was an introductory book in java at that time and I end up learning about interface, abstract, patterns, etc. before I even compiled my first
   "Hello World" in java.



5. This books was written in the late mid 90s when there was a lot of misunderstanding about OO. I enjoy reading Robert Martin's writings from that time and you'll see he is still a best selling OO author today. The form of OO in "A Little Java..." is exactly the form of OO that Mr Martin proved wrong then and today.
   
   More precisely, these authors use inheritance (the "is-a" relationship) as a form of aggregation (the "has-a" relationship). They did this, as another reviewer said, so their Java would look like Lisp. For instance, in this book, Tree inherits from Leaf. Shouldn't a tree have more than one leaf? Anyone conversant in OO recognizes that the relationship between a Pizza and its ingredients is Composition, not inheritance. While Lisp is a wonderful language, Lispy Java doesn't work.
   
   This book is worthless. The authors should apologize for writing it. It is difficult to follow as many reviewers say because it is so wrong.
   
   And yes, my former boss writes code just like this. It is difficult to write unit tests for code like this (he never did) so the quality is poor and maintainability also proved difficult.

4 comments about Sams Teach Yourself Wireless Java with J2ME in 21 Days.

1. As one of many people now moving their programming to the wireless world of Java 2 Micro Edition, I found this book to be excellent.

   It contains numerous, real world examples - from getting simple text off a server, right through to reasonably complex game design and even sprite manipulation.

   In fact I'm sure many of the applications in this book will be converted into real world code by cut and paste coders!

   The book does require some limited knowledge of Java2 but I was at home very quickly.

   With plenty of exercises, and a CD of all the source and latest Sun Forte/SDK I was delighted with my purchase.

   Perfect if you're targeting Motorola cellphones or Palm development (note though doesn't cover the new Nokia J2ME SDK)




2. Bad news first: This book has a few typographical errors in the
   explanatory texts but none in the source code listings. It also
   has a few misplaced words reversing the meaning of what the
   author intended to say. But if you're a beginning Java
   programmer and understands basic code optimization, you'll find
   yourself correcting the texts with a note on the margins.
   Example: on page 273, "... it takes longer for MIDlet code to
   access local variables than ... member variables..." The "local"
   and "member" words should be interchanged.
   
   I had to re-read Chapter 17 "Creating Animated MIDlets" because
   the author uses a different Sprite / Sprite Management classes
   that I'm used to (I write my own). Chapter 19 is probably the
   most difficult chapter to read because it uses artificial
   algorithms without fully explaining them (in fairness to the
   author, he did mention the names of the original algorithm
   developers, the general term of the algorithm and one possible
   source for AI research).
   
   The author could have used this chapter to create a multiplayer
   game (as a perfect combination of his prevous game programming
   chapters and networking-I/O chapters). Example: A two-player
   first person turn-based boxing game could have been a good
   tutorial.
   
   Also, the last two chapters were not necessary. He could have
   put them in appendices. The space could have been used too for
   more complicated examples.
   
   Good news: Nevertheless, Chapters 1 to 16 were an excellent
   J2ME tutorial altogeter. The author wrote very clearly and he
   reinforces previous lessons implicitly. As this is not a game
   programming book and despite the minor issues above, this books
   served its purpose of teaching me J2ME in 5 days (not 21 sorry).



3. Very good tutorial text ... with a nice hands-on approach
   and a working example on every chapter. Strongly recommended as your first book on J2ME. Simple graphical interfaces, persistent storage, connecting to the internet, personal information management..and even a few chapters on game development, which is great since , honestly speaking, is there any of us who wants to use Java on cell phones to make boring contact managment programs?



4. I knew a little bit of Java, and I found this book very good. J2ME is explained pretty good, and the examples are easy to follow. I have developed several applications that I use after reading this book.
   If there is anything that is missing in this book, it would probably be an Appendix with a better description of the different APIs.
   It is a very good book for anyone that wants to learn J2ME, but might be a little boring if you already have J2ME experience. However, if you buy a "Teach Yourself .... in 21 days" book, you are probably not an experienced programmer in the language anyway.

5 comments about Eclipse Modeling Framework (The Eclipse Series).

1. First four chapters of this book are an excellent introduction to EMF. Last section of this book wastes too many pages by listing reference APIs. I would highly recommend that you read equally important EMF overview documents available on the www.eclipse.org site before you buy this book.



2. If you have used Eclipse to program Java, you might have gotten comfortable with its capabilities. Very intuitive and kindly donated by IBM to open source. So when I opened this book, I anticipated oodles of helpful tweaks and shortcuts.

   But not so. IBM has indeed provided these in the book. But their goals were far more ambitious. The Eclipse Modelling Framework is a serious effort to incorporate into a development environment java, XML and UML. They found, perhaps correctly, that most Java programmers, including, and maybe especially the experienced ones, don't really use UML much. Okay, as an afterthought, to document a code base upon a major release. But rarely as a starting point. So one intent is to seamlessly let java programmers incorporate UML. More strongly, they claim that EMF lets you define a model in any of java, XML or UML. Then simply clicking a button will make EMF generate the other 2 forms. The greatest payoff for this is that it lets programmers, who may not be fluent in UML, make a graphical UML model and thence have EMF make the java code stubs. Much less error prone than doing it manually.

   There is an analogy here with Spice, if any of you have an electrical engineering background. Until the late 80s, if you wanted to model a circuit in Spice, you typically drew it by hand on paper. Then you manually transcribed these into a text file of netlists that was input into Spice. Slow and very error prone. Then along came MicroSim, Carver Mead's Magic program and others, that let you construct a circuit diagram on a console, and from which you could press a button and a Spice input file would be made. Much more productive.

   The book offers a similar gain in productivity. All you are asked to risk is your time in understanding the book.




3. This is the best and only work on the Eclipse Modeling Framework, which is the code generation engine built into the Eclipse IDE. It's a solid work, but it's one flaw is that it is neither a completely how-to book, nor is it completely architectural work, so it will probably frustrate most readers to some degree. This is the only reason I didn't give it a perfect rating.



4. This book served as my introduction to Eclipse, and I found it not as helpful as just playing with Eclipse itself. After play time was over, I went to the book again, and saw some improvements that I could have used.

   I don't mean to say that the book is bad. It's a little overweight with Java references, true, but it still covers one of the best Java IDEs available, and the fact that it's better than many commercial IDEs just makes it more pleasing.

   I believe I got this book when I wasn't ready for it, or when I wasn't the main target audience, and that this may skew my perception of it. In any sense, the book just wasn't my piece of pie, but I can see it being someone elses.




5. Just go to google and you will get all of the information in this book.