Variants Books

I am only about half way through this book and already have learned numerous things about the design of Java as a language and about proper usage of said language. This book is going to be a staple in my programming library and a book recommended to anyone I know working with Java. I am also looking forward to the second edition which is slated to be released in May sometime.

An indispensable, insightful, and well written Java book to add to your reference library. The second addition is due out May 25, 2008.

I ask all of the developers I manage to read this book, after having been introduced to it by a coworker. Great tips, and helpful in clarifying some of those "gut feel" things that come up during pair-programming.

It is incredible to read Joshua's insights. Forget about being a Java Guru or something like that. This book is pure joy to read if you are detail oriented, perfectionist or a student of art of programming in general.

I have started this effort of creating a distilled version of this book coupled with my own reflections at: [...]. To any curious reader though, any such effort is not a replacement for the book itself. It is a masterpiece.

- Kedar Mhaswade

I've been using Java since 1995 and have owned this book since 2001 and it's the only Java text I still turn to. I recommend every Java developer, no matter what level you're at, read this book and read it again every year for the remainder of your career. I doesn't matter who you are or how experienced you think you are -- you will learn from this book. I give "Effective Java" my highest recommendation. I cannot wait for the Second Edition.

If your a Java 2 developer then you need this on your bookshelf. It contains an enormous amount of useful information, examples, etc. for all the classes in java.applet, java.awt, and java.beans. You gotta have it!

The 1.st sentence of the preface says: "This book is intended as a reference rather than a tutorial". Well for an experienced Java programmer this is certainly true, but for a novice who has just grasped the fundamentals of the language and starts to write down his first lines of code this book is an excellent tutorial. Every class has a description and practically every method of every class has its example code where nearly every line is documented, with links to related methods. Looking into these examples one can quickly learn tips and tricks smoothing the learning curve a lot. The Chan's book is miles ahead, in my opinion, the unuseful example codes one can freely download from the Sun's internet pages, full of magic words comining from blue skyes not documented at all, where one has to figure out what any of them is useful for and where you are on your own. One more time: what I say is true for a novice; the senior Java programmer may feel at his ease with the API's documentation of the Sun's JDK.
My last warning: since in Java things change often this kind of books goes into obsolescence quicky. For instance: my copy is the 5th edition (October 2001) and it lacks completely the new Collections class framework.

This book really helps with a huge amount of information and examples for all of the classes in java.io, java.lang, java.math, java.text, and java.util. Wonderful reference book!

This is required on every Java developers bookshelf. It is a wonderful reference.

I strongly recommend this book to all Java users of all levels because no other book describes all classes of java.lang, java.io, java.net, java.util, java.text and java.math packages better. Every class, every method and every exception is explained by very understandable language with good and useful examples. There is no Java language problem you cannot solve with this book.

An awesome book on concurrency that all Java programmers ought to read before embarking on anything more complicated than the primordial Hello World application.

This was a solid book to gaining an understanding of Java concurrency, especially the new concurrency features introduced in Java 1.5

Though the book is admittedly good and valuable in content, the paper quality of the pages is absolutely horrible! One can see through to the next page, and using a highlighter for emphasis is next to impossible. I will never buy this book as long as the paper quality is so poor (as my colleagues have also mentioned).

After reading this book you will probably thank God that you haven't been using threads, but with that being said this book contains all the information you need to start writing code that walks the straight and narrow path.

This is "the" authoritative book on java concurrency. However, apart from some java specific items, the book is an excellent source on parallelism in general. Do not even try to implement parallelism without "reading and understanding" this book. Highly recommended !!!

I disagree with those who have reviewed this book as suitable for unexperienced programmers. Java 2: A Beginner's Guide is a solid and well written book but in my opinion it is not a book for someone who has no or very little programming experience.

The first couple of chapters are fairly easy to follow but later chapters become somewhat difficult for the novice. I would definitely recommend this book for anyone who has prior programming experience in Fortran or C but if you are looking to learn Java as your first real computer language you should look elsewhere first.

I would compare Java to learning calculus. Something you really should not do before completing arithmetic or algebra. I would recommend getting your feet wet with something like RealBasic (www.realbasic.com) which, for example, introduces the concept of classes in a much more manageable format. Another great approach would be the programming language of 4D (www.4d.com). Both of these are available as free full working demo downloads and would give you an easier slide into the programming world.

After taking a class on Java, I bought this book to review based on other reviewers comments and it's low used price. I was not disappointed. This is an excellent value for the beginner/intermediate. Written clearly and plainly there is no wasted space in the book. You will need another source for swing/graphics (perhaps the newer editions?) but as a beginner's guide this book truly delivers.

If Herb Schildt wrote it, it's gotta be good. I find his explanations very accessible and easy to follow for this non-programmer. If it weren't for the explanations and examples in his book, I'd never have gotten a passing grade in my class. It was far more useful than the textbook (or the professor, for that matter).

I use this book as an alternative source for students in my introduction classes. They repeatedly give me excellent comments about this book. They consistently find the book helpful.

This is very easy to follow and does not assume any previous prgramming experience for real and gives very good explaination chapter wise.

I bought this book because I've read very good reviews. I found this book amazing. This books shows you how to make good designs and develop in J2EE, all the chapters with full of comments from Rod's experience. Many of the concepts of this book were later applied in Spring framework. I strongly recommend read this book for advanced Java developers.

This book is for all level developers who have interest on J2EE platform and development. In spite of the complicated technology, it can let readers digest the knowledge without difficulty. On the other hand, the main theme of author(J2EE without EJB) has become popular trends nowaday and the whole idea can be found in this book.

Frankly, this book has gotten a little long in the tooth. One might say that, from the products it mentions and evaluates, it is out of date. But never mind!

Rod applies principles that never go out of date - only the examples do - or seem to. A product is stuck with its basic design forever. Thus a critique of the 2002 version of Struts is as valid as a critique of the 2007 version.

Pros: Readable. Insightful. It will make you a better architect.

Cons: Typos (how do chapters get mis-numbered in the ToC?!?) It really should be in a high-quality hard binding (though the binding is quite good for paper).

Summary: 'J2EE Design...' is worth much more than its weight in gold. Buy it. READ IT!

I thoroughly enjoyed reading this book, particularly well-thought out design guidelines for developing J2EE application with or without EJB. The author introduced several best practices particularly the concepts and usage of Spring and Hibernate based j2ee development is quite helpful. In addition to this book, I find patterns and bestpractices from "Core J2EE Patterns /Deepak Alur", "Core Security Patterns /Christopher Steel" and "Enterprise Integration Patterns /Gregor Hohpe" would be helpful - especially if you are building a enterprise-class j2ee applications.
Now the downside, the book needs a complete revision to include changes with J2EE 1.4. The CODE SAMPLES explained in this book does'nt work now - please update.

It is a great book. But I give it only 4 stars is because it is hard to read. English is my 2nd language. I cannot read this book quickly. I even need check dictionary at least 2 times per page. I do not have the same problem when read other tech books.
"What is WebSphere" is another book I like. Also help me to learn system level stuff. It is much easier to read. Though it does not have so many stuff like Johnson's book.
I would like to suggest the auther to consider many tech readers are not very good at English.

It's amazing how much is assumed in most after-market Java books! I can't estimate how often I've seen, "It is assumed you know about Threaded Programming, and therefore it is not covered here." Well, good news, It IS covered here. And is is covered well.
As a professional programmer for 20 years, I can attest to the fact that Thread programming is the most schizophrenic of disciplines. In addition, since most legacy thread concepts come from 'procedural' languages, the Java implementation tends to be hard to hold on to.
I found this book to be a wonderful 'primer' into Java's Thread capabilities. It doesn't attempt to relate to older languages. It starts from the begining, and presents its subject clearly. It's a good learning tool, and is organized well enough to be a reliable refference.
Even if you have experience with threading, this is worth it to orient your head to Java Threading.

If you find Doug Lea's "Concurrent Programming in Java" too daunting, this is the book you should have read first. The examples were easy to follow, and were to the point -that is, you will only learn how to work with the Thread API, and there is not much talk about design patterns. The diagrams in the book were very handy to follow Hyde's explanation. I enjoyed reading this book.. I recommend this book for every beginner in java programming.

This is a good book to learn Thread fundamentals and how to use thread in Real Life. The code examples uses a lot of AWT thats why the 4 stars I would have been a little bit happier if it used something else.
Any way a good purchase for learning Thread I brushed up my knowledge on Thread before sitting for the SCJP

This is a particularly easy to understand book on Java threads. If you are new to Java or to threading then don't hesitate to buy this book. The topics are clearly explained and in a logical order. The examples are small enough that they are easy to understand, but big enough to get the point across. And they work! Mr. Hyde has clearly gone to a great amount of trouble to make his presentation clear and simple to digest. As examples the diagrams he presents for explaining a deadlock and the timing of events in a wait/notify sequence make what is going on very clear.

If you are an experienced thread programmer looking for the finer points of threading, this book might not be the best. It does not go into the level of detail that some other books do, for example Holub's book "Taming Java Threads". On the other hand, these books are not the best for beginners.

Very straightforward and gentle introduction to the Java threading mechanics.It features basic theory and examples for about 3/4 of the book with the rest of the pages dedicated to a few useful techniques to ease and streamline threads programming, which you can use in you applications or as inspiration and examples for your own devices. My only complaint is the presentation method: a bunch of code followed by a bunch of explanations. I think presenting the more relevant lines of code interleaved with explanations and then the whole example program would make learning much more effective and easy. This book is also starting to show its age, so until a second edition comes out I would recommend the O'Reilly book over this one, unless you can get it real cheap.

Great clear and practical advice for the aspiring or even the professional java programmer.

I have already owned this book for more than four years and could not be happier with it. I have used it extensively mainly as a reference for the uncovered/undocumented topics in Swing, Concurrency and JDBC programming; and I must say it has always surprised me by providing sound information to complex concepts covered only in a very shallow way by other Java books. I keep up to date by buying the latest books in Java JSE and J2EE programming but still, it is only with Brett's book that I end up finding the best answers. It is very compelling its excellent coverage of good OO design in Java and programming style guidelines.

Please do not fool yourself as I almost did when I was quickly browsing through its pages before deciding to buy. My first impression was that this book wasn't going to be very deep, while covering so many different topics e.g. Java Architecture, Swing, Javadoc, JDBC, Remote, Concurrency, etc. but Brett's nail hitting approach is to leave out the trivialities and get to the core complex issues that make all the difference developing real-life complex Java applications.

e.g. today sunday 29.10.2006 I just could not take anymore not fully understanding how GridBagLayout works. I needed the added flexibility over the other simpler but very limited Layout managers. After my frustrated attempt of reviewing other three Java Swing-only up-to-date books, voila! there was Brett's in my bookshelf as always waiting to provide me with the best explanation and examples.

I very much look forward his updated new edition of this excellent almost never outdated resource.

The title of the book is very well honoured. It is IMHO a must have for any serious professional Java developer.

I've had this book since it was first printed, and I find myself coming back to it time and again. I've gotten great value from the printing, drag and drop, internationalization....you get the idea. There is a lot of info here that you just don't find in most Java books (and I've read quite a few).

Highly recomended.

As an intermediate-level Java programmer, this book has helped me tremendously. Reading it from front to back like a novel, I was able to immediately apply almost every lesson learned. Brett Spell has a wonderfully readable writing style and does a fantastic job of explaining a wide array of sticky topics that apply to almost every Java programmer. The book's diagrams and example code are also excellent. I highly recommend this book.

This book certainly covers many important topics in a clear and well written manner. You will find excellent and very clear advice to follow. My only gripe with this book is its rather lengthy treatment of Swing. Swing is covered in enough detail to give you a flavor, but that's all. In total the coverage of swing takes up a lot of pages, and makes the book a bit too thick to read comfortably in bed. Without the Swing part I think it would have been possible to have this book as a bedside companion.

After about 5 years as a java developer, I took a new job as a .NET / C# developer. This book was a great starting point for me. Going from java to c# is a relatively easy transition, but this book makes it much easier and quicker. The book compares the two languages and highlights the differences which made it easier for me to pick up. I'm not a person who reads many books, for work or pleasure, so I don't have much to compare it with. But out of the 10 or so books in my work library, this is the second best book I've used. (The best I own is Effective Java. I'd really like to get one like that for c#.)

This was truely an amazing book, I've read many .NET books, all of which assume zero knowledge of programming, or very little. So when I skipped the first few chapters, or skipped them (Since I've been a Java Developer for several years), I missed valuable differences between Java and .NET.

Be sure you do know your stuff in Java, or else this book will seem over your head. This is not a beginners book. But if you're a Java developer, or have similar programming experience, this book is 100% for you.

My only quirk with this book, is that at times, it's more of a refrence/comparison, over how to use several key .NET features. And it seemed to jump around a little. So actually I'd probably rate this book a 4.75...but rounding up gives us a 5, which it pretty much deserves.

I highly recomend this book out there for anyone who is NOT a beginner programmer, or comes from a Java background. This book is a MUST read for you.

This books hits the spot for java developers, the intended audience. A one page description on delegates, for example, has all the information you need to get started with delegates. The Oreilly book has a long winded chapter on it and the essence was lost in the obtuse example provided.

As an experienced Java developer who was "forced" to move into the C# and .NET world, I turned to this book to help me make that transition. I am very glad I did so. This book provided nearly all of the background I needed for that transition, and it still serves as my primary C# reference a year later. (By the way, working in the C# and .NET world is not as bad as I feared it would be.)

If you are accustomed to Java and new to the world of .NET and Microsoft books in general, you will find the majority of these books to be written for a less sophisticated audience than you are used to. My advice is to be very cautious what you spend your money on, as many of the books about Microsoft programming topics are not worth the investment.

This book, however, is very much worth the money you will spend on it.

i could have sworn this book was from microsoft press. This book did a *great* job of being unbiased, and presented "just the facts". It did so in such a clear manner as well, straightforwardly laying out the similarities and differences between java and C#, and each's strengths and weaknesses (briefly).

definitely recommended!

This is a readable, practical, and deep book. It's one of those books which teaches or refreshes Java and OO theory and practice as you read. I am also reading it for pleasure!

This is a great book. It is directed at users of JUnit, the Java unit testing framework. But in my mind the book gives sound advice for solving your programming problems in general, not just for Java or JUnit testing. It stresses the importance of unit testing, programming to interfaces instead of implementations and just simple common sense. The author is clearly passionate about his field and extremely experiences. The combination of enthusiasm and experience comes through on every page.

This review also appears on StickyMinds at http://www.stickyminds.com/s.asp?F=S767_BOOK_4

JUnit Recipes is a comprehensive tome of practical methods and techniques for the opensource JUnit tool to develop automated unit-tests for Java/J2EE applications. The book is split into four parts: Building Blocks, Testing J2EE, Additional JUnit Techniques, and Appendices. The Building Blocks cover the basics of using JUnit to create basic tests, organize and manage test suites and test data, running JUnit tests and reporting the results. It even includes a section on troubleshooting. Testing J2EE covers XML, JDBC, EJB, web components (including JSPs), and J2EE applications. Additional techniques include testing some well known design patterns, using JUnit add-ons and JUnit libraries (like GSBase). The Appendices include complete solutions (including code of course), some short and sweet essays on testing, and a modest recommended reading list.

The organization of the book flows very logically and the writing style is very clear and easy to follow. Along the way many insights into important design principles and testing techniques are revealed: the reader will learn about the "Hollywood principle", the Open-Closed principle, design patterns, POJOs, Mock Objects, Private and Parameterized Test-Cases, Abstract Test-Cases, Self-Shunts, and Spys. The book's coverage is very comprehensive and touches on many other popular Java/Enterprise projects and frameworks such as Struts, JBOSS, Prevayler, XDoclet, Tomcat, XPath, XMLUnit, HTTPUnit, Ant, Jakarta, and others.

Even though JUnit is often associated with "Agile" development and much of the wisdom apparent in the book applies to agile Java development, the book is useful to any Java developer on any Java project (agile or otherwise). The book also goes into considerable detail, with working code examples, to spell out exactly how to perform and apply the techniques it describes.

The book's primary audience is Java developers. Java Tester's will still find some good nuggets of information but it's quite clear that Java programmers and developers are the target audience. This isn't some high-level theoretical book mostly of concepts and ideas. This is an imminently pragmatic guide that not only conveys a great deal of highly practical wisdom but also clearly and comprehensively walks you through the explanations and the code to accomplish and apply the techniques it describes. The book is also not a "How To" for coming up-to-speed on setting up and running JUnit.

Another book from the same publisher, "JUnit in Action" is a great overview on learning more about the basics of running and using JUnit and on using JUnit to tackle a number of basic challenges with unit-testing Java and J2EE code. JUnit Recipes has some overlapping material but pretty much "picks up" where "JUnit in Action" leaves off, and JUnit Recipes goes into much more breadth and depth of coverage of JUnit methods, practices and techniques and use with other Java projects and frameworks.

I would say JUnit Recipes should probably be required reading for anyone attempting to use Java, J2EE and JUnit in the real-world.

This isn't necessarily the best introduction for absolute beginners (I would recommend /Pragmatic Unit Testing/ for that), but it is required reading for server-side Java, as most other reviewers have pointed out. But it's more than that--it's one of those rare computer books that transcends its subject matter. Why? Because it can make you a better programmer. While some of the credit can rightly be given to unit testing and Test-Driven Development in general, Rainsberger's book makes you /see/ better ways to write and refactor your code. The breadth and depth of examples is astonishing--he convincingly shatters "but it's too hard to test that" arguments with well-researched, non-trivial examples. In fact, I'd say that this is almost a better J2EE tutorial than most books about J2EE proper.

I'm withholding a star for one reason: the book doesn't cover GUI testing tools like Jemmy, JFCUnit, or Abbot/Costello. These JUnit extensions are ripe for a book with this depth; it's just too bad that this couldn't be that book. Other than that, I find that I turn to Rainsberger's book far more often than any other testing book or online reference.

Rainsberger does a very good job of detailing the techniques to unit test difficult code; including xml, ejb, servlets, jsps etc.

I feel like Groovy is like a programming language "Eintopf", it aggregates some best characteristics of a variety of programming languages. No matter which programming style you prefer - procedural, functional, object-oriented, meta-programming, static typed, dynamic typed... - Groovy has much to offer. The most beautiful thing is, you can easily combine different programming styles in one language and write most concise and self-explanatory code to solve your problem. With Groovy, you suddenly have so much mind-freedom, you have the choice of expressing your algorithms as close to the nature of the problems as possible.

There are languages having very concise syntax but the code is not easy for human to read. There are languages and APIs require more strikings on keyboard than thinking. Groovy is different. You have all kinds of syntax sugar while the code still tells a literal story in your problem domain.

The only fields I think Groovy might not be suitable are the machine-level infrastructures and image/audio/video processing. C and assembly languages are not replaceable by Groovy. In most other application fields, using Groovy can dramatically boost programmers' productivity and reduce programming errors.

I started off by simply renaming all .java files in my test packages to .groovy files. Worked. Then tried out it's closures and curry calls. For me there are a lot more to explore. Haskel fans will like Groovy. Smalltalk fans will like Groovy. Python fans will like Groovy. Lisp fans maybe too. Java folks? I for one, have already been conquered. If you program at all, by all means do yourself a favour and have a look at Groovy.

Groovy in Action is an excellent book on Groovy and programming. Get this book and get the insight, you'll be glad you do.

For those of you who haven't heard of Groovy, Groovy is a scripting language that is built on top of Java. Since it is written on top of Java, a Java developer can pick up pick Groovy in a snap.

I first heard about Groovy In Action (also known as GINA) during a Groovy presentation almost a year ago, the presenter was referring to Groovy In Action as one of the best references out at the time, After reading GINA, I was not disappointed. The roadmap given at the beginning of the book is a great guide to see how the book is organized out. As an added bonus, the book includes some great reference information at the end of the book. It contains Groovy Language information, a GDK API quick reference, and several great cheat sheets for items such as closures, lists, etc.

The book is full of great examples that you can use (some of the examples illustrate some of the finer points of the language).

In fact someone recently asked about where to find a complete specification of the Groovy Language. Guillaume Laforge, Groovy Program Manager and co-author of Groovy In Action, responded that the most current information can be found in Groovy In Action (source user@groovy.codehaus.org mailing list 3/16/2008).

Groovy in Action is one of the Groovy books that is a must have for anyone looking to get into Groovy Development.

This book is totally awesome. The book makes it very easy to jump around and come back to previous chapters. The book's online forum is great too. The author(s) respond very quickly. It is well worth the money. Order it now and you will be programming in Groovy very quickly.

While getting a little long in the tooth (GINA was released pre-Groovy 1.0, Groovy is now above 1.5), the material presented in the book is still very relevant and helpful. The biggest issue is that some of the newer (and cooler!) features, such as ExpandoMetaClass, of the language are not covered.

That being said, this is still a great introduction to the a language that will likely become an important player in Java shops as developers migrate existing designs to take advantage of the power the dynamic programming provides. The authors do a great job of explaining the concepts and syntax of the language, making it easy to quickly begin writing code of your own.

While books such as Groovy Recipes: Greasing the Wheels of Java are now available that cover the newest features in Groovy, a perusal of GINA can help to flatten the learning curve.

This book is fantastic. Very well done, easy read. It was the first tech book that I read cover-to-cover -without getting bored- in a long time. The author does a good job of explaining how Groovy works under the covers and does a great job of detailing how to make effective use of it.

The language itself is also impressive and I hope Groovy gets the attention it deserves. I hope all Java developers read this to see what they're missing in Java-land. :-)

Hindsight is 20/20, I'm sure the authors are sorry they included the last chapter on Grails as they did. But I don't fault them, as I'm sure the publisher was not uninvolved in that decision... ;-)

I'm giving it 5 stars anyway. Good work!