JavaRanch Book Reviews

Your search returned 76 matching documents

Effective Java:Programming Language Guide by Joshua Bloch, Joshua Bloch
Prentice Hall PTR second edition May 2008 384 pages	Reviewed by Campbell Ritchie, June 2008 (10 of 10) I had been waiting for this 2nd edition for ages, and I have not been disappointed by it. Everything is there: * Why you don't concatenate Strings repeatedly * Confusion between "L" and "l" and "1" * How to get floating-point arithmetic wrong * Why you avoid returning null * Why you always use library classes. These few previous points ought to be taught to even the rawest beginner, but the remainder of the book is only suitable for the more experienced programmer. Bloch takes a tour de force through all the features of the language. Some chapters are about general programming, including the methods inherited from java.lang.Object, others about specific features like concurrency. he book is completely up to date for Java 6. It is clear and easy to read, although dense with information, so one cannot skim through it. Bloch pulls no punches. He tells us the features he likes and which he doesn't. He warns against using finalize() and clone() and calls classes like StringTokenizer, and the older concurrency mechanisms obsolete. Anybody who wants to understand the workings of the language, to get up to speed and write code which really works: you're not borrowing my copy. Buy your own and you will be really pleased with it. Discuss book in the Saloon — More info at Amazon.com
Prentice Hall PTR second edition May 2008 384 pages	Reviewed by Michael Ernest, May 2008 (10 of 10) This updated edition has plenty to recommend it. The chapter "Substitutes for C Constructs" is replaced by two new ones, "Generics" and "Enums and Annotations." Some existing items are amended to reflect these constructs. Some new ones promote the use of concurrency over traditional Java threads. All in all, the second edition boasts 78 items compared to the first edition's 57 items. As before, the justifications driving each item are lucid and compelling, and much, much more valuable in my mind when used to assert confidence in a proven technique. I understand some people come to Effective Java as a primer. I can see how it woud be useful as such, but the arguments laid out seem to me more valuable once you've fumbled a bit on your own. One item ("For instance control, prefer enum types to readResolve") amounts to a retraction; I consider it a sign of strength, that the book has so little to apologize for. Sometimes you want answers on best practice from the best authority you can find. If you have a better source than Google's Chief Java Architect, share! I remain impressed by and indebted to Bloch for his simple, elegant style. I've been waiting for a long time to read his take on these new topics. Thank you Josh! Discuss book in the Saloon — More info at Amazon.com
Prentice Hall PTR second edition May 2008 384 pages	Reviewed by Jeanne Boyarsky, July 2008 (10 of 10) The second edition of "Effective Java" is almost like a completely different book from the first. There were new chapters addressing Java 5 topics such as generics, enums and autoboxing. Existing patterns were rewritten for Java 5/6 - both conceptually and for the code examples. For example, overloading now address varargs. The number of items grew from 57 to 78 as well and the author removed the old ones that are obsolete. As a reference, chapter one provided a table to quickly find items on Java 5. The appendix provided a cross mapping to find items from the first edition in this copy. For those new to "Effective Java", it is meant for intermediate to advanced Java developers. It provides best practices, recipes and idioms for working with Java. The author is good about listing both advantages and disadvantages to choose when to apply a tip. When thinking about my favorite chapter, I have trouble picking just one. I'm torn between the concurrency and enum chapters. The book goes beyond the common "use enums over constants" and goes into things like EnumBitSets. I learned a lot reading the first edition of this book and learned just as much reading the second. If you have the first edition, but this one anyway. And if you haven't read the first edition, get your hands on the latest copy! Discuss book in the Saloon — More info at Amazon.com
Prentice Hall PTR 1 edition June 2001 272 pages	Reviewed by Peter Tran, August 2001 (10 of 10) Have you ever overridden the equals() method, but not have it work correctly? Do you miss some of the C constructs and wonder how you can do the same thing in JAVA? Have you ever wished you could come up with better design for your classes? Then this book is for you. First, this is definitely not a book for beginners. I'm not saying you have to be a guru to appreciate the material presented. I made a lot of the same mistakes Joshua pointed out in his book early in my JAVA career. For example, the check list for Item 7: Obeying the general contract when overriding equals, will more than pay for the book when you don't have to spend several hours trying to figure out why your equals() implementation isn't working. (If my manager is reading this review, let it be known that this book wasn't available a year ago, and implementing equals() correctly isn't trivial!) The book is littered with examples of actual design patterns used in the JDK library, and the material is very up-to-date with references to the JDK 1.4. Anyone aspiring to write good JAVA code that others will appreciate reading and maintaining should be required to own a copy of this book. This is one of those rare books where the information won't become obsolete with subsequent release of the JDK library. A definite must-have for any JAVA developer/programmer. Discuss book in the Saloon — More info at Amazon.com
Component Development for the Java Platform by Stuart Dabbs Halloway
Addison-Wesley Professional 1 edition December 2001 368 pages	Reviewed by Margarita Isayeva, March 2002 (9 of 10) I used to think about Java as a programming language: design, coding, debugging and when my classes are compiled - the game is finished. This book shows that a new round of the game starts from here. The objects turn into "components", and Java, the language, becomes a platform for component development. The author examines its basic features: class loading architecture, type information (Java class format), Reflection API to access this information - on top of these basic mechanisms many high-level technologies, like EJB, JSP, RMI, are built. And if you understand the underlying concepts, many mysteries with those technologies are solved. Better yet, now you do not have to rely on existing technologies, you can design and develop your own. To wake up your imagination, the book shows how you can extend Java class format, write your own custom Class Loaders, add arbitraty functionality at run time via dynamic proxies, and - my favourite subject - to grant routine programming to code generators. There are three reasons why I would love a book: it gives me either conceptual understanding, or details on what's going on "under the hood", or a bunch of practical advice. It's not often that one book includes it all. Discuss book in the Saloon — More info at Amazon.com
Java Collections by John Zukowski
Apress 1 edition April 2001 420 pages	Reviewed by Bodie Minster, November 2001 (9 of 10) Java Collections is the most relevant and well-organized Java book I have read. There is a lot of detail provided, but not so much that it's painful to read. No space is wasted rehashing language basics. Fine distinctions between similar methods in the API are spelled out, and there are lots of examples given in good practice for the use of the API. The code snippets are clear and very illustrative in almost every case. Take the time to read the Historical Collection part, because there are a few meaty little tidbits in here that even the pros may have missed. This is not a monument to the author's arcane Java knowledge, unlike other advanced texts. If you are planning to use the collections API professionally, do yourself a favor and read this book! Discuss book in the Saloon — More info at Amazon.com
Java Rules by Douglas Dunn
Pearson Education 1 edition October 2001 720 pages	Reviewed by Margarita Isayeva, January 2002 (10 of 10) I liked this book a lot yet was uncertain how to evaluate it. A book should be judged according to the law of its genre and I had difficulty in defining what the genre is. Finally I found the word: "commentary". Commentary on Java "legal code" - a set of specifications - JLS, JVM, Inner Classes, Unicode standard, selected parts from Java API, even JavaSoft tutorial on the Collection framework, with detailed explanations. Two first chapters, "Lexical Structure" and "Compilation Units" reflect on corresponding sections of the JLS. Inner classes, static, super, and this keyword (chapter 3) are covered to a depth I've not seen before. The chapters on data (4-5) include not only primitives and String/StringBuffer, but also BigInteger, BigDecimal, Date, Calendar, NumberFormat classes which makes the whole approach fundamental and encyclopedic. The last sixth chapter covers the Collections framework. Here the discussion becomes especially pedantic and it could have been quite a boring reading if the author did not reveal principles that underlie the framework's design. Those insights seem turn magically the framework's apparent anarchy into order, my boredom into epiphany, and author's pedantry into blessing. Overall impression: the topics chosen are covered both deeply and fully. Explanations are always clear and complete, nothing is left for the reader to guess. The fact that the book is about Java basics should not mislead you: beginners are not the target audience. You need a firm grasp of the language to appreciate the discussion. Discuss book in the Saloon — More info at Amazon.com
Practical Java by Peter Haggar
Addison-Wesley Professional 1 edition February 2000 320 pages	Reviewed by Paul Wheaton, April 2000 (9 of 10) An excellent book covering some of the finer points of Java programming. I saw the author speak at a conference and he's an excellent speaker too. This book covers optimization tips and gotchas in Java. I liked the way the book was organized to I could easily skip over stuff I didn't care about or already knew about. I expect I'll refer back to this book frequently. Discuss book in the Saloon — More info at Amazon.com
Bitter Java by Bruce Tate
Manning Publications 1 edition April 2002 368 pages	Reviewed by Madhav Lakkapragada, June 2002 (8 of 10) "Bitter Java" is a "sweet book". While the previous statement sums-up my opinion of the content of the book, it wouldn't be fair not to say why. If you have the basic knowledge of J2EE components and would like to know "where to use a component" or more precisely "where NOT to use a component" this is the book you want. The books walks you through the most common mistakes a programmer with academic knowledge would do. Okay, you did a couple of tutorials on the web, you now "feel" you have knowledge of J2EE, so what next? I would say, read this book - it will teach you how to identify anti-patterns in your code and their ill-effects. Once you identify these anti-patterns and sense the "bitterness" the authors teach you how to redo your applications using some well-known design patterns. Anti-patterns in the areas of Servlets, JSPs, Security, Caching, Server-Side Memory leaks, Connections, amd briefly XML are covered. You don't really need a whole lot of design pattern knowledge, though a basic knowledge wouldn't hurt. Design patterns and anti-patterns are explained with example code. The original and refactered code is very well documented with appropriate remarks followed by detailed explanations. As the moderator of the JSP forum, I have seen many questions posted on topics that were addresed in this book. Although, while taking the first steps in J2EE, you don't give much importance to anti-patterns, when you get into a production environment you must have this knowledge. While the examples in this book "may" appear basic, I think they are sufficient and clearly make the point. Glad that I was able to review this book. Discuss book in the Saloon — More info at Amazon.com
Advanced Java 2 How to Program by Harvey M. Deitel, Paul J. Deitel , Sean S. Santry
Prentice Hall unknown edition October 2001 1496 pages	Reviewed by Johannes de Jong, December 2001 (8 of 10) As complete a coverage of the Java platform as one can get. Each chapter briefly explains the Java technology it covers and then shows you how it is used. Every listing is explained in detail. I find the explanations clear and easy to understand. I however hated having to page back and forth in the book to see the explained code in context. Separate listings book ? Their case studies are relevant and can be used as a great resource for your own projects at home and at work. It would have been nice if Class Diagram's were added. This would have helped one to understand the solutions better. Considering the pure volume of the example code you will forgive me that I did not install and try it all. But what I've played around with compiled and worked perfectly. The accompanying CD is a gem. Other authors should use it as an example to see how it should be done. I was especially impressed by the installation instructions for the accompanying software; clear, precise and accurate. Yep I have to say something about it. I love the color they use extensively in the book. It makes the reading of listings especially easy. This book must be one of the most complete Java books available at the moment. I highly recommend it. A note of caution, don't expect in depth overage on each subject. There simply is no space. They however provide extensive resources for further studies. Discuss book in the Saloon — More info at Amazon.com
Core Java by Horstmann, Cay S. / Cornell, Gary.
Prentice Hall PTR 5th edition December 2000 832 pages	Reviewed by Johannes de Jong, July 2001 (8 of 10) If you want to learn Java and OO from scratch this book is definitely NOT meant for you. If however you want to get a deeper understanding of the Java fundamentals (yes this book has been aptly named) and how you implement OO in Java this book is a must. I kept on catching myself saying "hey that's neat" when I finally grasped an important fundamental (yes that word again) that has alluded me up to now. (I've been playing with Java for 5 months). What I especially liked about the book is that the authors explained why a specific solution was chosen. They did not just leave me in the dark. At times they even suggested alternatives. My complaints: They waste unnecessary pages with code that hardly gets discussed. A simple reference to the CD would have been enough, heck they even supply a great editor (TextPad) to read and compile it with. I still had to correct quite a few examples manually after I'd downloaded the latest version of their code. Surely they could have updated it ? The Core Java Web page can be found at Core Java. The rest of Mr. Hortsmann's site is also worth a visit. "A solid foundation to improve your basic Java skills". Discuss book in the Saloon — More info at Amazon.com
Prentice Hall PTR 5th edition December 2000 832 pages	Reviewed by Mary Jane Swirski, August 2002 (8 of 10) Beginner? Then this book is for you! I am a COBOL programmer & found this book very easy to read. Concepts are easily explained then example code is provided, great for anyone new to Java or OO concepts. I would recommend this to any green-horn who is trying to learn the java language without the benefit of an professional instructor. The only downfall of the book: it provides no exercises, and I fervently believe that to become a good programmer one must practice their coding. Discuss book in the Saloon — More info at Amazon.com
Prentice Hall PTR 5th edition December 2000 832 pages	Reviewed by Paul Wheaton, January 2000 (2 of 10) When I had about eight months of Java experience, I read the Core series. After reading Just Java 1.1, the core series were awful by comparison. They had a lot of errors coming from taking a book on 1.0 and sticking in a few 1.1 paragraphs and calling it a 1.1 book. I don't know if the 1.2 series is better - I haven't bothered to look since Just Java 1.2 works so well for me. Discuss book in the Saloon — More info at Amazon.com
Java Platform Performance: Strategies and Tactics by Steve Wilson, Jeff Kesselman
Prentice Hall PTR 1 edition June 2000 256 pages	Reviewed by Randall Twede, May 2001 (8 of 10) With the latest release of java, version 1.3, performance is less likely to be a problem. Between the new hot spot virtual machine and performance tuning in the various packages, java is much faster than before. However, performance is important and if you have a performance problem this book most likely has the information you need to identify where the problem is and techniques you can use to remedy it. Many of the techniques described in this book are based on knowledge the author gained while improving the performance of the Swing toolkit. The book is well written, easy to understand with good examples. Many of the sample codes are useful in their own right. I'm glad it's on my bookshelf. Discuss book in the Saloon — More info at Amazon.com
Java Performance Tuning by Jack Shirazi, Jack Shirazi
O'Reilly second edition January 2003 600 pages	Reviewed by Thomas Paul, March 2003 (9 of 10) Once the business rules have been settled and all that is left is to tune the code, then the fun starts. Like a race car mechanic trying to squeeze out a couple of extra MPH from a race car, the most fun in programming is to try squeeze out extra performance from some code. A book on performance tuning should understand that and make the topic fun. Reading this book it is clear that Jack Shirazi loves to tune code. He has done an incredible amount of detailed research on different JVMs to determine exactly how to make Java perform. But he is also practical. He explains how to find performance problems, which exact areas to concentrate on, and which areas to ignore. After reading this book you won't waste your time on areas of code that can't be easily optimized and instead you'll know how to concentrate on those places where you can get the most bang. The book has been updated from the earlier edition to bring all the information up to date with the latest JVMs. Best of all, an additional 250 pages has been added to the book covering J2EE including Servlets, JSPs, EJBs, and JDBC. "Java Performance Tuning" is a programmer's book. You are guaranteed to learn a lot of very neat and useful tricks. I doubt that there is another Java book on the market with as many "WOW!" moments in it. Buy it and watch your code zoom. Discuss book in the Saloon — More info at Amazon.com
O'Reilly 1 edition January 2000 436 pages	Reviewed by Thomas Paul, April 2001 (8 of 10) You have been working on that Java application for two weeks and it's finally ready for testing. Your window for having the web site down is ten minutes but you aren't concerned. Three hours later with the program still running, you are more than concerned. Before you panic, pick up a copy of "Java Performance Tuning". This book is geared for serious developers who need to dramatically improve performance in their applications and are willing to dig deep into the code. For example, writing your own customized Reader and byte-to-char converter can be ten times faster than using the BufferedReader class. Shirazi starts off by showing how to measure performance and identify bottlenecks, including a way to override the Object class to measure object creation. Subsequent chapters discuss key performance issues and possible solutions. Topics covered include replacing Strings with char arrays, eliminating casting and minimizing object creation, removing method calls from inside of loops, writing your own sort routines instead of using Arrays.sort(), identifying the correct Collection object, using threading to improve performance, and optimizing distributed systems to decrease network communication. As Shirazi explains, some of the methods covered may violate encapsulation or other OO techniques so they should only be used when performance has been identified as a critical problem. Besides being well written, the book is fun. I found myself trying to figure out along with the author how to improve the performance of the various examples demonstrated in the book. Discuss book in the Saloon — More info at Amazon.com
Professional Java Programming by Brett Spell
Peer Information 1 edition December 2000 1111 pages	Reviewed by Jane Griscti, February 2001 (8 of 10) Just passed the SCJP exam and wondering what's next? This book introduces you to topics you'll need to deal with on a regular basis as a professional Java programmer: Class Design, Threads, Event Handling, Layout Managers, Swing Components, JDBC, XML, Security, JavaHelp, JNI, Performance, and Distributed Objects. The author doesn't pretend this book will make you an expert in each area; he does, however, explain the fundamentals of each topic and provide examples of how-to implement the behaviors commonly expected in applications supporting each subject area. What is lacking is information on where you can find additional resources for each topic. This is the first WROX book I've read and I liked the way the material was presented. The examples progress from the simple to the complex and Mr. Spell provides clear explanations as to both why he chose to implement the behavior as he did and how he added the functionality. The source code for the examples can be downloaded from the WROX site. While I did not compile all the examples, I had no problems compiling and running the one's that caught my immediate interest. This is one book I plan to dip into often. Discuss book in the Saloon — More info at Amazon.com
Advanced Programming for the Java 2 Platform by Calvin Austin, Monica Pawlan
Addison-Wesley Longman unknown edition September 2000 400 pages	Reviewed by John Ternlund, November 2000 (8 of 10) This book covers the basics of some advanced programming techniques by building small examples utilizing these techniques. I am a BIG fan of looking at example code and like having lots of good examples at my finger tips. The key words here are "lots" and "good". This book succeeds in providing some useful examples for an advanced Java developer to look at. It attempts to cover a lot of information in a small book and manages to provide some decent examples of entity and session beans, RMI, some CORBA, a little JDBC, Servlets, and JNI. It also has some nice sections on Java debugging and performance tweaking. Like any "example" type book, the examples contained in it may or may not be the examples you are looking for. Discuss book in the Saloon — More info at Amazon.com
The Java Virtual Machine Specification by Tim Lindholm, Frank Yellin
Prentice Hall PTR second edition April 1999 496 pages	Reviewed by Kathy Sierra, May 1999 (8 of 10) You don't need the intimate details of the Virtual Machine to be able to program in Java. This book is designed for those who write compilers and VMs. But it can really help you understand exactly how Java -- the language -- is implemented. Besides, think how smart you'll sound when you walk around saying cool opcodes like "baload, bipush, i2f". This new second edition is updated for Java2 and also cleans up inconsistencies between the first version and the language itself. Discuss book in the Saloon — More info at Amazon.com
Data Structure & Problem Solving using JAVA by Mark Allen Weiss
Addison-Wesley second edition August 2001 928 pages	Reviewed by Peter Tran, May 2002 (7 of 10) It's amazing how many people who develop software for a living and have no concept of data structures. More often than not, these developers will either write unmaintainable code or fall into the write everything from scratch syndrome resulting in very inefficient and buggy code. Anyone who is serious about becoming a professional developer should learn the fundamental data structure such as link list, hash map, trees, etc. The prior incarnation of this book was written in C, C++, Ada, and JAVA (1st ed.). The 2nd edition builds on Mark's experience with this subject and does a commendable job of referencing the JAVA Collections classes where appropriate. Data structure is only one step above automata and formal language analysis in dry subject matter, but nevertheless, it's just as important. For most people, the subject matter isn't consider a pleasant night reading, but the next time you apply for a job and the interviewer asks you to describe how a hash map is implemented in JAVA, you can confidently answer the question. Personally, I think everyone should be familiar with data structure and Mark A. Weiss's book is as good a book as any on the subject matter. Discuss book in the Saloon — More info at Amazon.com
Advanced Techniques for Java Developers by Berg, Daniel
Wiley unknown edition February 1999 528 pages	Reviewed by Frank Carver, December 2000 (6 of 10) A strange mixture of a book. Despite claiming on the cover that it "Fully Covers JDK 1.1 and 1.2" it was, in fact one of the first books to be rushed into print when Java 2 was announced, and thus lacks the depth and detail of many others. It reads as if the authors have just picked a few interesting topics and written a chapter about each. Many of the chapters are only of marginal or historical interest (Network Computers, JavaOS and JavaStation, for example), some have been superseded (the servlets chapter covers servlets 1.0, JWS 1.0 and HotJava), but others are still relevant (distributed development, RMI, networking, JDBC, IO, beans etc.) but even these are not covered in much depth. This book might be worth while if you find it in a discount bin, but for actual use you'd be far better off with a few books each of which covers one of the useful topics in more depth. Discuss book in the Saloon — More info at Amazon.com
Java Pitfalls: Time-Saving Solutions and Workarounds to Improve Programs by Michael C. Daconta(Editor), et al
Wiley 1 edition April 2000 336 pages	Reviewed by Salman Halim, June 2003 (8 of 10) The book contains fifty pitfalls that are arranged in eight categories with a brief description of each pitfall at the beginning of the category. This allows the book to be used as a reference after an initial look-over. While there will be the initial item that discusses relatively less advanced topics such as language constructs or the usage of the 'finally' clause, there are plenty of other items that will hit home resoundingly. Early on, I found items 14 and 15 (both dealing with cloning) to be quite instructive. Good, solid book -- covers enough topics to contain something useful for just about everybody. Puts the problems in context and provides explanations for what might be going wrong. The pitfalls are usually illustrated with code and examples of cases where they might come up. They cover many topics such as GUI design, performance and Collections and are discussed quite thoroughly. A nice thing is that many of the pitfalls aren't programming ERRORS, per se, but design problems that might affect maintenance -- for example, the maintenance difficulties that arise from a class with a single complex constructor or lazy loading to aid performance. There IS the occasional typographical error (usually in code) but nothing crippling. Recommendation: new programmers should read the book. Busy experienced programmers could treat it as a reference and only look at topics related to their current project. However, a straight read won't be a waste of time for even experienced programmers. Discuss book in the Saloon — More info at Amazon.com
Wiley 1 edition April 2000 336 pages	Reviewed by Ajith Kallambella, December 2000 (6 of 10) Efficient programming only comes with experience and only those who know the pitfalls know how to avoid them. This book is not for beginners. Familiarity with different API packages such as java.util, java.io, java.awt, and javax.swing is necessary. The book is neatly categorized into eight logical sections. Each section contains several "gotchas" of Java language that can catch you unaware. Each of these "nuggets of wisdom" teaches you about some specific drawback of Java language and the different ways you can steer away from the pothole. Each topic is short, crisp and is accompanied by code. The book has a little bit for every kind of reader. If you are not an amateur but always get stumbled on language subtleties, check out the items - Usage of String equals () method versus the = = operator, the "hidden field" pitfall, properly cloning an object and why one should avoid using a constructor while implementing clone() method. These language 'features' have the potential to make you debug the program for several days. If you are an experienced Java programmer you will benefit from the topics such as - reclaiming references when using SoftReference objects and sending serialized objects over sockets etc. For architects and the performance-savvy, the book has some interesting implementation patterns such as handling huge collections with caching and persistence, better data validation techniques, lazy loading for better performance and using object pools for excessive object creation. The book lacks sections on popular (and error-prone) topics such as Threads, Networking and Remote Objects. Some code samples contain minor syntax errors. There are some lengthy Windows SDK programs which may not appeal to those from non-windows background. Last but not least there is no accompanying source CD. Discuss book in the Saloon — More info at Amazon.com
Java 1.2 Developer's Handbook by Philip Heller, Simon Roberts
Sybex unknown edition September 1998 1011 pages	Reviewed by Kathy Sierra, May 1999 (6 of 10) This is NOT a certification guide for the Developer's exam, or for the 1.2 Programmer exam. It is simply a book packed with useful, well-written information on advanced topics. This book is for AFTER you pass the SCJP and it's time to move forward. Discuss book in the Saloon — More info at Amazon.com
Algorithms in Java, Parts 1-4 (Third Edition) by Robert Sedgewick, Michael Schidlowsky
Addison-Wesley Professional third edition August 2002 768 pages	Reviewed by Matthew Phillips, September 2002 (7 of 10) This book is volume one of a three part series. It covers fundamentals, data structures, sorting, and searching. This book is very detailed with good examples and well-placed exercises to reinforce the knowledge. The author does a very good job of avoiding unnecessary mathematical explanations. I spent two weeks reading this book, but to get a firm grasp of the subject matter expect to spend a lot more time. I did find a few things that I did not like about this book. My biggest complaint is that answers are not provided to the exercises. No benefit is derived from doing it wrong and thinking you are doing it right. I also think that the examples would be much improved if the property and method names better described their purpose. Variable names like M and l are common in the example code and leave the reader with a little bit of extra work to do in understanding the code. Overall, the positives outweigh the negatives in my opinion and make this a worthwhile book for any new Java programmer looking to take that next step. Discuss book in the Saloon — More info at Amazon.com
Java NIO by Ron Hitchens
O'Reilly 1 edition August 2002 312 pages	Reviewed by Valentin Crettaz, November 2002 (8 of 10) The New Input/Output (NIO) packages of the Java 2 platform introduce several long awaited advanced I/O features for developing high-performance and large-scale Java applications. It is not unsafe to say that these new capabilities bridge the gap between Java and other natively compiled languages. The author starts by giving some insights on some system-level I/O services before delving into how low-level features are abstracted by NIO in a portable way. He assumes the reader to be fairly comfortable with Java and common I/O concepts, that is, the book should not be seen as a tutorial on Java I/O. The book dedicates one chapter to each new feature, namely low-level buffer management, scalable networking and file channels, multiplexed I/O using selectors, and character set encoding/decoding. As last, the author presented a Regular Expressions API that brings Perl-like capabilities into the Java language, as a feature that is often used when performing I/O operations, although it is not strictly related to I/O. This is a first book on Java NIO, which is a well-written resource and contains a several concrete and ready-to-use examples illustrating various key concepts of the NIO packages. Discuss book in the Saloon — More info at Amazon.com
The Java 3D API Specification by Henry Sowizral, Kevin Rushforth, Michael Deering
Addison-Wesley Professional second edition May 2000 652 pages	Reviewed by Nathan Pruett, November 2002 (8 of 10) This book is a very good reference to the Java 3D API. It goes a step beyond the JavaDocs and whitepapers available from Sun's site and gives detailed explanations of every class in the entire Java 3D API. Scene Graphs, Behaviors, Geometries, Attributes, and the rest of the API are covered in detail. It even has chapters on input and sound devices, and appendices on the inner workings of Java 3D, covering topics such as 3D Geometry Compression, View Model Details, and equations used. However, I would not recommend this book to beginners... there is an overview of the Java3D package, but unless the reader is familiar with 3D graphics (and Java) they will quickly become lost. I also wish that more code examples were provided illustrating the topics as they were discussed. Example code is provided on the CD, but it is hard to pull the pertinent sections out of the example programs. Code snippets are also provided to illustrate some concepts, but it is a difficult task to figure out what you need to do to get these to actually compile and work. Another problem is that this book covers the 1.2 Java 3D API, but the 1.3 API has been released. So some people may want to wait for a newer edition of this book to come out. Overall, I would recommend this book as a good reference book for people who really need to have a good understanding of the Java 3D API. Discuss book in the Saloon — More info at Amazon.com
Java Development with Ant by Erik Hatcher, Steve Loughran
Manning Publications 1 edition August 2002 672 pages	Reviewed by Michael Ernest, February 2003 (9 of 10) Maybe it's me getting tool old or too out of step with books on popular tools, but I found this guide informative, thorough, and quite tedious to read. The information is fine, although it has that ring of authorship by people who are too close to the technology. That is, while they do strive to give practical applications of Ant in a variety of contexts, sometimes I feel like I'm reading a paraphrased specification. The coverage of related tools is pretty cool, actually, and it's important since Ant is a useful integration glue. At the same time, I stack this book next to my O'Reilly guide on make, and wonder why it was necessary to go into so much detail. I didn't benefit from so much example work, which really boils down to yet more XML tags. At some point it would have been nice if the authors had said a little more about Document Type Definitions and then left some topics as exercises to the reader. It's a fine reference and referral book; but I do think it could have been shorter and more to the point. Discuss book in the Saloon — More info at Amazon.com
Data Structures and Algorithms in Java by Robert Lafore
Sams second edition November 2002 800 pages	Reviewed by Thomas Paul, February 2003 (9 of 10) Just about every Computer Science program requires a course called "Data Structures and Algorithms". In order to become a better programmer you must understand the information provided in this course. This book was written as a textbook for a "Data Structures and Algorithms" course and all the expected topics are covered; arrays, queues, stacks, linked lists, trees, hash tables, heaps, sorting, recursion, and searching. Whether you are a teacher looking for a text, a student who wants a better text than the required one, or someone who wants to learn more about programming, this book is an excellent choice. By using Java, all the complications of C++ are eliminated and the author's crystal clear explanations come shining through. And the author's explanations and examples are excellent. For example, the chapter on link lists explains what a linked list is, what problems it is supposed to solve and what problems it fails to solve, and then shows how to implement your own link list. The author provides a set of applets to visually illustrate the topics covered in the book. There are questions at the end of each chapter and answers are provided. This book is not going to explain the Collection classes or help you learn the API. What this book will do is help you get a deeper understanding of what data structures are, how they work, and what performance sacrifices must be made in order to achieve better overall performance in your programs. Discuss book in the Saloon — More info at Amazon.com
Technical Java: Applications for Science and Engineering by Grant Palmer
Prentice Hall PTR 1 edition April 2003 496 pages	Reviewed by David O'Meara, June 2003 (6 of 10) While reading this book I kept wavering between enjoying the information presented and wondering what it was trying to accomplish. It begins with sections dedicated to people moving from C, C++ and Fortran, but there isn't enough coverage and it doesn't say much more than "Java is not so different". The sections on differential equations, integration and Fourier transformations are useful, but some of the examples get caught up explaining more about the problem than the solution. At times you may be learning more about fluid dynamics than technical programming. There are also short sections on IO, GUIs and web based applications that may be useful as an introduction to the topics in Java, but you would get better coverage of the IO and GUI features in a beginners book. There are plenty of examples of technical problems presented in the book, but I can't see it persuading C or C++ developers to make the move to Java. The book does get the message across that Java is a great choice for building technical programs, but you might be better off with the combination of a beginner Java book for the syntax and a language neutral book for the algorithms. If Java is going to be accepted for building scientific and engineering programs, more technical books need to be written using Java as the reference language. I'm not sure this book counts, but it might be a place to start. Discuss book in the Saloon — More info at Amazon.com
Prentice Hall PTR 1 edition April 2003 496 pages	Reviewed by Simeon Pinder, June 2003 (9 of 10) This book is not directed at typical java developers but more for scientific programmers predominantly using other languages to write numerical analysis applications. Don't get it twisted though, there's lots of information here for java developers writing numerical analysis code. Many science and engineering programmers think java is too slow and is ill suited for "hard core" numerical analysis. This book is clearly written and dispels many misconceptions concerning java and its math capabilities. For starters, there are transition chapters for traditional numerical analysis programmers from C, C++ and Fortran, which highlight differences to be aware of if you make the switch. Next up are a few chapters on java basics and syntax for the uninitiated, while communicating sound OOP practices. The author makes the switch look a little too easy, but ok. Following was an exciting chapter pitting the innate java math libraries against the big numerical analysis three (C, C++ and Fortran). That was cool. The next eight chapters were worth the purchase off the bat. Complete with clear descriptions, use case examples and implementation code (I'm a big fan!) for numerical analysis techniques involving matrix operations, solving differential equations and Fourier transforms to name a few. The math isn't trivial. As a java developer holding B.S. degrees in Computer Science and Molecular Biology, I have many colleagues who misunderstand java and its capabilities. This book, by a NASA engineer of 18 years, demonstrates how java addresses their analytical needs. Discuss book in the Saloon — More info at Amazon.com
More Java Pitfalls by Michael C. Daconta, et al
Wiley 1 edition February 2003 300 pages	Reviewed by Salman Halim, June 2003 (8 of 10) This book continues where the first one left off; the items covered herein are given a more in-depth treatment than those in the first volume and include new Java technologies: J2EE, J2ME, EJB etc. The layout of the book has been changed from its predecessor to consist of three big sections, one each for the client, Web and enterprise tiers. There is still plenty of useful information here: for example, I found the breakdown of web.xml in item 35 and unique EJB primary key generation in (item 42) very informative. One critique is that some of the items leave questions unanswered. As examples, item 13 suggests sealing JAR files to ensure precedence in class loading but doesn't really explain HOW to seal a JAR. Similarly, item 16 points out how Component.setSize() can't always be used to reliably set the size of components; it explains how to do it correctly, of course, but never really explains what setSize() CAN be used for! While the book isn't error-free, they aren't major and don't detract from the value of the information. Recommendation: get the book collectively and keep it as a reference, sharing it among friends or colleagues. A quick once-over to see the topics covered is sufficient, I think; a cover-to-cover read isn't necessary. Discuss book in the Saloon — More info at Amazon.com
JDK 1.4 Tutorial by Gregory M. Travis
Manning Publications 1 edition March 2002 408 pages	Reviewed by Rob Ross, August 2003 (10 of 10) The book "JDK 1.4 Tutorial" by Gregory M. Travis has proven to be a valuable resource to me over the last year. Even though the 1.4 version of the JDK has been out for a while now, many applications and development teams are still using the 1.3 JDK. When they finally make the switch to 1.4, this book is all they need to quickly bring them up to speed on all the goodies that the new JDK has to offer. Note that this book is NOT a general-purpose java tutorial; there are plenty of other books that cover that topic. As the author states, "The ideal reader of this book is an intermediate or expert Java programmer who needs to use the new features of JDK 1.4." The book covers NIO (New Input/Output), Java Web Start, Logging, Assertions, Regular Expressions, Preferences API, and the Secure Socket Extension. It also covers the changes and additions the 1.4 JDK introduces to the Java2D and Collections API, and enhancements to the Exceptions mechanism. The book covers these topics in great detail and provides source-code examples for how to best use the new features. In my own development work, I have found the chapters on Advanced NIO, Assertions, and the Preferences API most valuable, and the examples in the book allowed me to very quickly implement the new functionality in my applications. I have used the book both as a tutorial for the new 1.4 features, as well as a reference source for exploring the detailed intricacies involved in using the new APIs and in both cases I have found the tone and style of the author's writing to effectively convey the information in a clear, concise manner. If you are an experienced Java developer and want to learn about all the new features in the 1.4 JDK, this is the book for you. It's well written, includes extensive coverage of the new features, and doesn't waste any pages with "HelloWorld" tutorial programs that are covered already in countless beginner's Java books. Discuss book in the Saloon — More info at Amazon.com
Algorithms in Java Part 5 Graph Algorithms by Robert Sedgewick
Addison-Wesley Professional third edition July 2003 528 pages	Reviewed by Gregg Bolinger, October 2003 (10 of 10) Robert Sedgewick continues his discussion on algorithms in java with the second book of his Algorithms in Java series. Graph algorithms is Part 5. My favorite aspect of this book is the fact that Robert talks about algorithms in a very generic sense. As algorithms should be discussed. But then he shows me how to use and construct these algorithms using a language that I am familiar with; Java. Robert wastes no time jumping right into the topic of discussion. And from cover to cover there are code samples, illustrations, graphs, and very understandable explanations. Anyone reading this book better know what they are getting into. This book assumes more than intermediate knowledge of the Java language, but assumes nothing about your knowledge of graph algorithms. So be prepared to be intrigued, a little confused at times, but most of all, educated. Discuss book in the Saloon — More info at Amazon.com
Hardcore Java by Robert Simmons Jr
O'Reilly 1 edition January 2004 400 pages	Reviewed by Valentin Crettaz, May 2004 (5 of 10) My first thought when I saw this new book on O'Reilly's web site was: "Well, there must be some really cool Java hacks hidden behind this rather evocative title." Basically, it's one of those books where you expect the next page to actually delve into the real matter and give you some crispy details. My personal impression after finishing it was that the content was a little lightweight for deserving to be qualified as "hardcore", but maybe I'm being too harsh. The author handles a good deal of "advanced" topics, such as the effective use of Collections and nested classes, constants, immutable types, reflection, proxies and the four different flavors of references. Also qualified as hardcore, the novelties introduced by the upcoming Java 1.5 release are also part of the story... I have always regarded O'Reilly's books as high-quality work (and I still do), but I have never been able to find 50 typos in any of their books before. I'm inclined to interpret this fact as if the book had been rushed to press to be on the shelves before JDK 1.5 comes out. I just wish the book had been more thoroughly proofread. On a more positive note, I'm quite sure medium and advanced Java programmers will be able to distill valuables tips and tricks from this book. On the companion web site, the author also provides the sources of all the examples illustrated in the book. Discuss book in the Saloon — More info at Amazon.com
Java 2, v5.0 (Tiger) New Features by Herbert Schildt
McGraw-Hill 1 edition July 2004 216 pages	Reviewed by Lasse Koskela, August 2004 (8 of 10) If you already know Java and want to utilize the impressive array of innovations contained in Java 2, v5.0, this book is for you." That's actually from the back cover of the book and I have to say I fully agree. Schildt has brought us many useful titles and "Java 2, v5.0 (Tiger) New Features" is no exception. The delightfully small book (a hair below 200 pages) packs just enough information to upgrade your know-how to the level of the latest Java version. Each topic (generics, autoboxing, enums, for-each, static imports, varargs, annotations, formatter, scanner) is explained clearly and concisely with expressive code samples. Schildt even lets you in on how the compiler handles some of these syntax enhancements, which I especially enjoyed reading about. The major features of each new addition is discussed in more detail and the less common methods are given a one-sentence description, which suits me, personally, quite well as long as I agree with what's common and what's not. Talking about agreeing on what's common, the only real gripes I have with "Java 2, v5.0 (Tiger) New Features" is that the author completely by-passes the addition of java.lang.instrument and java.lang.management packages, only mentioning that those have been added. I would've certainly expected to read at least a page worth of overview on the actual services those packages provide. In summary, I'd say you can't go wrong with this book. It's not a "complete reference" nor is it intended to be. It's a quick path to knowing just enough to feel comfortable diving into Java code written "Tiger style". Discuss book in the Saloon — More info at Amazon.com
Better Faster Lighter Java by Bruce A. Tate, Justin Gehtland
O'Reilly 1 edition May 2004 262 pages	Reviewed by Valentin Crettaz, August 2004 (9 of 10) Next year, Java will finally get a second digit in its age. Over the past 10 years, Java has become one of the most popular language on earth. Popularity is usually a positive sign but it often hides a double-edged sword as an ever increasing indigestible amalgam of (cough reusable cough) Java libraries/frameworks flood developers everyday. No one will argue that it becomes increasingly difficult to make the right decisions when it comes to choosing existing libraries/frameworks for developing new products and/or refactoring older ones. Don't worry, you are not alone. Bruce Tate and Justin Gehtland have made a tremendous effort of popularizing some fundamental principles that, when applied consistently, can considerably ease your life. They introduce the following basic principles: "Keep it simple", "Do one thing and do it well", "Strive for transparency", "You are what you eat" and "Allow for extension". They also show how two famous open-source frameworks, Spring and Hibernate, elegantly apply these five principles. Finally, they take their own "better-faster-lighter-java" medication by applying it on the Simple Spider project and show how the latter can easily be integrated into the infamous jPetStore application. I definitely enjoyed reading this book even though it is not necessarily about pure coding. However, I would like to warn entry-level programmers as they might not enjoy the occasional philosophical tone. As well, they might not have had the chance to be frustrated yet which is THE assumption the authors make. Discuss book in the Saloon — More info at Amazon.com
Java 1.5 Tiger : A Developer's Notebook by David Flanagan, Brett McLaughlin
O'Reilly 1 edition June 2004 200 pages	Reviewed by Ernest Friedman-Hill, January 2005 (8 of 10) The foreword to this new O'Reilly series explains that a "Developer's Notebook" is the raw scribbling of an "Alpha Geek" as he or she examines some exciting new technology. That pretty much describes "Java 1.5 Tiger." It's raw, it's scribbling, and it's exciting nonetheless. At a slim 177 pages, this is one of the shorter general Java books you're ever likely to see. There isn't a lot of fat between these covers. Over the faint blue graph-paper lines and the cute faux coffee stains, the concise text covers just the biggest new features in JDK 1.5: generics, varargs, autoboxing, annotations, printf, enumerations. Many of the plentiful code examples are sensible and give you a realistic idea of how to use a feature. Some of them, unfortunately, are rather contrived and don't make much sense. My main brickbat for "Java 1.5 Tiger" is the very high incidence of typos, more in the text than in the code. Raw scribbling is one thing, but accuracy is important, too; a programming book demands it. My main bouquet is that I learned a lot from reading it, and honestly, you can't do much better than that. Discuss book in the Saloon — More info at Amazon.com
O'Reilly 1 edition June 2004 200 pages	Reviewed by Jeanne Boyarsky, August 2004 (10 of 10) "Java 1.5 Tiger: A Developer's Notebook" has all the information and quality we have come to expect from O'Reilly However, the developer's notebook series has a very different style than the animal books. The book was a true page-turner and I read all 171 pages in two days. This book really looks like a notebook complete with notes in the margins, graph paper and coffee cup stains! There is also plenty of room in the margins for the reader to add notes. This book is informative, useful and looks really cool! A guru narrates the book. He tells you about Java 1.5 and answers your questions. Each chapter discusses several labs in a task/how to I do that?/what about ... format. It is like the author walks you through doing the labs. It really does read like a conversation. As the authors put it: "All lab, no lecture." The code examples begin on page two and are prevalent throughout the book. The authors give warnings about common pitfalls and tasks that you cannot do -- just like you would expect a guru to do. The authors also give opinions and recommendations. The book assumes a working knowledge of java 1.4 (or earlier.) This is especially important in the concurrency section. There is excellent cross-referencing so the chapters and tasks can be read in almost any order. I would not give a 10 unless a book was amazing. This one earned it! Discuss book in the Saloon — More info at Amazon.com
Decompiling Java by Godfrey Nolan
Apress 1 edition July 2004 280 pages	Reviewed by Valentin Crettaz, October 2004 (8 of 10) Fascinated by the Java lady? Ever wanted to ask her out but never dared to? Get this book and take a shot. After discussing some legal and moral issues and telling you how to protect yourself, this book will teach you how to approach her and ask her out politely. Then, it will delve into the most intimate details of her bytecode attributes and show you how to manipulate them efficiently. Also, the author briefly describes a couple of free and commercial tools you can use to play with her. The book goes on describing techniques you can exploit to protect her sources from being seen by anyone. Such techniques include: obfuscation, encryption, server-side execution, digital rights management, fingerprinting, native implementation and many more. The second half of the book is fully dedicated to designing and implementing a working Java decompiler from scratch using the JLex and CUP (i.e., Java implementations of lex and yacc). Basically, I very much appreciated the way I have been introduced to this wonderful and charming lady. Our chat was both enjoyable and enlightening. However, the date was over when the whole thing started to get interesting and I admit that 250 pages left me hungry. I would have liked to see a couple more concrete examples discussed and analyzed in minute details. Nonetheless, this book is a very good introduction to the topic and would satisfy both beginner and medium Java developers willing to peek beneath the lady's bytecode veil. Discuss book in the Saloon — More info at Amazon.com
Apress 1 edition July 2004 280 pages	Reviewed by Lasse Koskela, September 2004 (7 of 10) "Decompiling Java" is an interesting piece of work. In just 250 or so pages, you'll go through legalities related to decompiling Java code, learn the basics of Java's class file format, get a brief run-down of tools available for decompiling and obfuscating Java code, all the way through different methods employed by obfuscation tools. Finally, Nolan goes through the design of a basic Java decompiler implementation using JLex and CUP open source compiler compiler tools. The brevity of the book is both its best and worst characteristic. It's great because I certainly wouldn't have wanted a bible on copyright and patent laws in different parts of the world, but it's unfortunate because the topic you're interested in is bound to be slightly too superficial or detached from the rest of the book. For example, I would've liked to read a lot more about the actual class file format and the internals of a JVM in the book itself instead of having to read from a specification on the web. On the other hand, the author managed to light some bulbs in my head along the way and I actually enjoyed reading his text - especially the chapter about creating a decompiler using JLex and CUP (which I've also found a bit too intimidating to actually look into). In summary, "Decompiling Java" is a good overview of decompilation in Java and it has a couple of real gems inside, but if you're looking for a manual for dissecting class files or the JVM, it might not the book you're looking for. Discuss book in the Saloon — More info at Amazon.com
Java Reflection in Action by Ira R. Forman, Nate Forman
Manning Publications 1 edition October 2004 300 pages	Reviewed by Thomas Paul, December 2004 (10 of 10) There are only a handful of books that every Java programmer should own. This book manages to enter into that elite group of books by providing exceptional coverage of an area of Java programming that is generally poorly covered and often misunderstood. Reflection is a topic that many programmers know about but don't truly understand. Reflection can provide simple ways to get out of complex problems, which makes it well worth knowing. Reflection is one of those tools that you never knew you needed until you learn it. The authors have been working with reflection for years. They attack reflection in small pieces, making each topic crystal clear before moving on. In keeping with the "action" from the title, the authors show examples of each aspect of reflection, breaking down each line of code with complete explanations. The book starts with the basics of reflection, looking at how to examine a class at runtime and dynamically load it. The book then moves on to demonstrating how to use the Proxy class. Later chapters show how to examine the call stack, customize class loaders, and transform one class into another. Performance is covered with a chapter that gives some good examples of benchmarking the cost of using reflection. The book ends with a look at the impact of Java 1.5 on reflection. The best advice I can give is, buy this book. You will be amazed at the things that you didn't know you could do with Java. Discuss book in the Saloon — More info at Amazon.com
Core Java 2, Fundamentals by Cay Horstmann, Gary Cornell
Prentice Hall PTR 7th edition August 2004 784 pages	Reviewed by Thomas Paul, December 2004 (7 of 10) This is the seventh edition of this book and in some ways it hasn't changed much since the first edition. The first edition was aimed at C++ programmers who were looking to transition to the new language. The seventh edition is still fast-paced and detailed and aimed for the experienced programmer. The authors assume that you already know the basics of programming even if it isn't with an object oriented language. The book might make a fairly good college textbook but not as a first language. The book covers the main areas that you would expect in an introductory Java book with a few surprises. The book gives a little bit of the history of Java and shows how to install and run Java from the console and Eclipse (but not NetBeans). There is an early introduction to reflection but exception handling isn't covered until well into the book. Swing is covered in a fair level of depth. J2SE 5.0 changes are covered throughout the book with the many examples written to show off the new additions to the language. Threading and Collections are not covered. Overall this is a well written book who is the target audience? How many C++ programmers can be left that don't already know Java? For an introductory tutorial this book may be a bit too advanced. Through seven editions, Core Java has changed little other than to reflect language changes. Perhaps it's time to rethink the franchise. Discuss book in the Saloon — More info at Amazon.com
Core Java(TM) 2, Volume II--Advanced Features by Cay S. Horstmann, Gary Cornell, Cay Horstmann, Gary Cornell
Prentice Hall PTR 8 edition April 2008 1056 pages	Reviewed by Michael Ernest, May 2008 (10 of 10) In my review of Professional Java JDK 6 Edition, I said I didn't think one book could cover so many topics and serve the reader well. This volume is an exception that proves the point. It is a monster book, easily several months of steady work to get through, and an useful reference afterwards as well. It is well put together, clearly written, methodically presented. I wouldn't put it down if that were possible. The coverage is broad and the examples are interesting. The topics also feel complete, not because they are thorough, but because they leave off right where intermediate-level programmers could work out most details on their own. I read the first and second editions years ago. I must say this title is a case study in steady, disciplined, tireless improvement and refinement of the original. It's 990 pages, but I haven't come across a useless sentence yet. The authors haven't just added on. They've refined their examples, improved and replaced others. Most importantly, they've realized a format that puts boilerplate and API tables to the side, allowing the reader to focus on the concept at hand. Complete code listings are presented in a way that's easy to pass over in favor of the files available by download. If you need lots of code work on different topics to urn Java into your fingertips -- and there is no better way to do it -- this book is an excellent choice Discuss book in the Saloon — More info at Amazon.com
Prentice Hall PTR 7th edition December 2004 1024 pages	Reviewed by David O'Meara, April 2005 (8 of 10) I've always been impressed with the quality of the 'Core' series and happily this book is no exception. My first impression of "Core Java 2, Volume 2 - Advanced Features" (7th Edition) was that the book contained too much information and was too small for the task it had set itself. However it didn't long for me to revise this perception. Java 5 includes a huge number of new features. This book does its best to expose you to the new features and doesn't give a definitive example for each part, but provides at least enough so you know what they're for and can spot them in the wild. The examples strike the right balance between length and detail so that you're onto the next topic before getting bogged down in the current one. There is a good mixture of code snippets and full source included, though sometimes I felt the excess could have been trimmed for a few of them. Personally I loved the coverage of Threading, Collections, Security and XML, but there was enough in each chapter to make it worth reading. This is an excellent resource for any programmer looking for a quality Java 5 text, although you'll want to consider pairing it with volume one if you lack programming experience. Whether you have experience with the features in the new version or not, the depth of information makes it an important book to add to your bookshelf. Discuss book in the Saloon — More info at Amazon.com
Java Puzzlers : Traps, Pitfalls, and Corner Cases by Joshua Bloch, Neal Gafter
Addison-Wesley Professional 1 edition July 2005 304 pages	Reviewed by Ernest Friedman-Hill, November 2005 (9 of 10) First, let's get this out of the way: you're not as smart as you think you are. Seriously. You don't know everything about Java. It's possible, however, that these authors do. "Java Puzzlers" shows you more tricky corners of the Java language than you ever expected could exist. Not odd behaviors of obscure API classes, not failings of a particular implementation, but known consequences of the language specification itself. Each puzzler, written in an engaging and often humorous style, gives you a chance to figure things out for yourself before lowering the boom to let you know that, once again... you're wrong. If you read this book and take its message to heart, you'll learn to avoid the dark alleys of Java, making sure your programs will never inadvertently become puzzlers for you or those who come after you. Discuss book in the Saloon — More info at Amazon.com
Addison-Wesley Professional 1 edition July 2005 304 pages	Reviewed by John Wetherbie, August 2005 (9 of 10) This is a fun book that's educational, too! The purpose is to help the reader learn about traps you can fall into coding in Java through the use of code puzzles. There are 95 puzzlers with each puzzle and associated solution discussion running two to three pages each. Appendix A provides a quick summary of the various traps identified in the book and the puzzlers in which they appeared. Appendix B describes the optical illusions scattered throughout the book. In general each puzzler has a very short description of what the program appears to do and the program itself. It is your job to figure out what the program actually does and more importantly why. The following page is a discussion of why the program actually does what it does. Important points and traps to avoid are bolded in the discussion. Note that some of the puzzlers depend on you having Java 1.5. Bloch and Gafter want you to think about and be aware of the language features and APIs you are using along with having fun. Read the description and the code, determine what the code does, run the code, and then, in most cases, rethink your analysis. Then read the solution and think about what the authors are saying. Go read the sections of the Java Language Specification or other references mentioned in the solution. Truly an enjoyable book! Full Disclosure: I received a free copy of this book for review. Discuss book in the Saloon — More info at Amazon.com
Beyond Java by Bruce A. Tate
O'Reilly 1 edition September 2005 200 pages	Reviewed by Mark Spritzler, November 2005 (8 of 10) First I have to laugh. Because this is one of those books where the author is either trying to get people mad, just to see their reactions, or they really know what's going on and are the first to say so, and therefore be burned at the stake. Or they are just morons who have no clue. I think after a number of reviews have come in for this book, I think you will find all of them cover the above three. First, this book makes me think and makes me want to look further into Ruby on Rails and continuation servers. They sound interesting. Second, some of the things Bruce says in this book seem to contradict themselves when it comes to him sounding off at Java's shortcomings. First he says he doesn't like the "verbosity" of generics (Java 5.0), then he talks about having to use Iterators and the code you have to write to loop through Collections (Java 1.4). Meaning that for his argument, he'll use Java with version 1.4, and in another he'll use Java 5.0 But only to "prove" his argument. He jumps back and forth. I can do that in any language, use a fault in a much older version to use in an argument about the version today. I think some of his "pluses" for using Ruby is because he hasn't used a dynamic typed language before, and not seeing the trade-offs and other maintenance problems that come with dynamic typing. We'll have to see. I also respect Bruce, because I really enjoyed his Better Faster Lighter Java book. Buy this book for the entertainment value from either side, the I want to beat him up, to I completely agree with him 100%. Either way you will have fun reading it. Discuss book in the Saloon — More info at Amazon.com
Java Concurrency in Practice by Brian Goetz, Tim Peierls, Joseph Bowbeer, David Holmes, Joshua Bloch, Doug Lea
Addison-Wesley Professional 1 edition May 2006 384 pages	Reviewed by Ulf Dittmer, July 2007 (8 of 10) Java has had multi-threading capabilities from the beginning, but with the arrival of multi-core and multi-processor CPUs on desktops everywhere, and the broad range of new concurrency features in Java 5, there are no excuses any more not to take advantage of multithreading. Getting it right can be tricky, though, and that's where this book comes in. It explains not just the features of the Java virtual machine and the class libraries that help implement concurrent applications, but also serves as an introduction to the problems arising in multi-threaded code in general. That can range from the small -how to share a class variable between threads - to the large - how to structure applications to take advantage of concurrency. More specialized chapters deal with threading in GUIs (important for Swing developers), how to maximize performance while retaining thread safety, and how to test concurrent code. All concepts are explained with plenty of code examples that show what is and what isn't thread-safe. If several ways to solve a concurrency problem exist, their functional and performance differences are investigated, and -where possible- quantified. Engineering consists of tradeoffs everywhere, and this book makes clear how those between functionality, performance and thread safety can usefully be made. Everyone not having had the benefit of CS 401 "Issues in Concurrency" will get a lot out of this book. And those who did will learn how to properly implement concurrent applications in Java. Discuss book in the Saloon — More info at Amazon.com
Addison-Wesley Professional 1 edition May 2006 384 pages	Reviewed by Lasse Koskela, June 2006 (9 of 10) I've been doing most of my recent consulting in technology companies building systems that deal with concurrency, which is part of the reason why this book ended up on my desk -- I wanted to upgrade my know-how on the new concurrency features in Java 5 and a brand new book from recognized authors in the field sounded like a great source of information beyond the javadocs. And it is. I'd almost call this the current bible on Java concurrency. At less than 400 pages it's relatively compact and still manages to properly cover a lot of ground. The text is easy to understand and avoids "difficult" words better than Doug Lea's "Concurrent Programming in Java", although it's been a couple of years since I read Lea's earlier book. What I really like about the book is the thorough discussion on not just the API but also on the underlying theory. In other words, you're not just reading about the new synchronizer objects, thread factories or the executor architecture -- you're also getting the low-down on a lot of what's happening inside the JVM. This, on the other hand, also makes the book somewhat less approachable as it might be if the authors would just give you the "tutorial". I did have hard time figuring out some sections on the first time around but I can't say it was because of the authors' writing. In any case, definitely not a course book for Java Programming 101. It was a positive surprise to see the authors dedicating a chapter for testing multithreaded code. I would've wanted to read more on the topic, but the material in this one chapter is already a huge help in helping the reader to understand some important differences between unit testing the logic and the concurrent behavior of Java code. I'm giving a big thumbs-up for "Java Concurrency in Practice". Besides the couple of pages in my copy having print quality problems (the copy we have at the office doesn't, so it's probably a one-off case), I don't have much negative things to say about this book. If you're looking for an advanced title on concurrency programming in Java, you won't go wrong with this one. Discuss book in the Saloon — More info at Amazon.com
Addison-Wesley Professional 1 edition May 2006 384 pages	Reviewed by Janeice DelVecchio, October 2010 (8 of 10) Wow. So many examples! I love books that really SHOW me what's going on. This was my first real in depth look at threads. When I first got this book, I said, "wow, kindof a smallish book for a big deal subject...." I assure you: there's a ton of material packed into this book. I can bet that everyone could benefit from the concentrated knowledge in this text. I mainly got through the first section of the book, the fundamentals. There's talk about easy-ish stuff like definitions and use of volatile and synchronized keywords, and a way more in depth description of what happens in the JVM and why. I will be reading this whole section over again because it's a whole lot to wrap my head around. I really enjoyed picking at the code examples and using the snippets to work through what was going on. This was really helpful in helping me understand the concepts. The only (minor) downfall is the book goes like a steamtrain through the material. Because of this, I wouldn't recommend this book to anyone without a very good understanding of core Java, and at least some foundational knowledge of threads and threadsafety. The other sections of the book look at design, performance, testing, and advanced topics. This is a book that will remain in my collection and be used time and time again. Discuss book in the Saloon — More info at Amazon.com
Java 6 Platform Revealed by John Zukowski
Apress 1 edition July 2006 240 pages	Reviewed by Henry Wong, October 2006 (9 of 10) A few interesting points about this book. This book assumes knowledge of Java up to Java 5. In fact, it assumes deep knowledge of Java. You will be treated as an experienced developer that needs to get up to speed with Java 6. This book covers enough to get you started. You will understand what changes were made, and how to use the new or changed features (with code snippets). Anything more complex requires a bit of research into the Java documentation -- of which you will be provided the JSR to obtain the information. This book is short. At slightly above 200 pages, it can be read in a single sitting. These points may give an impression that this is not a useful book. This is not the case. In fact, I was very impressed with it. The purpose of this book is to get the reader up to speed on Java SE 6, and as quickly as possible. In this regard, it does the job very well. The chapters discusses the core classes, I/O classes, AWT/Swing, JDBC, XML support, Web Services support, along with some interesting enhancements, such as the Compiler API, Scripting API, and new Annotations. The chapters are also written in a fashion that can be read independently -- so if you are only interested in databases, you can jump right to the JDBC chapter. I highly recommend this book for any experienced developer considering a move to Java 6. Beginners should look elsewhere. Discuss book in the Saloon — More info at Amazon.com
Scripting in Java - Languages, Frameworks and Patterns by Dejan Bosanac
Addison-Wesley Professional 1 edition August 2007 552 pages	Reviewed by Ulf Dittmer, November 2007 (6 of 10) This book aims to be an introduction to combining Java with scripting by presenting popular Java-based scripting languages, making the case for when and how to use scripting and Java, explaining the prevalent APIs, and showing some useful patterns of how to make it work. A full third of the book is taken up by introducing scripting APIs, namely the Apache Bean Scripting Framework (BSF) and the javax.script package found in Java 6 and its non-yet-released web scripting component. Another quarter is used for an introduction to Groovy, and many examples are written in that language; so if for some reason Groovy is of no interest to the reader that might be a drawback. JavaScript and (to a lesser degree) PHP are the other languages being used. While just about everyone interested in the subject will find something (or a few somethings) of interest in this book, it doesn't feel like a coherent whole. It touches authoritatively on a number of subjects, amongst which the reader will choose which ones are applicable to him, and ignore the remainder. The style is technical, and even through the author seeks to present motivation repeatedly as to why to use scripting with Java, this becomes a bit tedious after a while. Overall the book is quite readable, though, and the numerous code examples interspersed with the text help provide some out-of-the-box applicability of the concepts presented. Discuss book in the Saloon — More info at Amazon.com
Professional Java JDK 6 Edition by W. Clay Richardson, Donald Avondolio, Scot Schrager, Mark W. Mitchell, Jeff Scanlon
Wrox 1 edition January 2007 741 pages	Reviewed by Michael Ernest, May 2008 (6 of 10) Professional Java attempts something I don't think one book can do well, which is to say something useful on every topic. This book's sections include: updates to JDK 5; project methodologies; design patterns; build tools; persistence tools; UIs; web applications; JNI; EJB 3; SOA; security; and packaging and deployment. It wants to be a "one-stop shop," and that's fine, but I can't tell who the target shopper is. Topic coverage varies wildly, in writing style, quality and in the effectiveness of sample code to illustrate the point. Too many descriptions are verbose and phrased in the passive voice. Some code samples seem like a brief sketch rather than a compelling example. Still other samples seem mostly boilerplate code that speeds up the page-turning but doesn't illuminate. And sometimes the text abruptly changes diction, for example from objective description to a "follow-along" coaching style. Some sentences sound like the author left them in as to-do reminders. The result is a thick book that, for me, is sometimes tedious or exhausting to read. I think it would have been helpful to credit each author by chapter, if only to know when the presentation style might change so much. Also, a concerted effort at paring things down, and keeping the diction clear and active, throughout the text, would make it more readable and worth referencing. This book might be handy if you just need many topics covered in one place. Discuss book in the Saloon — More info at Amazon.com
The Object-Oriented Thought Process by Matt Weisfeld
Addison-Wesley Developer's Library third edition 2008 pages	Reviewed by Campbell Ritchie, October 2008 (6 of 10) A little book for experienced programmers, their managers, etc., to explain how one does things "differently" in object-oriented programming. It is easy and entertaining to read, and explains the basics of object-orientation, so might also be suitable for teachers of computing. It shows what the object-oriented way is, with classes, objects, hiding, encapsulation explained. Later chapters explain how to send objects across networks, why databases are usually not object-oriented, etc. There are many illustrations with Java code, and "translations" to Visual Basic and C#. The chapter about design patterns barely scratches the surface, and the section on anti-patterns is so short I think it ought to have been omitted. Unfortunately some of the code fragments incorporate errors, mostly obvious to the experienced Java programmer, which would prevent compilation. There is detailed discussion of a "Cabbie" class and how it relates to Cars and Customers, but there are two odd bits of design: a static companyName field and a no-arguments constructor. Fuller discussion of these peculiarities would have made the book more useful. Access control is discussed, but there are mistakes about what private and protected mean in Java. There are less than 3 dozen references altogether, and they are arranged strangely, and the most interesting quote (page 181) has no source cited and was difficult to find from its keywords in the index. Although I enjoyed the book, I thought it was badly marred by the points I mentioned. More info at Amazon.com
Eclipse Rich Client Platform (2nd Edition) by Jeff McAffer, Jean-Michel Lemieux, Chris Aniszczyk
Addison-Wesley Professional second edition May 2010 552 pages	Reviewed by Christophe Verre, September 2010 (10 of 10) Eclipse Rich Client Platform will teach you how to create professional and redistributable RCP applications. Part I and II look like a tutorial, but the rest of the book goes far beyond. First, you will create a chat application, adding views, editors, actions, help, integrating a third party library... The style is clear, and the progression is logical. API details are left for Part III, where RCP indispensable components are discussed, and that is where the simple tutorial ends. Part IV introduces more advanced features like p2, dynamic plug-ins, product configurations for various platforms, testing... I found that this part required more thinking than the rest of the book, but it is invaluable if you aim at making a professional application. The last part is a reference about Eclipse and OSGi. If you plan to make an Eclipse RCP application, if you have some interest in it or in Eclipse plug-ins, if you just like the Eclipse IDE, this book is for you. You'll learn a lot about the Eclipse architecture, and you will learn it the easy way. I also own another book of the Eclipse Series, Eclipse Plug-ins, 3rd Edition, which I enjoyed a lot. I was not disappointed by Eclipse Rich Client Platform, 2nd Edition. I highly recommend it. Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of JavaRanch. Discuss book in the Saloon — More info at Amazon.com
Addison-Wesley Professional second edition May 2010 552 pages	Reviewed by James Ervin, November 2010 (10 of 10) A common gripe about open source, is how do I get started, start eating the 'dog food' if you will? Popular open source communities solve this by writing 'the standard book' that most people learn from. This is good. Next it goes out of date due to the rapid evolution of the technology. That would be bad. So now to get started, you read a book that is now mostly wrong. Have fun. The Eclipse Rich Client Platform (RCP) book was no different. The first edition was the standard for using Eclipse RCP and, arguably, for any serious plugin developer. It was the best place to learn how to eat the 'dog food'. It is now out of date. The second edi-tion addresses that problem. The book consists of two parts. The first is a rather thorough tutorial building the Hyperbola application. Ever been frustrated by 'HelloWorld' tutorials? Here's the antidote. Hyperbola, while not a fully polished application, is as deep a tutorial dive I have ever seen. It was a useful refresher and introduction to newer features. The second portion will keep this book on your short list of Eclipse reference books. It's a succinct reference on topics of interest. Ever been confused by Eclipse editors, views, actions and how they work together? The answers are there. Personal favorites included information on p2, the chapter on dynamic plugins, the part on the ever mysterious PDE build and finally, the section on OSGi. In conclusion, I recommend this book to developers working with Eclipse, be it using the RCP or writing plugins for the full IDE. This book fills in a lot of gaps that are not well covered elsewhere. After reading, I think you'll discover that the doggie food can taste pretty good. WOOF WOOF --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Addison-Wesley Professional second edition May 2010 552 pages	Reviewed by James Ervin, November 2010 (10 of 10) A common gripe about open source, is how do I get started, start eating the 'dog food' if you will? Popular open source communities solve this by writing 'the standard book' that most people learn from. This is good. Next it goes out of date due to the rapid evolution of the technology. That would be bad. So now to get started, you read a book that is now mostly wrong. Have fun. The Eclipse Rich Client Platform (RCP) book was no different. The first edition was the standard for using Eclipse RCP and, arguably, for any serious plugin developer. It was the best place to learn how to eat the 'dog food'. It is now out of date. The second edi-tion addresses that problem. The book consists of two parts. The first is a rather thorough tutorial building the Hyperbola application. Ever been frustrated by 'HelloWorld' tutorials? Here's the antidote. Hyperbola, while not a fully polished application, is as deep a tutorial dive I have ever seen. It was a useful refresher and introduction to newer features. The second portion will keep this book on your short list of Eclipse reference books. It's a succinct reference on topics of interest. Ever been confused by Eclipse editors, views, actions and how they work together? The answers are there. Personal favorites included information on p2, the chapter on dynamic plugins, the part on the ever mysterious PDE build and finally, the section on OSGi. In conclusion, I recommend this book to developers working with Eclipse, be it using the RCP or writing plugins for the full IDE. This book fills in a lot of gaps that are not well covered elsewhere. After reading, I think you'll discover that the doggie food can taste pretty good. WOOF WOOF --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Java Generics and Collections by Maurice Naftalin, Philip Wadler
O'Reilly Media 1 edition October 2006 288 pages	Reviewed by Jeanne Boyarsky, May 2011 (6 of 10) My first thought on seeing the title "Java Generics and Collections" was wondering how there could be a whole book's worth of material on the topic. There is! The first half of the book addresses generics. It includes concepts like reification (I learned a new word) that helps you better understand how generics actually work. It also includes a number of idioms for dealing with generics that you might not know even if you use generics. The rest of the book covers the Collection API including how each one works and when to each type. This felt somewhat drawn out and repetitive. I would have liked to see the new classes in Java 5 and 6 highlighted more. The downside: Some of the code examples were on the long side and some of the text required a lot of concentration. I also noticed a typo in the name of a Java class in a diagram which feels worse than in text. I also feel too broad an audience is covered. Parts assume you know nothing (in which case you'd be in over your head.) Overall I recommend the book to learn about generics on a level of detail that surpasses the tutorials. Discuss book in the Saloon — More info at Amazon.com
Java the Complete Reference by Herbert Schildt
Oracle Press/McGraw Hill 8 edition 2011 1116 pages	Reviewed by Campbell Ritchie, October 2011 (7 of 10) Always open the Amazon links for these reviews: examine the contents and a few sample pages. We have a lot of pages; 1100 for $60.00 is good value for money. I suspect the binding may not last many years; maybe I'll need a new copy soon! The "tutorial" in "Part I" moves (I think) too quickly for beginners, so I'll review it as "Advanced". I think it is intended for experienced programmers who already understand object-orientation. It covers all the basics, and is easy to read. It includes the first explanation of Object#wait() and Object#notify() which I really understood! The "tutorial" covers syntax before object-orientation, and encapsulation only appears after classes are described. "Part II" goes through the packages, describing their classes and interfaces. Maybe a list of classes could have been replaced by a link to the appropriate page of the API, and the text might not have gone so "fast"? The collections framework section describes all the classes, including legacy code, but doesn't analyse the Set interface with those nice methods which implement set union and intersection. Most classes are demonstrated with short examples. In some cases the examples are obviously abbreviated to save space. The coverage is comprehensive and up-to-date for Java7. "Part III" shows examples of use of Swing, Beans, and Servlets, and "Part IV" some larger example applications. I found only two things I took exception to: the %n tag "inserts a newline character", and java.util.Scanner.nextLine() "returns the next line of input as a String." I would have preferred full-blown object orientation, encapsulation, etc., from the start. But this is a book I shall be pleased to have on the shelf, which I shall make sure to read lots from. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Oracle Press/McGraw Hill 8 edition 2011 1116 pages	Reviewed by Rob Spoor, November 2011 (6 of 10) This book doesn't seem to know what it wants to be. It claims to be a reference but fails at that point. Its definition of reference seems to be listing a lot of methods with little explanation. If I want that I can use the Javadoc pages for free. Even worse, it chooses to describe obsolete classes like StringTokenizer, Stack or Dictionary, but only briefly mentions more interesting features like cookie handling and the concurrent collections. It does list the latter, but doesn't tell me which one I would need in which situation. The book also gives too much attention to applets (in combination with AWT, not Swing), while ignoring more interesting packages like java.util.logging and java.util.zip almost completely. It tries to describe servlets (in just over 20 pages, definitely not enough), but fails to even mention JDBC. It would have been better to either add a few hundred pages, or drop some topics altogether. The book appears to try to be a book for beginners as well. While it does explain the basics, it rushes through them at times. I don't think beginners will like that. I think that Head First Java or even Oracle's own tutorials are better choices to learn the language. What's left is several chapters that experienced programmers already know. Now this isn't a bad book. It does handle several of the new Java 7 features like the Fork/Join Framework, NIO2 and try-with-resources, and some topics like Formatter rightfully have longer sections. I also really liked the chapter on images. However, it doesn't add much that you can't find in Oracle's own tutorials and online Javadoc pages. I'd like to add one thing that really surprised me. While the book is updated for JDK 7, the author doesn't appear to know that the wrapper classes (Integer, Long, etc) have valueOf methods to wrap primitives. I can't remember him using them even once, choosing to use a constructor each time instead. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
The CERT Oracle Secure Coding Standard for Java by Fred Long et al
Addison-Wesley Professional edition September 8, 2011 744 pages	Reviewed by Jeanne Boyarsky, November 2011 (8 of 10) "The CERT Oracle Secure Coding Standard for Java." The name says it all. This is a book about security, no? Actually, it is not. It is a book about security and quality. The authors don't define security in quite the same way I do. For example calling string.replace() and ignoring the result is incorrect. However it is a quality issue. I'm not convinced the relationship to security. In any case, the practices are excellent. They are clearly documented in the form of: attack/flaw bad code example good code example I think the code examples could have been a little clearer. Maybe highlight the differences between the two in longer snippets. I particularly liked the tables where they show severity, likelihood, cost to fix, priority and level. I also like that they call attention to which can be easily found by static analysis. The focus is on core Java (not JEE/web) and a lot of emphasis is placed on threading. The book calls attention to different versions of Java and includes Java 7. Overall a worthwhile addition to the bookshelf. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Java Performance by Charlie Hunt, Binu John
Prentice Hall 1 edition October 2011 720 pages	Reviewed by Deepak Bala, December 2011 (9 of 10) If you have the need to fine tune your java application / VM then look on further. This book covers in great detail how to look for problem areas in a variety of environments. The perspective that the authors have taken is varied. They teach you to measure performance at different levels - OS / Application / VM etc and also teach you to benchmark code. You also get a quick look at high level JVM architecture. The chapters on GC and benchmarking were interesting and added some insight into those areas. I also enjoyed the introduction of tools/plugins which I previously did not know existed. For example I never knew that java JIT compiler activity can be monitored through a tool. Most tools work across operating systems like Windows / Linux and Solaris. The only downside that I found while reading this book is that there are plugs to Sun/Oracle products peppered throughout the book. For example references to Solaris / Glassfish / Oracle Solaris studio / Netbeans etc. But since this is part of the java series I guess that is to be expected. I would recommend this book to a colleague. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Murach's Java Programming by Joel Murach
Mike Murach & Associates fourth edition November 2011 836 pages	Reviewed by Campbell Ritchie, January 2012 (8 of 10) Whenever reviewing a book, consider which audience and purpose it's intended for. This book is obviously for experienced people (Murach produce a "Beginning" book, too) who wish to migrate to Java? programming from another language, and so as to speed up coding teaches both Java? and NetBeans. It fortunately makes no claim to be comprehensive; it clearly focuses on certain classes (see page 366), expecting readers to find other topics for themselves. The book follows the paired pages format often used by Murach, wherever the length of the code fragments permits. It starts with basic syntax, then object-orientation, specialised classes, GUIs, data access, threading and deployment with jar files. Collections and exceptions are included amongst those "specialised classes". I was especially pleased to see that data validation, using error messages was introduced early in the book, and that the exceptions section teaches how to throw Exceptions for incorrect input, as well as how to catch them. The GUIs are created with the NetBeans GUI builder; this allows one to set up the display very quickly without necessarily knowing all the code. It also shows real object-oriented event handling. This book moves very fast and would be particularly on to a course, where an instructor can supply more explanations. I would have preferred to see "for further reading" and references to basic principles e.g. Object-orientation. I found a few errors, eg precedence of ! (p117) Character and Hashtable misspelt (p401, 396). A good book I'm pleased I've read. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Mike Murach & Associates fourth edition November 2011 836 pages	Reviewed by Christophe Verre, January 2012 (7 of 10) Murach's Java programming is a classic Murach book aimed at Java enthusiasts. Following Murach's paired-paged style, with the left page for explanations and the right page for syntax, guidelines and examples, the book drives the reader into the Java world. It even goes a bit beyond the language syntax, by providing chapters on JDBC using the Derby database, and a chapter about XML handling. Each chapter ends with practical hands-on exercises. The IDE used throughout the book is Netbeans. The book is fast paced, maybe because explanations are kept to a minimum, so whether or not beginners are the target audience is debatable. Object-oriented programming needs time to assimilate so some people might find chapters on that subject lacking depth. The book is enjoyable, but I'd recommend it to people with an object-oriented background rather that to complete beginners. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Spring Roo in Action by Ken Rimple, Srini Penchikala
Manning Publications pap/psc edition April 2012 408 pages	Reviewed by Jeanne Boyarsky, May 2012 (8 of 10) "Spring Roo in Action" starts out with an example. Similar to the "Rails demo" where you build a complete application in 15 minutes. The book then moves on to how to use the shell and your IDE with Roo. I particularly liked the part about which files are safe to change vs which are Roo only. The tricky thing with Roo is that readers need to understand a bit about the technologies Roo is generating code for in order to understand the examples. (Spring MVC, JPA, Dojo, Ajax, etc.) The authors cover "the least you need to know to follow." It's more useful as a review than if you've never use the technology. But if you've never used the technology, you wouldn't be generating code for it and expecting to understand it anyway. The other tricky thing in a book like this is that the authors are experts on Roo (and many other things) but not necessarily everything in the book. For example, the JUnit section mixes junit.framework with org.junit packages (3.8 vs 4.0). And assertTrue(a.size() == b.size()) which gives a less clear assertion failure than assertEquals(a, b). This isn't important but I'd caution against assuming everything you read is a best practice. However, the Spring and Roo parts of the book are excellent and I couldn't find any anti-patterns in there. In a Roo book, that's what you want to see. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Sunshine On Java: Secure Web Applications With Code Examples by Natalie "Sunny" Wear
edition July 2012 29 pages	Reviewed by Jeanne Boyarsky, August 2012 (7 of 10) This e-chapter (e-book) covers 3 of the OWASP top 10 (XSS, CSRF and SQL injection.) With a bonus mention of session fixation. While Amazon counts it as 29 pages, once you get past the intro we are down to 24 pages. The author covers the attacks and how to prevent them in a succinct manner. When I first read the chapter, I was surprised to see Clickjacking wasn't included. But then I looked and it is not currently in the OWASP top 10 which was the inspiration for the book. (It is still important though; make sure to read about it on owasp.org.) I would have liked more detail. For example show an example of CSRF along with the different ways to prevent it. It's not enough to say use a filter/token. This introduces issues of its own which need to be addressed. As far as whether to buy the e-chapter, it is a question of whether you would pay $5 for one chapter of a book. A good chapter, but still only one chapter. I think the answer is yes in this case. But I can't bring myself to call it a book so I'm going to recommend this e-chapter to those who are unfamiliar with two or three of these attacks. If you are already familiar with them, just go on OWASP directly. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
The Well-Grounded Java Developer: Vital techniques of Java 7 and polyglot programming by Benjamin J Evans, Martijn Verburg
Manning Publications edition July 2012 496 pages	Reviewed by Jeanne Boyarsky, August 2012 (10 of 10) Want to be a good Java developer? What do you need to know? Java of course. That part is easy. But unless you are a brand new Java developer, you probably aren't up to speed on the latest Java 7 features, the threading model and how bytecode works. Or maybe you haven't caught up with the new JVM languages (Clojure, Scala and Jython.) The book also covers dependency injection, TDD and the like. With lots of code examples, and clear explanations/writing style, I really enjoyed reading the book - and learned a lot. And as technical proofer, I can tell you the quality of the book is good and the examples work! I'm looking forward to scribbling notes in a printed copy. And I know it isn't going to be a book that stays on my bookshelf in the office - too many people will want to borrow it. And I'm sure some of them will actually buy their own copy. Disclosure: I will be receiving a copy of this book from the publisher in exchange for being the technical proofreader for the book. Discuss book in the Saloon — More info at Amazon.com
Regular Expressions Cookbook by Jan Goyvaerts, Steven Levithan
O'Reilly Media second edition September 2012 612 pages	Reviewed by Jeanne Boyarsky, September 2012 (10 of 10) "Regular Expressions Cookbook" covers reg exp syntax in different languages and patterns for building them. I had read O'Reilly's "Mastering Regular Expressions" years ago and liked it a lot. I feel the same way about this book. While the book doesn't require regular expression experience, it is a tough read if you are coming in completely fresh. At least read a tutorial online first. It is a great book for building on basic or advanced knowledge. Chapter two is like a book in itself. The author says you can skip this chapter if you've read "Mastering Regular Expressions" cover to cover. That's me! Yet I still learned a couple things in chapter 2. The rest of the book is recipes. Problem, solution, flavors, languages it works in, variations and lots of description. Some recipes were similar/repetitive. But a 500 page pattern book isn't intended to be read cover to cover. The recipes had a great range from zip codes to ISBN numbers to VAT. I like how the examples build up in complexity so they don't start out being overwhelming. I learned a lot about regular expressions and patterns. And what grep stands for (g/re/p in ed). I also learned about some new Java 7 features like named captures. I liked the parts on performance and Big O notation. Now I have two really good regular expression books plus the pocket reference. Thanks O'Reilly! --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Getting started with Spring Framework by J Sharma, Ashish Sarin
CreateSpace Independent Publishing Platform edition December 2012 324 pages	Reviewed by Jeanne Boyarsky, December 2012 (6 of 10) "Getting Started with Spring Framework" is an intro to Spring book. It covers less material than Manning's "Spring in Action"; however it is a shorter read and costs $15 less, so that's ok. The explanations were fine. There were lots of code examples. My favorite part was the excellent diagrams. I liked all of the chapters except chapter 1. There were a couple of places in later chapters where multiple ways of doing something were presented, and it wasn't clear why you'd choose each way. But what didn't I like about chapter 1 you ask? The chapter starts with a statement that rubbed me the wrong way. To paraphrase: in the old world, developers had to create well structured easily testable maintainable apps-- the implication being that Spring somehow relieves you of this duty. The truth is that you can create a pile of crud in Spring, too. This felt like "Spring is magic" salesmanship and it put me in a bad mood. The rest of the chapter was a mix of concepts critical to understand and a high level overview of things you never see in the book again. I was also taken aback that the author tells readers to download Spring 3.2.0 RC 2. I think it's great that the author was testing with the latest and greatest. It's fine to mention that (although putting it on the back cover is pushing it.) However, someone just learning Spring should not use the release candidate version. The book was self published and this was evident in a few ways. I saw a typo early on ("quiet" vs "quite"), some organizational issues which would have been brought up by an editor, and in general the layout looks like someone just printed a PDF and stuck it in a book with page breaks in some odd spots. The index had a great list of annotations but was missing common words like "security" and "transaction." I guess what I'm saying is that you'd be better off buying the e-book than the printed version. Ultimately, the book was "fine". You can learn Spring from it. If you're looking to save a few bucks and don't need to learn about Spring for web apps, it's probably a good idea. $17 for the e-book and $29 for the printed copy is very inexpensive for a computer book. But I found Manning's "Spring in Action" was a better read. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Core Java vol I-Fundamentals by Cay S Horstmann, Gary Cornell
Prentice-Hall 9 edition 2013 974 pages	Reviewed by Campbell Ritchie, March 2013 (8 of 10) I was pleased to have a copy of this book to review. It is by no means a beginners' book, moving at a fast pace, and often referring to later chapters or VolII, and using a rather "compressed" form of code in its examples. Users of previous editions will recognise the writing style, updated seamlessly so one cannot see the join between "old" and "new". Unlike in some books, there is no "project" running through it, nor end-of-chapter exercises. Again reflection appears unusually early position in this book. It has ~220 more pages than my 2005 edition, but part of that increase comes from moving the threading chapter into VolI. It is an object-oriented book, but assumes readers already know what objects are. It describes aliases, returning mutable references and pass-by-value. Also warnings about potential security hazards and pitfalls. Much of the book consists of a detailed description of different features of the platform. It has probably the clearest description of Java generics I have seen. The threading chapter is also up to date, with Locks before synchronized. This book takes it for granted than the reader already know the working of data structures, Singletons, Immutable classes or invariants, so they are not described. Many differences from C++ are mentioned; although many C++ programmers already know Java, those are potential points of confusion. These differences are less relevant to people who come straight to Java. I disagree with a few things: throwing an unchecked Exception to enable an overridden method to compile, Scanner#nextLine reads the next line. One thing I was disappointed by: the book has only few references. A good resource to get you up to speed in Java. When VolII comes out it will probably also be a very comprehensive resource. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Effective Unit Testing: A guide for Java Developers by Lasse Koskela
Manning Publications edition February 2013 248 pages	Reviewed by Jeanne Boyarsky, March 2013 (10 of 10) "Effective Unit Testing" felt familiar to me. I think it is because I read "Test Driven" and saw the author present some of the content from this title at the 2012 Server Side Java Symposium. You can get a feel for some of the smells from my live blog post of that session http://www.selikoff.net/2011/03/16/test-smells-breakout-at-the-server-side-java-symposium/ Part one sets the stage. It walks you through a hypothetical teams journey - no tests → tests → test driven! I liked the examples of bad code and bad test examples. And I really like the explanation of different types of test doubles. I also liked the example of jMock vs Mockito to do the same thing. Part two shows you a series of test smells and how to fix them. One of my favorites is something really simple. How to make a bowling example more readable by using method names so you can embed "magic values" in the code. I also particularly liked the segment on how parameterized tests can be an anti-pattern along with how to avoid this problem. Part three is "other things." It covers using other JVM languages to test and how to make your tests faster. Both via the tests and running them in the cloud. I really liked the part on how to profile in both Ant (which I knew) and Maven (which I haven't needed to yet.) While there is an appendix to get you up to speed on JUnit, you should read a different book if you are trying to get up to speed on JUnit. I recommend "JUnit in Action" or "Test Driven" for that. Once you know any unit testing framework, it is time to come back to this book so you can write better tests. It was a great book. My only problem was that having seen the session some was repetitive. But I highly recommend both the book and the talk. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
HTML5 Security by Carsten Eilers
Developer.Press edition October 2012 85 pages	Reviewed by Jeanne Boyarsky, March 2013 (10 of 10) "HTML 5 Security" is $4 for 60 pages. It is priced like a standalone short story. And it reads like a full length book. I came away from reading it with three takeaways 1 - lots of info on security 2 - a lot changed in the security space even if you aren't using the new html 5/browser features 3 - scary - some of these attacks are impossible to prevent at the moment The author explains what XSS and Clickjacking are in case you don't already have that background. But read carefully even if you do. Both attacks have "developed" considerably since I learned about them. Plus now we have to worry about SVG and forms and autocomplete and data storage and ... You get the point. Read the book! My only disappointment was that CSRF wasn't covered. Granted it didn't change with HTML 5, but too many people still don't know what it is. This is the second "short story" length book that I've read. I like this one better. It crams more content into the short length. It doesn't waste time with a lengthy intro or other filler. I'd write more, but I need to go tell some other people to buy this book. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Core Java, Volume II--Advanced Features (9th Edition) (Core Series) by Cay S. Horstmann, Gary Cornell
Prentice Hall 9 edition March 2013 1152 pages	Reviewed by Mohamed Sanaulla, May 2013 (9 of 10) I always liked the approach Cay S. Horstmann takes in the examples in his Core Java books. He tries to follow good practices in all his examples which includes better naming convention, documentation and comments, identifying right classes. This book, Core Java Volume-2, is no different. You find examples which are in themselves mini applications. You dont find toy programs which illustrate the feature and do some printing on the console. The examples themselves include different concepts across Java. There are very interesting topics covered in this book like: Steams and Files, XML processing, JDBC, Network Programming, Scripting and Annotations, Security, JNI, Advanced Swing and AWT. I see that few chapters which were originally in Volume-2 have been moved to volume-1 namely multithreading and collections. I see a very exhaustive coverage on Swing and AWT, what I feel missing is the coverage of JavaFX features for which I think a chapter would suffice. Not to forget this book covers the Java 7 features as well. Otherwise this book covers lot of stuff and I would recommend to use it as a reference to pick chapters as and when you want to explore those features. Reading end-to-end may not be necessary because most likely we would not be using all of those features in one place together. Reading end-to-end might be an overkill as well owing to the number of pages. Bottom line: Highly recommend book in your bookshelf of Java references. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Prentice Hall 9 edition March 2013 1152 pages	Reviewed by Campbell Ritchie, September 2013 (9 of 10) I would always advise readers to try before they buy; look at the contents and sample pages on Amazon or similar. There you will find you get 1117 pages, 115 more than in my 2005 edition. That's even more of a change when you remember the threading chapter moved to Vol I. That extra space is full of information, in the inimitable Horstmann & Cornell (H&C) style. They teach object‑oriented programming throughout, with good coding style and emphasise correctness. The book has been updated and uses Java7 constructs throughout, even though the odd use of StringTokenizer escaped updating. And GridBagConstraints appears once instead of GBC (see volume I). This book makes no pretence to comprehensiveness. There is relatively little about servlets, for example, and no design patterns; as I said about Vol I, they assume readers know patterns already. The points for C++ programmers still appear; they are interesting but only of relevance to people coming from C++. Those points are probably important because there are many points where the apparent similarities between the two languages obscure differences. I found the chapters about security and native methods particularly interesting. The index is comprehensive. There are suggestions for further reading, e.g. about advanced graphics. When H&C are unhappy about something in the Java? platform, they say so without hesitation (policytool is criticised on page 833). The only weakness I perceive is the lack of a proper bibliography, which I believe would enhance this book greatly. There is one place where it looks as if a reference had been forgotten. Still, H&C has been a favourite of mine for a long time, and remains a favourite. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Java Coding Guidelines: 75 Recommendations for Reliable and Secure Programs (SEI Series in Software Engineering) by Fred Long, Dhruv Mohindra, Robert C. Seacord, Dean F. Sutherland, David Svoboda
Addison-Wesley Professional 1 edition September 2013 304 pages	Reviewed by Jeanne Boyarsky, October 2013 (9 of 10) This book is a successor to "The CERT Oracle Secure Coding Standard for Java." My biggest gripe with that book was that many of the rules didn't pertain to security. This book was named "Java Coding Guidelines - 75 Recommendations for Reliable and Secure Programs." I like this title much better. Both runtime reliability and maintainability are considered. It's the same authors and style so many good things carry over. Many of the rules are new including security ones such as XPath injection. The book itself is shorter, but I felt like the picked the most important things to concentrate on. I also found this book easier to read than the predecessor. The CERT specific parts are gone like the severity/likelihood/remediation cost/priority/level. I think this is in recognition that something can be important without being an attack. I still think the code examples could have been a little clearer. Maybe highlight the differences between the two in longer snippets. I found myself underlining this in pen as I red. Bold would have helped. I particularly liked the real life example in showing how Oracle themselves fixed some of the vulnerabilities in version 7 of the JDK. The focus is on core Java (not JEE/web). There are still rules about threading, but not as prominently as the previous title. Overall I think either title is a worthwhile addition to the bookshelf. I slightly prefer "Java Coding Guidelines" to the first edition/CERT title. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Selenium Testing Tools Cookbook by Gundecha Unmesh
Packt Publishing edition November 2012 326 pages	Reviewed by Jeanne Boyarsky, May 2014 (8 of 10) "Selenium Testing Tools Cookbook" covers a lot of ground. I've written some Selenium tests and still learned new things in chapter 1. It's not meant to be an introduction book so you should have written a test before. I like the depth on foundations though. From browser plugins to advanced selectors, there is a lot to see. I particularly liked the CSS selector syntax summary. It was good to see JSExecutor covered - I wasted a good amount of time with this on a problem in the past. I liked seeing the page object pattern (which looks like a DSL) and the Actions framework. I like the example of a parameterized test case in chapter 4. I would have liked to see it broken up so not a ton of code in a row though. There are warnings as needed when showing a feature that you might not want to use. Or when showing a feature that is only available in some cases. For example, the HtmlUnitDriver doesn't support taking screenshots. I could write a review without mentioning the JDBC example has a resource leak. It may be "just" test code, but I still remember the time (a decade ago) that I locked out the test database server because my integration test had a resource leak in it. I was skeptical when the book said it covered Java, C#, Python and Ruby. But it really does. This book is going to be a helpful reference to have around when I'm writing future tests. Discuss book in the Saloon — More info at Amazon.com
Java and XML by Brett McLaughlin, Brett McLaughlin
O'Reilly second edition September 2001 550 pages	Reviewed by Thomas Paul, January 2002 (9 of 10) The first edition of this book was considered one of the best on the subject of Java and XML. This new edition has expanded to include the developments in Java and XML over the last year. The author gives a little less handholding on the basics of XML reducing a three chapter introduction in the first edition to a one chapter summary. SAX, DOM, and JDOM all are covered in detail with each topic getting an introduction and an advanced chapter. JAXP 1.1 is covered in sufficient detail. After the introduction to the basic Java/XML APIs, the author moves on to some other interesting topics. The chapters on web publishing frameworks and XML-RPC haven't changed much since the first edition. New chapters on SOAP, Web Services, and content syndication are welcome additions. The book ends with a look at data binding and JAXB. The examples in the book are extremely clear and concise, explaining each topic well without being overly simplistic. As with the first edition, the author assumes that you are familiar with Java but unlike the first edition he assumes you have a basic understanding of XML. If you are a Java developer and you are going to be working with XML then this book is required reading. The coverage of the Java/XML APIs is excellent. As for the other topics, it is a good introduction but for anyone working with SOAP or Web Services, other books will be required. Discuss book in the Saloon — More info at Amazon.com
O'Reilly 1 edition June 2000 498 pages	Reviewed by Frank Carver, June 2001 (9 of 10) The first half of the book covers XML, DTD, Schema, parsing with SAX, DOM and JDOM, transformation, and traversal of XML data, and the second half covers some applications of XML; document and web site styling; remote procedure calls, configurations and a bit about integrating XML with other technologies such as perl. In general this book has good, solid coverage of most of the important aspects of XML and Java. The sensible sections on XML Schema, JDOM and JAXP, elevate it above many others, but you may need a more detailed book if you plan heavy use of DTD. The examples have just enough detail to be usable without swamping the text, which approaches nutshell-like conciseness. The later sections sometimes read a bit like a how-to guide for the authors favourite products from the Apache range - configuration and use of Xerces, Xalan, Cocoon and the non-standard XSP is covered in detail, but other, equivalent products are mostly ignored. XML technology is developing extremely fast, and some aspects of this book are already getting old. A few of the quoted URLs lead nowhere, and mention of newer standards such as the JAXP transformation API, XML data binding and Messaging APIs is a must for the next version. The JDOM examples may also be incorrect soon if the proposed package changes take place. Keep this book on your desk if you are developing XML with Java, and you won't go far wrong. Discuss book in the Saloon — More info at Amazon.com
The Complete Java 2 Training Course by Deitel & Associates (Editor), et al
Prentice Hall PTR fourth edition November 2001 1100 pages	Reviewed by Johannes de Jong, February 2003 (7 of 10) I've always been a fan of Deitel books but I have always found them heavy going to read from cover to cover. I mostly grab their books when I need to know how something is done. I can t remember the time they let me down when I needed help. When I asked to review their Multimedia Cyber Classroom, I wanted to see if it would help me work through the whole book, because I honestly feel that if I could manage to do that, I will become a much better Java programmer. But alas it was not to be. In general, I found the audio parts boring and of very little added value. Good points for me were the electronic Assessment exams but I wish they did the same for Self Review exercises. What I found fantastic was the fact that the complete book, Java How to Program, was available in electronic searchable format. The CD is a constant companion in my briefcase now, it weighs much less than the book I promise you, and I get a lot of joy out of this easy way finding Java knowledge, and for that alone I advise you to get the Cyber version of this fantastic book, if you have the extra money. The book gets a rating of 8, heck everything you want is there, but I'm afraid I can't give the Cyber part more than a 6, which makes a 7 average. Discuss book in the Saloon — More info at Amazon.com
Java How To Program by Harvey M. Deitel, Paul J. Deitel
Prentice Hall 5th edition December 2002 1536 pages	Reviewed by Thomas Paul, March 2003 (8 of 10) Once again, Deitel has published a very impressive book. This new edition has been updated for Java 1.4 with, among other topics, coverage of regular expression and NIO. In addition, chapters on JDBC, Servlets, and JSP have been added. The chapter on object oriented programming and polymorphism has been rewritten and expanded into two chapters. The book has been cleaned up with redundancy removed in order to keep it around 1500 pages. Overall, the book is as complete as you would want in an introduction to Java. The book covers virtually everything in J2SE, gives a good primer on object oriented programming, covers design patterns and UML, and even gives an introduction to server side development. There's enough information in this book for at least two semesters of Java. All this information can be overwhelming but the authors use extensive, well commented color coded program samples to explain each topic. It is almost impossible to turn a page and not find either code samples or a diagram. In addition, there is a natural flow from topic to topic. This book was written as a college textbook and it has a college textbook "feel". Each chapter has well thought out exercises but the solutions must be purchased separately. A lab manual for this book is also available (release date, July 1, 2003). If you are planning on teaching a Java course and you are looking for a textbook this book would make a good choice. Discuss book in the Saloon — More info at Amazon.com
Java Number Cruncher: The Java Programmer's Guide to Numerical Computing by Ronald Mak
Prentice Hall PTR 1 edition November 2002 480 pages	Reviewed by Jason Menard, May 2003 (9 of 10) At one time or another, most of us will likely have to write code performing some amount of numerical computation beyond simple integer arithmetic. As many of us are neither mathematicians nor intimately familiar with the bit gymnastics our machines must perform in order to manipulate numbers, we can get ourselves into trouble if we're not careful. Luckily, "Java Number Cruncher" comes to the rescue. This book is an introduction to numerical computing using Java providing "non-theoretical explanations of practical numerical algorithms." While this sounds like heady stuff, freshman level calculus should be sufficient to get the most out of this text. The first three chapters are amazingly useful, and worth the price of admission alone. Mak does a fine job explaining in simple terms the pitfalls of even routine integer and floating-point calculations, and how to mitigate these problems. Along the way the reader learns the details of how Java represents numbers and why good math goes bad. The remainder of the book covers iterative computations, matrix operations, and several "fun" topics, including fractals and random number generation. The author conveys his excitement for the subject in an easy-to-read, easy-to-understand manner. Examples in Java clearly demonstrate the topics covered. Some may not like that the complete source is in-line with the text, but this is subjective. Overall, I found this book educational, interesting, and quite enjoyable to read. Discuss book in the Saloon — More info at Amazon.com
Logging in Java with the JDK 1.4 logging API and Apache Log4j by Samudra Gupta
Apress 1 edition April 2003 336 pages	Reviewed by Thomas Paul, May 2003 (8 of 10) This book covers the two most popular logging APIS, the one built in to JDK 1.4 and the Apache log4j. The book starts with a brief introduction to logging and why we should care about it. The rest of the book is divided into two parts, each discussing one of the two APIs. The final chapter covers best practices and a brief comparison of the two APIs. The sections on the logging APIs are divided into two parts, the first discussing the features of the API and the next discussing how to create your own custom components to extend the API. The book is very well written. The author does a nice job of combining the discussion with code examples to make the topics clear. He uses UML diagrams appropriately to help the reader understand how a log request flows through the many classes. He clearly explains each of the classes in the logging frameworks and how to properly use them. The discussion of log4j ends with a chapter on the log tag library written for use with JSPs. Overall this is a very good book. If you are doing no more than very basic logging then this book is probably a lot more information than you need. But if you want to incorporate logging into your development projects in more than just a very basic way or if you are interested in comparing in detail the two APIs, you will find this book useful. Discuss book in the Saloon — More info at Amazon.com
Apress 1 edition April 2003 336 pages	Reviewed by Mark Spritzler, June 2003 (8 of 10) Well I thought I was going to be able to knock down a few trees on the Ranch, and sell them, when I read the title of this book. Instead, I learned how to implement the two most popular logging APIs for Java. Now they are so very similar, just different names for classes that do identical tasks. However, Log4j has some more features. The book also explains all the different sources, filters, and formatters that you can incorporate in your apps to log when logging is needed, and present the information best needed to be logged. Now I know what you are thinking, why write a book about logging, I mean the APIs for basic logging are very simple. But throw that thought right out the window or barn. Samudra does a great job of explaining the ins and outs of logging and some best practices. I would highly recommend this book if you want to learn these APIs. If you already have experience with them, then you might be bored. If we had .5 point ratings then I would have put this book as an 8.5. Discuss book in the Saloon — More info at Amazon.com
Java Data Objects by David Jordan and Craig Russell
O'Reilly 1 edition April 2003 380 pages	Reviewed by Ernest Friedman-Hill, January 2004 (8 of 10) Java Data Objects is simple and straightforward, and solves a real problem in an elegant way. Conveniently, this also serves as a description of this enjoyable book from some of the key JDO specification team members. JDO is a recently standardized API for transparent object persistence. A standalone reference implementation is available, as are quite a few commercial and open-source versions that piggyback on relational databases and other storage solutions. JDO's popularity is growing rapidly because of its simplicity, ease of use, and scalability. "Java Data Objects" is a timely and practical treatment of this new API. After a clear and accessible overview, this book first presents JDO in a tutorial style using a simple but nontrivial example application. Later chapters fill in the details where needed: for instance, a whole chapter is dedicated to the difficult topic of object identity. The motivations behind JDO's development are explained well, and comparisons to other object-persistence solutions, including EJB container-managed persistence, are fair and balanced. One of this book's few flaws is that despite the authors' important roles on the standards committee, the rationale behind some of JDO's more puzzling properties are left unexplained. In particular, JDO requires that only a small subset of the standard Collections be supported by a JDO implementation, but this book doesn't explain how this subset was chosen. All in all, an excellent tutorial and reference that will have you up and running with JDO in no time. Discuss book in the Saloon — More info at Amazon.com
O'Reilly 1 edition April 2003 380 pages	Reviewed by Chris Mathews, May 2003 (8 of 10) The first thing to note about this book, is that it was written by David Jordan and Craig Russell, who happen to be key members of the JDO Expert Group (Craig was also the Specification Lead). This obviously built up my expectations for the book and I am happy to say that I was not disappointed. This book does a great job explaining JDO in a vendor independent and portable manner. The first few chapters provide a high level overview of the JDO API and Architecture, read these if you just want to know what all the hype is about. The rest of the book is dedicated to describing all aspects of JDO in detail and clearly explaining how to apply them. JDO concepts are demonstrated throughout with the use of a single problem domain, which makes the numerous code examples flow easily and consistently. My only major complaint deals with the final two chapters of the book, which focus on how to use JDO in application server environments. They are easily the weakest chapters of the book. I found myself questioning much of the advice given in these chapters and some of the terminology used was outdated. Ultimately, I feel that this book would have been better served without the final two chapters. Despite some minor flaws, I would consider Java Data Objects is the definitive book on JDO. Anyone that is interested in JDO shouldn't miss this book. Discuss book in the Saloon — More info at Amazon.com
Java Programming by Poornachandra Sarang
McGraw-Hill Osborne Media 1 edition January 2012 672 pages	Reviewed by Mohamed Sanaulla, March 2012 (9 of 10) Caution: Dont get bogged down by the number of pages. As The books is more of hands on, most of the content is code samples and their explanation. This book explains the concepts by using examples. This is exactly how one can learn the language and its vast libraries. Each topic is supported by an well explained example, and the examples are not trivial. Something that which reminds me of examples in Core Java book. The book starts with Arrays, as the basic syntactical chapters are available online. Topics like Generics are given their due share (unlike in Core Java book, very less of Generics was covered). Interesting to see that advanced concurrency related concepts are also covered and not to forget the new features introduced in Java 7 are also covered as and when required. The "Notes" and "Cautions" are quite useful and informative. Reading the book doesnt bore you provided you sit with the Terminal and a Editor open. I would strongly recommend to code the examples and try to compile and run them. As always one should befriend the API and documentation for help in the long run. Anyone looking for books other than Head First Java can get a copy of this book. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Scala for the Impatient by Cay S. Horstmann
Addison-Wesley Professional 1 edition March 2012 384 pages	Reviewed by Mohamed Sanaulla, July 2012 (8 of 10) - The book covers almost all of the concepts in Scala in a very concise format. - More emphasis on learning by doing. - Lot of exercise problems at the end of each chapter. It is highly recommended to try them out. - The concepts have been divided into varying difficultly levels and the chapters have been arranged so as to facilitate good understanding. - The initial few chapters help Java programs to get onto programming in Scala by not scaring with Functional style of programming. Some of the not so good things: - You dont get to see lot of idomatic scala code. Unlike Core Java where the examples gave the reader an idea of how to organise code. It is acceptable considering the size of the book. - The questions dont have solutions so its difficult to evaluate if your code follows best practices. This would not be the last book you would read, I am sure once you finish this book you would be in a better position to read other Scala books and try to grasp the advanced scala concepts and also learn to write idomatic scala code. The ideal approach to read this book is to practice the exercises and also keep the Scala API documentation handy. Being a newbie with lot of failed efforts to learn Scala, I found this book to be easy to pick scala concepts and also familiarize with the code. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Kicking Butt with MIDP and MSA: Creating Great Mobile Applications (Java Series) by Jonathan Knudsen
Prentice Hall PTR 1 edition January 2008 432 pages	Reviewed by Mark Spritzler, December 2008 (9 of 10) When it comes to MIDP and J2ME books, there is no better author than Jonathan Knudsen. It was about 4-5 years ago that he published his first J2ME book, and it was that book that I learned J2ME very quickly. Jonathan is one of those writers that can break down a technology to its simplest parts and then explain it to us so that we get it quickly. In "Kicking Butt" Jonathan does it again. Keeping us up to date with the latest developments of J2ME. It is great to see him back with this new book to teach the next generation of J2ME developers. The only thing I wish I saw was the part about device manufacturers not implementing specs 100% and making some parts of J2ME (Bluetooth comes to mind) a heck to work with and figure out what is wrong, when it comes down to a company not implementing the Spec completely, but claiming it does. More info at Amazon.com
Google Web Toolkit 2 Application Development Cookbook by Shamsuddin Ahammad
Packt Publishing 1 edition Nov 2010 244 pages	Reviewed by Ankit Garg, November 2011 (6 of 10) This book is a nice introduction to GWT which is suitable for beginners. I myself being a beginner in GWT found this book as a good starting point to learn GWT. One thing you should know however is that this book covers Ext GWT which can be confusing at first. The book starts from the basics of creating a GWT project using Netbeans and moves to creating layouts, forms, handling different events, making Ajax calls and deploying a GWT application. Sometimes it feels like there is too much code and very little explanation of how the code is actually working. The book has many flaws like repetition of similar recipes, and the focus of the book is not entirely on GWT. There are chapters on database design, JPA, JasperReports which is sort of unnecessary. Instead the book could have covered things like how to create a Grid and populating it using GWT. That sort of information would've been more useful. All said this book is one of the very few beginner level books which covers GWT 2. In spite of its flaws the book can be useful for beginners in GWT. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. Discuss book in the Saloon — More info at Amazon.com
Java 8: Lambda Expressions and Streams by Marty Hall
Addison-Wesley Professional edition pages	Reviewed by Bill Gorder, January 2014 (6 of 10) What I didn't like: - I expected more interaction maybe some labs or exercises - Video segments were a little too long to easily stop and start - A lot of repetition throughout the second lesson - I did not care for the narrated slide show format. I would have liked to see a format that capitalized more on this being a video. What I liked: -The examples clearly expressed the concept being taught. -Additional detail on how things worked was provided rather than just focusing on syntax -This was my first experience with the new Java features like lambdas, functional interfaces, method references and the function package. I feel after having watched this video and practiced a bit, that I have a good understanding of the topics. Marty Hall is an experienced trainer and accomplished author. He does a good job covering the topics, and he is certainly first to the market with this course. Given a person knows what to expect going in (this is a narrated slide presentation), I could recommend this course to those wanting an early look at the new Java 8 features if it were not for the price point. This course is listed at $199.00 (although currently I can get it for $100). Both of these prices exceed the value received from the course in my opinion. A book can be purchased at under half the discounted rate, and nothing about the course capitalized on video in a way that made it advantageous over written literature. I would suggest instead to hold off until some of the books currently being written become available. You could also take advantage of one of the early access programs offered by most publishers. If you don't mind the work you can also get a taste from the free tutorials, and blogs scattered about, although no single one of these will cover all the things in this course. If you are impatient and have the extra money to burn, then this course is good from a technical coverage perspective. It covers all the points outlined in the course description and is easy to follow and listen to. If the price were made more competitive, or some extra value was added to justify the cost difference from the upcoming written literature, I would add a couple horseshoes and change my recommendation. --- Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch. More info at Amazon.com
Professional Apache Tomcat by Vivek Chopra, Ben Galbraith, Sing Li, Chanoch Wiggers, Amit Bakore, Debashish Bhattacharjee, Sandip Bhattacharya, Chad Fowler, Romin Irani
Wrox unknown edition October 2002 552 pages	Reviewed by Michael Ernest, February 2003 (9 of 10) This book is a solid, well-rounded guide to using Apache Tomcat and getting the most out of it. The authors cover a wide number of topics, including installation, modification, managing services, and even testing applications for server load. I was particularly pleased with the clean language and style of the book, something I had noted before in Sing Li's Wrox book on Jini. Li is a contributing author here as well. The only objection I have really isn't a fault of the book at all, but it nonetheless hampers my ability to read it carefully. So much work is done these days to convert configuration and property files into XML formats, that books like this one are often forced to explain features by showing example XML files and encouraging the reader to parse it visually. Sweet mama, that's boring; fortunately, the authors keep this aspect to a minimum. I recommend it to anyone who needs a desktop reference for learning all the aspects of Apache Tomcat as they need them. More info at Amazon.com
Mastering Jakarta Struts by James Goodwill
Wiley 1 edition September 2002 360 pages	Reviewed by Paul Stevens, September 2002 (8 of 10) This book takes a good step by step approach to giving the reader an understanding of struts. Good examples and explanations of each topic covered fairly well. Don't let the title (Mastering Jakarta Struts) deceive you. The book says it is meant as a tutorial on Stuts and that is what it is. So if you already have an understanding of Struts this book won't be right. But if you are looking to get familiar with Struts this book is a good starter. I would like to give the author James Goodwill a big thumbs up. The source code for the book was not on the Wiley site and James emailed it to me right away. Discuss book in the Saloon — More info at Amazon.com
Struts In Action by Ted Husted, Cedric Dumoulin, George Franciscus, and David Winterfeldt
Manning Publications 1 edition November 2002 630 pages	Reviewed by Matthew Phillips, November 2002 (8 of 10) Although the title of this book is not descriptive, I cannot deny the author's approach to making the reader a Struts expert is effective. Section 1 is an introduction to Struts. By the end of the section you have written your first Struts application. This is great for someone with no prior knowlege of Struts. Section 2 delves into the details of Struts framework. It gets away from a hands on approach to explain the details. It covers Actions, ActionForms, etc. quite well. The sample code accompanying the explanations is not enough to run, but it did help me understand the topics better. Section 3 continues the same approach to learning as section 2 but concentrates on the presentation layer tools. One of my complaints about this book relates to its coverage of the Struts tag libraries. The chapter is clearly intended to compliment the online documentation at the Struts website and it really doesn't provide much value over it. The coverage of Tiles, validation, and localization are excellent. Section 4 gets back to the hands on approach to effectively tie everything together. The book's organization lends itself to being a great reference, but I would have liked it to take a more hands on approach and build a large application piece by piece. I still learned more about Struts than I knew existed. I would not hesitate recommending this book to anyone that wants to go from Struts beginner to Struts expert. Discuss book in the Saloon — More info at Amazon.com
Programming Jakarta Struts by Chuck Cavaness
O'Reilly 1 edition November 2002 462 pages	Reviewed by Thomas Paul, February 2003 (7 of 10) The target for the book is any experienced Java developer who is interested in Struts but has little or no experience with Struts. The book starts with an explanation of why Struts is a "good thing" and shows how Struts fits into a web architecture. The author then gives an explanation of each of the pieces of the Struts architecture and demonstrates a simple application. Although the explanations were clear, I felt that the author was making the architecture overly complicated by explaining things out of order. A diagram showing the interrelationships of the different Struts classes and config files would have been helpful. The author covers all the expected topics such as internationalization, exception handling, logging, and the Struts tag libraries. The chapter on the Struts tag libraries could have used more examples to make the explanations clearer. The book concentrates on Struts 1.1 and the author does a nice job of explaining the changes from the 1.0 version and the features available in the new version. The chapter on the new Validator framework is clear and the examples are on target. The chapter on Tiles is short but the author does a great job of explaining how it fits into the Struts architecture. The chapter on performance seemed completely unnecessary since there was nothing in it specific to Struts. Overall this book is a good addition to the Struts library. The book has some shortcomings but it provides a good deal of value. Discuss book in the Saloon — More info at Amazon.com
The Struts Framework: Practical Guide for Programmers by Sue Spielman
Morgan Kaufmann 1 edition October 2002 150 pages	Reviewed by Jessica Sant, May 2003 (7 of 10) I found this book's introduction to Struts to be inadequate. I have a very strong understanding of JSP and Servlets and a cursory understanding of the MVC design pattern. After reading the first two chapters I was quite confused about the general workings of Struts. A small, trivial Struts application to introduce the reader to the pieces and how they are inter-related would have increased the understandability ten-fold. However, that might have cut into the author's allowed page count: realize this book is 137 pages soaking wet (including the appendix and index... I don't recommend actually soaking the book). After getting a better understanding of Struts from another source, I came back to learn the details. The author does an good job of explaining how best to use each part of the Struts Framework (that's where the "practical guide" part comes into play). More importantly she notes the possible hang-ups that normally you'd only learn through a bad experience (Don't use instance variables in your Action classes. Don't worry if you forget this rule now -- after you've read the book, this and other gotchas are tattooed inside your head). Overall I'd say this is a very good resource. You'll need to go elsewhere to introduce yourself to Struts (find a nicely explained step-by-step tutorial), but after that, this book will be able to take you most of the way to a well-designed Struts implementation. Discuss book in the Saloon — More info at Amazon.com
Hibernate Made Easy by Cameron McKenzie
Self published 1 edition 2008 434 pages	Reviewed by Mark Spritzler, July 2008 (9 of 10) Hibernate is a subject dear to my heart. It is a database tool that I would not live without. However, it has a steep learning curve. In Hibernate Made Easy, author Cameron McKenzie does a great job in getting someone who is brand new to Hibernate, up and running quickly and understanding the basics of Hibernate to effectively take on its learning curve. Keep in mind when reading this book, that in order to keep it simple, some alternative solutions are not discussed. This is a book to get you started. So it didn't mention that you can have Hibernate automatically search your classpath for @Entity classes, but used addAnnotatedClass() method calls. This is ok, and might be fixed by the time you buy the book. Now, there are many pieces to the Hibernate puzzle and Cameron manages to pick the subjects that are the necessary building blocks to move on to the more advanced topics. If you are just learning Hibernate, I highly recommend this book to take you on the path of righteousness. Discuss book in the Saloon — More info at Amazon.com
Pro Spring 2.5 by Jan Machacek, Jessica Ditt, Aleksa Vukotic, Anirvan Chakraborty
Apress 1 edition August 2008 920 pages	Reviewed by Mark Spritzler, December 2008 (9 of 10) 8 1/2, but since we only have 8 or 9, I liked it enough to make sure I rounded up instead of down. I highly recommend this book to learn Core Spring. It is the only book currently out by Dec 08 that covers version 2.5. Other books still only cover 2.0 I found the writing easy to understand, I found that they covered the material very well with good examples. They cover a lot of material and leave you with great in-depth knowledge in each of those Spring technologies. Now, I don't agree with everything they say in the book, but it isn't that they are wrong, but that I just disagree with certain statements. For example, in a Note section they stated that "They do not encourage the use of annotations on the objects you will persist using Hibernate." Using JPA Annotations, from an ORM tool expert, is a best practice and makes your life so much easier, in my opinion, and many other ORM experts. This note should have been left out of the book, unless they wanted to fully cover why. More info at Amazon.com

The Bunkhouse administrator is Ankit Garg.


Copyright © 1998-2013 Paul Wheaton, Missoula, Montana	Contact Us