Compras Nikon Bluetooth |
The writer constantly refers the reader to other authors' discussions of the topics, which is really distracting. Just boil it down and keep using the foot notes (which he does as well).
A lot of the patterns were geared toward re-use. I guess that's fine if your designing a product for re-sale, but I was looking for more in the way of "did you know you could do this or that". I guess it is really my own fault. I did read the other reviews and bought it anyway thinking this book would contain some useful insight. Most of the stuff he mentioned I had already implemented as the design patterns were fairly logical and common sensical.
It was decently written, I was just hoping for more in the way of a not so overly simplified approach to understanding how java can be easily used to create servers. I already understood that. If there is one thing this book has taught me - or more accurately - confirmed for me is that sometimes programmers over-complicate things to make them re-usable. I have definitely found it is much more efficient to create many components from scratch rather than trying to figure out what some other programmer was thinking in their implementation. In other words, re-use, I think, gets blown out of proportion in the business application development environment. In the time it takes to figure out what that developer's strategy was, I could have already created a perfectly functional, scalable component. Leave the over complication to the development teams creating commercial products like high end web servers, data access components, etc... I've got work to do.
As with all tools, EJB/Servlet/JSP should be applied where they fit into your problem, and not shoehorned into every application.
This is the first book I've found with such a thorough coverage of java server programming. Be forewarned, when they talk about Server-Based Java programming, they aren't talking about servlets and JSP for web projects. If you're looking for such a book, you're better off looking elsewhere. This book has excellent coverage of issues involved in programming middle-tier and backend server java for use in enterprise level systems. The sections on server threading issues and code deployment are worth the cost of the book alone. But then they throw in RMI, Corba, and JNI for helping you integrate your components with other applications.
The book is noticeably light on EJB's, but this is by design. So you may wish to pick up a companion book if that's your aim. However, even if your focusing on EJB's, this is a highly useful book for the underlying server architecture that the EJB's will reside on.
As a Sun Certified Java 2 Developer, I've read more than my fare share of bad java books. The good thing is that they are very easy to spot: they are typically extremely thick books with trivial examples and a huge API reference (that you can download from Sun's website) for filler. This book is a voice of reason in Sun's flood of J2EE (especially EJB) hype. It's a wholly remarkable Java book. Ted Neward should be rewarded and congratualted for this book, it sets a new standard in content quality for Java books.
It is very common these days just to modify product manuals, or specs and call it a book. This book shines with its original approach, in-depth information and practical examples; you will learn both basics and behind the sceene server side Java: a six stars book!
When I first glanced through the contents of "Server-Based Java Programming" at the bookstore, I almost immediately put it back on the shelf. After all, it barely even mentioned J2EE. Who on earth writes a book about using Java on the server without covering J2EE? That's the hot technology and everyone is focusing on and certainly the basis for Java development on the server. Using an application framework provided by J2EE provides too much to ignore - why would you write anything else?
Well, I was wrong. Long story short - I ended up with a copy at my desk. Finally I picked it up and started reading.
Hours later and I still couldn't put it down.
Ted Neward's book Java-Based Server Programming, published by Manning Publications covers much more than simple J2EE development. It gives you the tools you need in order to understand and develop your own servers, application or otherwise. While this may not seem important at the surface (see my own remarks earlier), it becomes readily apparent only a few pages in just how valuable these skills are. Having the depth of understanding that's presented in this book gives you the ability to write code of greater robustness than otherwise, whether you're writing J2EE apps or not.
The first thing that struck my fancy was the discussion about the 3 zeroes - zero development, zero deployment, and zero administration. I've long been an advocate of building "lights out" systems - put it on the servers, shut off the lights and go home and wait for the checks. But Ted takes it beyond what I had considered. Lofty goals, no doubt, zero development, deployment & administration is exactly what we should be shooting for. As the saying goes, "Shoot for the stars and hit the sky, shoot for the sky and hit the mud."
If that was all he had to say it would have been a good purchase, but Ted then goes on to describe and produce code that actually moves us toward these goals.
I appreciated the frequent references to design patterns. In many circles patterns are new concepts that people are just starting to experiment with. It is refreshing to see a book where the audience is expected to understand them. UML is used where appropriate, adding yet more evidence that this is written by an architect and software engineer - not just someone throwing code together quick and dirty.
It's not as though all the material in the book is new and doesn't exist elsewhere. There are many texts that cover threads and their proper use. Texts about n-tier architectures abound. Application frameworks are not new concepts; sockets, persistence, servlets, middleware and JNI have been around and are well-understood. The power comes through the stated objectives and the practical application of these different technologies in a holistic manner toward them that produces a very worthy text.
Real-world, architecture-centric, holistic, practical, proven. All appropriate words to describe this book. Don't believe that one size fits all? Me either, and it's refreshing to see a work with the depth of this one. Don't know Java yet? Read some of the other fine books first. Then, when you understand the language and want to get serious about server-side development, get a copy of Server-Based Java Programming and dig in. Personally I consider the $50 I spent on this book one of the best purchases I've made.
Now if you'll excuse me, I'm going to get back into this book. It's 5am so I still have some time before I have to go to work...
Throughout the book the author identifies real-world problems and issues facing server-side design, and presents several solutions to these problems. Both the Servlet and Business Object Model sections have excellent discussions about n-tier application issues pertaining to the separation between logic, content, and presentation. These sections make excellent reading. Rather than being theoretical about the issues the author describes real-world situations and ways to work around them. A few examples of the issues the author describes in these sections are team development of common modules, n-tier client-side validation, and scalability and performance.
Having read this book cover-to-cover (something I rarely do with technical books), there were a few sections that I did not find useful. These sections were the ones on ClassLoaders, Custom ClassLoaders, and Java Native Interface. Also, I felt the section on Configuration was a bit weak, and did not address many of the issues I have faced with configuration issues involving distributed systems. Overall, this is an excellent book, one that is now included in my "Top 5" list of technical books.
There is no sin but ignorance.
-- Christopher Marlowe
The truth of a proposition has nothing to do with its credibility. And
vice versa.
