Customer Reviews

Java 5.0 Tiger: A Developer's Notebook

5 star:		(13)
4 star:		(16)
3 star:		(1)
2 star:		(1)
1 star:		(0)

 

 

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.

"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 conncurrency section. There is excellent cross-referencing so the chapters and tasks can be read in almost any order. This was an amazing book!

This notebook series is a very good aid for the experienced developer who wants to play with some new feauture in the company of an even more experienced fellow who has done most of the research for him. Stay far from this one if you need to learn Java from scratch. (Go for one of the many excellent intro books by Ivor Horton or Cay Horstmann). Not surprisingly this book is one of the best in the series, being mostly the effort of Brett McLaughlin who, besides being a talented coder and writer is also the man behind the O'Reilly "developer notebook idea". In about 150 pages you will get plenty of working examples and clear, concise explanations on the new features of "Tiger": generics (templates), varargs, annotations, autoboxing etc .. If you are a serious Java developer you cannot miss on these new features, and have no excuse for doing it since now you can bridge this gap with just a few hours of reading on a train. And if you are an old school C coder who grudgingly had to pass to Java for "marketing reasons".. I have great news for you.. believe it or not, we got printf back! ;)

I found the book shallow. Probably Notebook series is meant to be that way, a quick overview of a subject. What a programmer needs is developing intuition in the tool it uses. If you need a quick tour of Tiger this book is good but, http://java.sun.com/j2se/1.5.0/docs/relnotes/features.html, I beleive is good enough for this purpose. Especially the tutorial on generics far beyond better than what this book covers. You can find it at http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf

Having read this book I'm itching to use the new features in Tiger. I found it well written, with generally clear examples, and a lot of information in a short book. It's not the definitive reference to Java 1.5, but then I probably wouldn't have made it all the way through if it was.

The reason I didn't give it 5 stars is that there were a few cases where I would have liked some more information about using the new features in an Enterprise system. In particular there are these two points that I'm still looking for answers to:

1) When discussing Enums there's no discussion of using them Remotely (via RMI). Can emums still be compared using == if they have come from a remote client? If not, can the new form of switch be used?

2) Comparison of the new Formatter to MessageFormat. In particular the performance of the new Formatter (because MessageFormat is slow).

Perhaps I need to write myself some tests, because I was frustrated that I couldn't find the answers to these questions on the web.

Another thing that I think could have been covered is the JVM changes introduced in 1.5 - the implications of class data sharing between virtual machines and the changes to garbage collection. Admittedly not as interesting as the language changes, but if you're going to use the new features you're going to have to use the new JVM.

Who: You. You already know Java. In fact, you silently snicker at most people who say they "really know Java," because they don't - not like you do.

Why: Java 1.5 is really different. Not just enums and boxing/unboxing, it has type-safe varargs (who'd've thunk it!), last-chance handlers for threads, the most comprehensive generic mechanism I'm seen, and more. You need to know what's new, and how to use it, and fast.

What: This book. It won't help the Java newbie. It's just the new features, spelled out in detail. Better yet, they're spelled out in code samples. This doesn't so much tell you what's new, it shows you.

Where: Here. Until the next generation of Java books hits the shelves, your alternatives are this and the language spec. Believe me, you don't want the language spec.

When: Now. This book will probably look old fast, once the more polished, friendly, and tutorial texts come out. It's a great quick-start on the new technology, though, and (see "who" above) you can't wait.

I hope O'Reilly keeps coming out with new titles in this series. I give it five stars now, but probably two a year from now. As I said, though, this book is for !right!now! and does a great job of what it does.

//wiredweird

I found this book very interesting and I hope to continue to use
it. First, the positives. It provided a good survey of the most
important new features in Java 1.5. Some of the examples were
quite detailed and very useful, and it is good to have all the new
features collected together into one place. It will also provide
a place to quickly look up the syntax for some of the new
features, especially Generics, Enums, and Formatting.

On the downside I didn't really like the tone of the book - I got
fed up with seeing "cool" all over the place. I also don't
understand the intended audience for the book. It is too advanced
for beginning Java programmers, and yet it doesn't contain enough
detail for advanced programmers. The section on Threading was
especially lightweight. Doug Lea's Concurrency book (from which
all of the new support for multithreading in Java 1.5 is derived)
is an extremely dense and difficult book. Any attempt to try and
cover the material in a few pages is unlikely to meet with much
success. This chapter was good for advertisement: "here are some
new classes" but not much else.

In summary, this is a good overview of the new features in Java
1.5, and useful as a reference for many of the features. I would
recommend it to any intermediate Java programmer who wants to get
up to speed quickly. However, it is not intended as a reference,
so do not expect to get one!

There's nothing in this book that you couldn't find on Sun's website, but it's a good quick reference book.

This is a great book. If you know Java 4 and you want to upgrade your knowledge, this book is short-and-sweet -- only 170 pages. It tells you quickly what is new in Java 5 so that you can make the transition from Java 4 prograamming to Java 5 programming.

This book was never intended to teach newbies the Java language version 5.0. Its purpose is to teach those features of Java 5.0 that are completely new to the language to veteran Java programmers. This is very helpful to those of us who already know Java and do not want to invest in an $80 1200 page tome that will teach the entire Java language to us once again. The book consists of 10 chapters:
1. What's New
2. Generics - Generics provides a way for you to communicate the object type of a collection to the compiler, so that it can be checked.
3. Enumerated Types - Java gets linguistic support for enumerated types beyond the int Enum pattern. In their simplest form, these enums look just like their C, C++, and C# counterparts, but they are far more powerful.
4. Autoboxing and Unboxing- This pertains to a more straightforward way of inserting and removing objects from a collection using their true object notation.
5. varargs- Previously, a method that took an arbitrary number of values required you to create an array and put the values into the array prior to invoking the method. This new feature automates and hides the process.
6. Annotations -A metadata facility that permits you to define and use your own annotation types. Annotations do not directly affect program semantics, but they do affect the way programs are treated by tools and libraries.
7. The for/in Statement - often called either "enhanced for" or "foreach" is largely a convenience feature in Java 5.0.
8. Static Imports - The static import construct allows unqualified access to static members without inheriting from the type containing the static members.
9. Formatting - An interpreter for printf-style format strings has been added.
10. Threading - There have some been some major advances to the design of threading in Java.
Each chapter explains the new concept that has been introduced to the language and shows the reader how to incorporate that feature by showing actual code. As other reviewers have pointed out, there are a moderate amount of typos in this book. Some are just cases of spelling errors where it is obvious what was really meant, but some are in the code itself and impede understanding of the concepts being taught. Overall, though, I am a fan of the Developer's notebook series and I think that it works well for showcasing Java's new features. I just wish more care would have gone into the editing process.