2 comments about Integrating and Extending BIRT (Eclipse Series).

1. This book is an impressive extension on "BIRT: A Field Guide to Reporting". The latter described BIRT to a newcomer, showing how to use its features. With a minimal discussion of scripting for customisation. While the scripting certainly involved programming, it was rather minimal, and most of the text showed a declarative layout approach to using BIRT.
   
   The Integrating book is the sequel. Strictly a programmer's book. It assumes you've read the earlier book. But now you need to take the customising [much] further. So here the text shows how to program in Java, not just JavaScript. Essentially, the bulk of the book explains the package org.eclipse.birt, which is freely available and has been built out with many classes. The problem to a programmer is the sheer multitude of those classes. An embarrassment of riches which the book tackles.
   
   Some classes relate to customising the UI. There is a charting API built on top of Java Swing. So you can key off your pre-existing Swing expertise. Swing is pretty easy to learn, and the BIRT graphics classes seem to continue this property.
   
   The only possible problem might be if you prefer SWT widgets for the better native look and feel. But the BIRT contributors correctly decided to support the most popular widget set, which is Swing.
   
   Other BIRT classes relate to getting data at the back end, from various possible sources.



2. It is a very useful book for anybody starting to use BIRT. However, some sections are slightly out of date vs. the new versions (2.2.2) of BIRT in 2007.
   
   The basic concepts in this book are still very useful, otherwise it is hard to find online information explained in such a systematic way and in such details.

1 comments about Object-Oriented Application Development Using Java.

1. Consiglio questo libro a chi sta affrontando per la prima volta l'approccio oop allo sviluppo di applicazioni.
   
   Gli argomenti sono spiegati bene, ma ho trovato troppa superficialita' in alcuni passaggi. Non e' un libro per chi ha gia' una discreta conoscenza dell'oop.

2 comments about Pro Java Programming, Second Edition (Pro).

1. This book covers a grab bag of reasonably advanced Java topics. These include collections, XML, some database access, and Swing. Roughly half of the book is Swing. The first chapter, which covers library design, is solid.
   
   The exposition is solid, if a little dry. The illustrations are good. The book does rely a little heavily on code to do most of the expository work.
   
   I recommend having a look at this book in person before buying it. See if there is enough there on the topics that interest you to make it worth the purchase.



2. I really liked this book. The explanations are very clear and thorough. I agree with the previous review, that the book is a little SWING and code heavy. The SWING stuff is however just used as examples to explain a concept. The author is not trying to teach you SWING through this book. I guess that also the reason for longer code samples. Swing adds a few extra lines of code to each sample, but without that .. it might be difficult to follow through.
   
   Overall .. this is a good intermediate/advanced level book.

5 comments about Oracle PL/SQL Developer's Workbook.

1. This book covers a wide range of material. In this sense it is good for someone of every level but it also means you will only use a part of the book. Each chapter is structured like a quiz - answer the questions and then review the answers. It does not work you through problems but there is a lot of useful material in here that you will not find anywhere else.



2. This is a great book to test your PL/SQL knowledge no matter what level you are at. In fact each chapter is devided into 3 sections: Beginner, Intermediate and Expert. This is an excellent book to get after you have worked through a PL/SQL course and want something to give you the extra edge on all the various PL/SQL topics. There is some very good hard to find information in here.



3. I thought this book was great. If you like getting into specific, real-world programming tasks and figuring out the best solutions then this book is for you. He provides helpful explainations along with his solutions. There are a lot of top-notch, practical techniques that you learn as you get into the nitty-gritty of working on small pieces of pl/sql code. There are also questions that test your conceptual understanding of different facets of pl/sql programming --- questions that you could face on a job interview. Even though I've been a pl/sql developer for a few years, I found this book very useful.



4. If there is any book which will "fine-tune" one's knowledge of PL/SQL, this is it. It is written in Feuerstein's inimitable style which will keep you engaged with the book much longer than any other peer book of it's kind. There is so much to learn from this book really - and it applies to beginners as experts alike. This book explores the tiniest nuts and bolts of PL/SQL in an exercise-like format which gives the reader a chance to ponder on the problem before he/she looks up the answers. And I must add, you are in store for a lot of surprises when you look up the answers in the second half of the book ! (escpecially in the experts' section)



5. If there is any book which will "fine-tune" one's knowledge of PL/SQL, this is it. It is written in Feuerstein's inimitable style which will keep you engaged with the book much longer than any other peer book of it's kind. There is so much to learn from this book really - and it applies to beginners as experts alike. This book explores the tiniest nuts and bolts of PL/SQL in an exercise-like format which gives the reader a chance to ponder on the problem before he/she looks up the answers. And I must add, you are in store for a lot of surprises when you look up the answers in the second half of the book ! (escpecially in the experts' section)

5 comments about Java 1.5 Tiger: A Developer's Notebook (Java 5,Version 1.5).

1. This book delivers on what it promises - quick and dirty introductions to the new features of Tiger. It does a great job of getting one familiar with all of the new features, though, as noted by other reviewers, it is not intended to be an in depth reference. The chapters on generics and concurrency could certainly be deeper, but the book provides a good grounding in the basics, opens the door to more complete study, and provides enough sample code to get one writing code.



2. First off, i sincerely appreciate O'Reilly on their innovative idea of a notebook series. This series is targetted towards busy developers who dont find the time to crunch through big fat books and learn about every grain of sand; rather they would spend less time and learn what is absolutely required. This is certainly a welcome concept.
   
   That said, this book is about the new additions that sun incroporated into java 5 (Tiger). Yes, there are so many additions that it requires a book in itself. The author covers all the significant additions like Generics, Enums, Autoboxing, Varargs, Annotations, Enhanced For-Loop, Static Imports, printf and Threading. Isnt that a mouthful? Yet, he covers them in under 200 pages. That in itself is an achievement. Also, the conversational tone and the humour with which the author writes makes the text very interesting.
   
   Now, for the bad news. This book is edited pretty poorly. There are a lot of typos both in the text and code. I understand that, this book is conceptualized saying that it is a scribbling of an alpha geek who takes down notes as he researches new technologies. But, that doesnt mean that we get to read the same scribbling without even getting edited, though we pay for it.
   
   More than the typos, the author establishes certain technical claims, which are both wrong and misleadging. For example, the author claims that it is IMPOSSIBLE to use the enhanced-for-loop for generating a comma-seperated string from a list of strings, where the resulting comma-seperated string doesnt end with a comma, so as to display formateed output. The author justifies this by saying that a developer doesnt have access to the counter variable in the enhanced-for-loop. Though i agree that we dont have access to the count variable, the use-case is ofcourse possible. This piece of code can be used to achieve what the author claims IMPOSSIBLE.
   
   import java.util.List;
   import java.util.ArrayList;
   
   public class CommaString {
   public static void main(String[] args) {
   List numList = new ArrayList();
   numList.add("1"); numList.add("2"); numList.add("3");
   
   String numStr="";
   for(String num: numList)
   numStr = numStr.equals("") ? (numStr+num) : (numStr+", "+ num);
   
   System.out.println(numStr);
   }
   }
   
   This may not be the most efficient implementation, but, it atleast proves that what author claims as impossible is rather possible. There were some statements like this in the threading chapter as well, where the author compares synchronized keyword and lock. So, beware not to always go with author's opinions, but ofcourse, the technical content can be trusted.
   
   In the end, i would say that this book achieved its goal by neatly summarizing all the significant improvements/additions in tiger and we sure can learn every feature from this book. There are some issues, but it will not affect the overall value of the book as long as you dont overlook them.



3. 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.



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



5. This book delivers most of what it promises to, which is a good introduction to the latest and greatest features of Java 1.5 Tiger. Considering the extent of changes Sun introduced in the new version, I think the authors did a decent job explaining them. If you are new to 1.5 version though, you would probably need to read another book that explains the concepts in greater detail.
   
   My only complaint is with the "Threading" chapter which was full of of API methods instead of letting the users know the concepts behind the changes. Looked like the authors were in a hurry to get the book finished and the "Threading" chapter got affected.
   
   Overall, it is a good read.

5 comments about Fundamental Networking in Java.

1. I have never read a more concise but clearly written technical book, and the code looks beautiful too. Pretty much every software engineer needs this book.
   
   If you absolutely know what you are doing it reduces the solution time for most known problems from hours to minutes. If you are not all that clued up about IP but want/need to be, this is the book. Fundamental Networking in Java could just as easily be just called Fundamental Networking.
   
   I expect this book will become the standard text in Software Engineering courses on Networking. And if your course has a different text, this book is probably a better choice. It will be one of the very few textbooks that will survive your transition into the working world.
   
   And the beauty of this book is that because it is written in crystal clear english it is also very useful to a much wider audience - technology manager, business analyst, etcetera.



2. This book is what Im finding to develop server applications with Java language, it is filling the market gap.



3. This book describes its subject from the basics of the underlying IP networking technologies (including both TCP and UDP) all the way up through the "traditional" socket classes to the new Channel classes.
   
   Personally I particularly benefitted from the discussion of channels and the rest of the NIO (New IO) package, but I believe that the solid coverage of Java networking basics in tandem with the comprehensive description of the available libraries makes this both a good introductory text and a good reference to the more obscure niches. It helps that while there are quite a few reference tables and lengthy discussion sections this is still a hands-on book with plenty of code examples.
   
   Not quite suitable for a complete Java beginner - but any novice developer with a grip on syntax and the core API would benefit from this.



4. Pitt demonstrates how to connect between machines in a TCP/IP network, when at least one of the machines is running java. He explains that the standard java, which you get free from Sun comes replete with a a core set of networking classes. These free you from a lot of the grungy low level I/O issues that programmers using C and the default unix libraries have endured since the 1980s. C network programming is notorious for the amount of sweat that developers have to endure.
   
   In contrast, the book is an easy and concise read of a compelling alternative. The java networking classes also include the ability to connect to an arbitrary URL and to download data (usually a web page). A fundamental subroutine for Web access.
   
   Hopefully, the book will deter you from going back to C networking.



5. This is an excellent book on Networking in Java. I would highly recommend it to anyone wanting to learn sockets, TCP/IP and UDP. Just make sure you have the API available when you're reading this book.

5 comments about Professional Java, JDK 5 Edition.

1. Chpater 1: Key Java Language Features and Libraries - the only chapter that talks about JDK 5.
   
   Waste of time to proceed further.



2. I like this book because it brings together in one place a lot of information that is helpful in real-world development tasks. My complaint is that it seems carelessly edited, leaving you with a collection of chapters obviously written by different authors who didn't communicate much with each other in the formation of the book.
   
   It's nice to be able to get the new Java 5 features under your belt in just a couple of hours of reading and playing around. In fact, the first chapter is excellent, code samples and all. The next chapter is nice for a quick review of methodologies, or if you are completely new to the frameworks that are often used in conjunction with Agile Programming in Java, such as JUnit and Hibernate and so on. Chapter 3 is a capable introduction to some of the more popular Design Patterns, but it is here that you first notice that the author ignores all the advice in Chapters 1 and 2 about how much easier your development will be if you use the new language features of Java 5 and the tools and methodologies of Agile development.
   
   Things go downhill by Chapter 4, which covers Swing desktop GUI design and coding. The sample apps aren't all that well designed and don't don't demonstrate everything presented in Chapter 3 (such as the MVC application architecture) in a clear, convincing way. And it is here that you encounter the most shocking deficiencies of this book: sloppy, difficult-to-read sample code that compiles and runs--more or less--but which contains numerous lines (and even entire blocks) of extraneous code, poorly-chosen and sometimes even capitalized local and member variable names, and code stucture that defies best coding practices in many places. It is the type of code that you get when you hurry to meet a deadline for a prototype, and which you have not yet gotten around to going back and cleaning up.
   
   Things pick back up a bit in subsequent chapters, with a nice intro to J2EE and J2EE-oriented API's, messaging, security, and a fine chapter on the much-neglected subject of application deployment.
   
   Overall, I'm glad I bought this book. I've learned a lot from it, despite it's few annoyances. In fact, I made an exercise out of cleaning up the kludgy code samples in chapter 4. No, I'm not being sarcastic--I really did find it far more helpful and educational to patch that code up than to just read it through and then kid myself that I had internalized it. Who knows--maybe all sample code should be written with some defects.



3. all I could say is that book is very poorly written , no connection between reader and writer, in may chapets ,they are just composed of a bunch of refference manuls that everyone can read for free from vendor , for example JAAS section is totaly useless ...
   JDK 1.5 is covered very very poorly ...
   it seems that book was written in a rush to get it out to market ..



4. This book is an unfocused collection of reference manuals that seem to have been thrown together with very little forethought. It's poorly organized, the code examples aren't all that intructive, and there are plenty of errors throughout the book. It isn't very useful if you're learning Java, and it's a lousy reference if you already know it. I suggest skipping it.



5. Despite what some other reviewers said, I actually really enjoyed this book. It has allot of valuable material for folks making the jump from beginner topics to more advanced topics.
   
   It seems that allot of folks expect the book to be all about JDK 5 when the title clearly says "PROFESSIONAL JAVA" (JDK 5 edition).

4 comments about JUnit Pocket Guide.

1. Quick disclosure - I'm a big fan of JUnit already. :) Anything that will convince java developers to use JUnit is a good thing. JUnit is as powerful as it is simple. To prove it, everything you need to know about JUnit is in this 80 page pocket guide. If you are a Java programmer, this pocket guide will easily convince you to add JUnit to your daily development processes. It covers the entire JUnit API, using JUnit with Ant, Extending JUnit, and plenty of suggestions on how to test various situations with JUnit.
   
   I liked the descriptions on how to run JUnit standalone or within various IDEs (Eclipse, JBuilder and IntelliJ IDEA). I have been working with JUnit in Eclipse for quite some time and recently started a project using IntelliJ IDEA - so it helped me get JUnit going quickly. I also found the short history on JUnit interesting as well.
   
   Whether you're new to Java development or just haven't used JUnit yet, this is the perfect pocket guide to help you get started.



2. This is a short and sweet end-to-end introduction to JUnit. The text is pretty terse and there are a surprising number of a screenshots for a book so small. The book starts with an introduction to testing. It then gives a high level architectural overview of JUnit, along with it's API. There is a short digression into the history of the framework. Then it's into putting a front-end on the tests both on the command line and embedded into IDEs.



3. I got "JUnit Pocket Guide" along with "JUnit in Action" and "JUnit Recipes". I figured I should have Beck's book since he's the father of JUnit and a major force in test-driven development. I figured I'd get a concise explanation of JUint and be able to use the book as a reference.
   
   While the book more or less meets those goals, the writing is terse and mostly fails to provide the illuminating insights I was hoping for. I was also disappointed that the book is not well-structured to use as a reference, and is somewhat out of date with JUnit 4.x at this point. After reading this I moved on to "JUnit in Action", which I highly recommend.
   
   Overall, I'm not disappointed that I got the book given the reasonable price and minimal investment in time reading it. It does serve as a quick introduction to and motivation for using JUnit. However, if you intend to put JUnit into practice, you can easily skip this book and go directly to one of the many excellent and more comprehensive books on JUnit--this book won't be enough and offers nothing indispensable.



4. The philosophies in this book will help me get more out of life.
   I have wanted to learn JUnit for several months now. The techniques in this book will help me write better code and think more clearly in many planning and development aspects in life.

5 comments about Developing Games in Java (New Riders Games).

1. The good things about this book that the author modulates the basic game componets into various class such as screen manager, input manager which enhances the reusability of the game code.
   
   Also, a game can be easily built on the existing class without much tweaking of the original source code.



2. First off, this book is fairly easily to read if you have some programming background. This book is obviously not aimed at beginners, so it will require atleast a basic knowledge of Java to make any sort of sense.
   
   What I liked about this book is the rather large number of projects you have to build right from the get go. However, what was most disappointing about this book was the lack of explanations as to what, exactly, is going on in the code. For instance, his section on mouselooking basically dumps two pages of code on you, filled with new algorithms that are accompanied by zero details about how they work or why things are done that way. There aren't even comments in the code that step you through it.
   
   That aspect of the book is really saddens me because that's all that seperates it from a typing exercise and a great lessong in game programming.
   
   Having said all of that. There are some basic functional things you gather that are useful if you are brand new to game programming.
   
   What I had hoped to gather out of this book was more than just code. I hoped that there would be principles that I could extrapolate and take with me from project to project. Regretfully, I don't think this book accomplished that goal.



3. I have had this book for a couple of years. It is one of the best games programming books I have read. Be aware that over half the book is devoted to developing a software 3D engine. I found this to be quite high quality and I have even ported it to C++ with no issues. The engine supports texture mapping, shade mapping, z-buffering, collisions, pathfinding and BSP trees. As the author states, learning how things work in software helps when you later use hardware 3D rendering. To be honest, I was really impressed with the speed the 3D demo ran at, considering most people still think Java is slow.
   
   The first half of the book develops a nice game framework to help with redifining keys, choosing a screen resolution, sound effects, animation and 2D scrolling with collision detection. There is enough info here to produce a good Mario clone. There is a chapter on networking but it seems disconnected from the rest of the book (I think it was written by a different author).
   
   One of the best things though is that all the source code (available from his site) compiles straight off the bat, and works with no modifications. I cannot tell you how rare this is for a computer book. All the examples are built as Ant scripts and I simply imported them into my IDE (IntelliJ IDEA, but most other IDEs can also import Ant scripts). They all compiled with no errors and ran exactly as described in the book.
   
   In summary this is an excellent buy for the intermediate Java programmer who wants to get into 2D and 3D games.



4. Early attempts at Java game programming usually meant incorporating a foreign framework in your code. With the latest advancements in Swing, it's become easier to develop rich media applications in Java. Developing Games in Java takes this rich framework and explains thoroughly how to best utilize it for both 2D and 3D games. The book could easily be used as a primer in game and graphics techniques as well. Concepts like collision detection, path finding, scripting, and AI are well covered, making this a complete introduction to developing great games in Java.



5. Pretty darn great book!
   Chapter 1 starts with threads, locking and multithreading animation!!
   This is for serious programmers, serious game developers...you gotta have some experience in JAVA development in order to get the best from this book. Beginners will take some time, but eventually prevail.
   A must!!

No comments about Beginning Java Game Programming Second Edition.