Variants Books

Deals with the RT (soft) issues of Java. Garbage collection and more.

Includes what you need to know about soft RT constraints when using Java. The garbage collection issue and more.

Hi all. This is a serious book on real time, even if you are not a java programmer. (by the way this is not a book on java for those who came here by mistake.)

I have used this book to help me build a project I am working on at my UNI and it's was very helpful. it is first of all Specification book so it main use for my opinion is a reference after the first reading an as such the book is very good. A real time programming background is essensial for really benefit from this book , but if you are one of the RTP so it's a book for you !

I gave it 4 stars because it's a spec and not my kind of books but it's a defenetly great spec. - Enjoy

Assume that you've been given a mandate to turn an existing, popular language built on write-once run-anywhere (WORA) principles into a basis for implementing correct performance-critical applications on a wide variety of platforms. Thats exactly what the team who wrote this book were tasked to do - without changing the core Java language specification. Bearing these restrictions in mind, its a good effort. The specification addresses all the basic concerns of the real-time developer - concurrency, asynchronous event handling and transfer of control issues, timing, scheduling, memory and so on, though the introduction of a single package: javax.realtime.

In general the rich set of classes provided seem to be fairly straightforward, and will probably be easy to use when a reference implementation becomes available. Key concepts are illustrated with short examples - and here's my biggest criticism - they are often of appalling quality - typically they confuse rather than clarify matters. I appreciate that this is a specification rather than a tutorial but anyone who has to implement or use this standard needs all the help they can get! There a few other typos, especially in the method signatures but these are easily parseable nonetheless.

The biggest changes are going to be in the real-time virtual machines that will be built to support this standard. Comprehensive support for such features as configurable scheduling algorithms, dynamic schedulability (where schedulable objects are dynamically added to the schedule and feasibility is determined at runtime), asynchronous transfer of control on executing threads and so on - are going to require heavy-duty support at the virtual machine level. The specification doesn't state how these and other services will be implemented but gives a would-be real-time JVM implementor lots of hints on how to do, and how NOT to do a good job in this area - which is a welcome addition.

So, my recommendation. I'd give it 4 1/2 stars if I could - but lets be generous and give it 5. The only detraction is that a good dose of proofreading could have improved on the current release. That said, I have high hopes that this will eventually emerge as a real-time development standard in the same way that Ada 95 promised to, but never delivered on.

p.s. for distributed real-time transactions - you'll have to wait for an additional standard to address this issue : watch this space.

The programming language Java is widely used for web applications, servers, compilers. The concurrency aspect is also known to all of us. But for real time systems development in Java was awaited. I being a teacher of RTS course was looking for the language to introduce the real time system concepts. This book is correct solution. It starts with real time threading. Scheduling, Synchronization, timing issues of Real time systems are explained with implementaion and verification aspects. The book is correct choice for learning, developing, real time systems with complete programming language Java.

Unfortunately I am disappointed with this book. I guess I had high hopes that it was going to provide a lot of information that I didn't know and principles (backed by examples) that would help me learn some really valuable exception handling patterns.

I'm not sure who the intended audience is. The book is probably ok if you are relatively new to Java and it's exception handling features, but on the whole it did not add much to my skill set. But then there are also a couple of sections that reference concepts from Servlets/JSP and EJB, so if you are a newbie you might be confused.

In my opinion most of the book covers basic topics that you will already know or just as easily get from the API docs. For example, chapters 7-9 (130 pp.) talks about "core" Java classes, Collections, I/O, distributed APIs, and J2EE. It describes the various types of exceptions that can occur and what they mean. Unless you don't know how to read the javadocs, there is no new, useful info there.

It also seems to lack focus throughout. Too much of the book covers material outside of the scope of exceptions. For example, it discusses common software patterns and then just throws in a couple of sentences about exception handling to tie it back in. However, for the most part the exception handling techniques are not described well enough and lack thorough, concrete examples.

I wish the author would have made chapter 12, exception handling patterns, the bulk of the book. Then maybe I would feel closer to the book's claims of "Master application-wide exceptyion handling startegies" and "Learn proven design patterns for handling exceptions in code".

Maybe I was just expecting too much. After reading the books description I was expecting something like "Core J2EE Patterns" for the exception realm - something that would get me excited about applying a bunch of new patterns/techniques. But I really got a book of general information.

If you already have a solid grasp on exceptions (e.g. concepts like chaining, when to handle vs declare, custom application exceptions, multi-tier environments, etc) then I don't recommend this book.

This book is very helpful! I strongly recommend it!

I've been using this for a couple of months now, and it's already paid for itself. I like that the author actually spelled out best practices for exception handling in the first part of the book. There are also good pointers for how to avoid common programming problems in Java.

In the second part of the book, there's a lot of good info about exceptions in the Java APIs. It's helpful that the author actually tells you reasons behind WHY code breaks and gives advice on how to deal with problems in code.

Robust Java covers a lot of ground from how to view exceptions in Analysis and Design, to how Java uses exceptions, to how specific APIs use exceptions, to testing and so on. The book's greatest strengths are in the areas of Design and Architecture in which Steve provides solid principles and guidelines for creating an exception model across a multi-tiered system.

Nobody wants to think about all of the things that can go wrong in an application. We all want to think about everything the application should do when everything goes right. But such is not always the case and we need to think about what happens when errors occur and exceptions are thrown.

This book starts with the basics of exception handling. Going through the do's and dont's in a very well written and informative manner. It then presents the exception handling specifics for each of the API, from the Java core, all the way through J2EE. Perhaps the most interesting part is saved for last as the author presents design patterns for exception handling.

This is an excellent work on error handling. It teaches the basics and leaves you with a good feeling that have you tools at your disposal to handle the errors. As opposed to trying to effectively disguise your head as you stick it in the sand.

Of the many Java books I have purchased, this has been the most helpful. I recommend this to anyone learning Java, especially Visual Basic users. Can't wait for an update to cover JDK 1.1.x and Beans.

As a long time VB and ASP programmer, retraining for Java or C# is a mind-boggler. After taking a class on OO Analysis and Design, I can now make sense out of the paradigm of OO, and appreciate it's benefits. But the paradigm shift is so great, that one probably needs more than the syntax training and introductory level OO concepts presented in this book to be successfull with OO. However this is not the author's fault. If you already grasp OO concepts, this book provides superb examples of how to move from procedural syntax and program structures to use inheritance,polymorphism, and encapsulation as provided by Java.

Recommendation
VB pros - Strong Buy.
Delphi pros - Buy.
C++ pros - Don't Buy.

Pros
Author makes language approachable by writing VB code next to Java code. Learning by example snippets makes Java seem easier than it is. This teaching method gives the reader the bonus of a boatload of code samples to play with, all on a CD. These CDs are nice, but I remain unconvinced that a CD justifies the skyscraper prices computer publishers demand.

Cons
Biggest letdown was absence of database material. JDBC came on the scene about the time the book did so perhaps that explains the omission. JDBC or not, the author should have said something about databases. Also, the Internet received too little attention. I was surprised since the Internet was touted by Sun as the language's primary justification (read cross-platform compatibility) after marketing the benefits of a language for toasters and refrigerators warmed programmers hearts like watching a flawless sprinkler system hose your workstation during a supposed fire drill.

Review Abstract
The chapters are organized well and short (<20 pages each). This isn't Moby Dick so biting off small bites and taking time to digest is part of good geek mores. You actually learn to think of VB in an abstract manner - more mores.

Chapter Review Details
1. "What is Java?" A quick and dirty overview of Java. Could have used a fun in the Sun anecdote or three.
2. "Installing & Using Java" Missing any mention of Visual Cafe or Microsoft J++. Perhaps I'm a bit tough here, but author burst out of the gate without even checking on Symantec and Microsoft.
3. "Syntax of the Java Language" Didn't hurt much.
4. "Object-Oriented Programming" Best lesson for Vbers who like pick-it-up-during-lunch training methods.
5. "Using Classes in Java Programming" Whoever gave them the name "class" must enjoy the bewildering look on people. It makes more sense to stick ! with the term "object." It confuses me. I think schedule every time I see "class" instead of methods to accomplish something like returning the number of characters in a string using int len = abc.length();.
6. "Inheritance" Actually a good moniker. Properties and methods are passed on to your version when you base it on a previous object. It's the same as placing a textbox on a form. You have access to the height property even though you didn't write the code for it. Java folk say you inherited the height property.
7. "Java Visual Controls" Just what the chapter title means. About the only chapter that needed more material and examples.
8. "Writing a Simple Visual Application in Java" This is where the book would start to change if the author does another version. This chapter simply needs to include a real tool like Visual Cafe or Microsoft J++.
9. "Layout Managers" Too much said here. VB does it better and, amazingly, Microsoft marketing machine doesn't even demand credit for it.
10. "Using Graphics Methods" I don't know how to draw on paper much less on screen so no opinion here.
11. "Writing a Program With Two Windows" Excellent chapter with a misleading title. Should have gone with Communication between Windows.
12. "Files & Exceptions" Another strong chapter that would have been a good transition into databases.
13. "Using Threads in Java" Best theoretical chapter in the book. I didn't get it all so I'll have to reread it a few times.
14. "Images in Java Applets & Applications" Necessary evil for artistically challenged like myself.
15. "Menus & Dialogs" Nuff said.
16. "Classes & Binary Files in Java" Should have come after chapter 12.
17. "Keyboard Input in Java" Makes me appreciate VB.
18. "Using the Mouse in Java" Makes me like VB even more.
19. "Building Custom Contro! ls" Somewhat tough. I would usually surf far and wide for one someone else's hack before taking the time to do anything complicated.
20. "Using Packages" A way of grouping classes. I never heard of it before.
21. "Building Web Pages" No Java, just plain HTML.
22. "Applets & Web Pages" Late, but finally!
23. "Interacting With Web Page Forms" Really fun section.
24. "What is JavaScript?" Author gets points for due diligence.
25. "Using Sockets in Java" Most powerful chapter. You can get dangerous here.
26. "Math Classes & Matrices" A small chapter that was still appreciated. It would have been easy to add some statistic examples on CD like standard deviation and average of arrays.

As a proficient VB/COM developer, I thought this might be a good book to begin learning Java with. Be warned: It is not! It was written over 4 years ago and it completely out of date. The text makes constant references to the accompanying CD, which does not exist. The book honestly looks like a poor quality photocopy. It is clear that this was writen in 1996 and republished in January 1999 with nary a change in content. The book only goes to VB4, which is long gone. Want to learn Java? Buy Beginning Java 2 by Ivor Horton. I am sending this book back.

This book is unlike any other Java book on the market. For a VB programmer, the comparisons really clear even the most abstracts aspects of Java programming. I highly recommend this book.

This book provides an introduction to creating custom UI components using Java. First there's a guide to effective user interface design, including what to avoid, including examples of real software.

The book then goes through several example of custom UI components. The examples are done with the AWT instead of using Swing for better portability of the code. In the examples, the authors emphasis design principles along with the actual code. The examples are advanced and are written for experienced programmers. The authors then go through the design and development of the example, which is very helpful to understand their design consideration in coding the example. The book ends with an overall software development process and component maintenance.

This book is for Java developers seeking a detailed introduction to designing and implementing custom user-interface components and frameworks. After the user interface guide in the beginning, this book is a tutorial by example. I would recommend the book to anyone who needs to create a user interface beyond the components offered by the standard toolkit.

Professional Java Custom UI Components takes the reader through a planning, design, and implementation philosophy for creating custom user interface components. Hints and tips are discussed, giving important insight for creating components. The authors concentrated on the basic principles of design without creating another reference book. Also, rather than laying out all the nitty gritty code detail, the most interesting portions are highlighted and discussed. A handful of custom components are built to demonstrate these principles. Both the source code and documentation can be downloaded from WROX, and are copyrighted by Krutsch Associates, Inc.

The book tour starts with a discussion of the user interface design, the importance of a good interface that is intuitive to use, and the attention to detail required for a UI component. The authors take the reader through the planning and implementation of a toggle switch and LED component, implementing the event model, specifying the parent container interaction, and rendering strategy. Many tips are provided so that the reader may avoid common pit falls. More complex components are discussed and implemented.

The book ends with an overall software development process and component maintenance. Until this point, the focus has been the "how" of building custom components, now the discussion shifts into a larger context. The authors stress the importance of both before and after the initial implementation.

I recommend reading this book for anyone designing and implementing custom UI components. (September 2001)

At first I was really excited about reading this book. I have several books from the WROX publishers, and for the most part I have found them to be very high above average in their ability to explain their topics in a very deep manner. While I do not think that this book covers Swing very deeply, I still believe that it is a good book for learning the concepts of Swing. Since reading this book I have read other books on Swing (Java Swing by O'Reilly for instance), and I have found that most of them seem to go into a lot more detail than this book. Another thing that I would have liked to have seen in this book would have been more emphasis on different design paradigms (MVC, model-delegate, etc). Design was mentioned, but not as deeply as I was looking for. Overall though, I suppose that it can be difficult to get just the right mix of UI design and API coverage.

When developing client Java applets there is a problem which has no simple solution. The majority of browser installations support Java 1.1 only. If you intend to use Swing you will often have to force the user to download and install the upgrade. This can lose clients because it's too difficult, or limit the user base because 1.2 is unavailable for their platform, etc. In addition, Swing can run quite slow on older hardware. A large part of this book deals with providing equivalent functionality using AWT alone.
This book covers the design and implementation of several components using AWT and then covers what you would do given access to Swing. In the end you have several components that give a good foundation to an alternative library to Swing. You could use the design concepts in this book to develop your own complete library to use when Swing isn't available.
One thing to note when comparing the components in the book to Swing is that Swing was developed in a non-production environment. In a way they had to invent the problems and then create the solution. This code was developed as a result of real problems. As a byproduct the components run very fast compared to regular Swing components.
The chapter on UI design (Chapter 2) is a must for any developer. It details common UI design mistakes that developers make and give practical solutions. I would suggest requiring developers to read this chapter before allowing them to do any UI development of any kind (note I didn't say UI design - I recommend that you don't allow developers to DESIGN UI at all). The chapter on code maintenance (Chapter 11) is very useful and is a skill that many developers lack. Again, this could be required reading for developers.
There are several things about this book that make unique from any other book I've read. The code base is the result of a real, shipping system (used by StorageTek). It's the result of a real, organic development cycle that is also well tested. The code isn't small snippets that were hand built for the book, thus forgetting the interaction with a full application. The code is a full product standing on its own.
The code and topic is advanced and is not for beginning programmers (the name of the book is PROFESSIONAL Java Custom UI components). Bring your thinking cap.

The Core Java (vol 1 and 2) are simply superb books. If you are a developer looking for thorough books on this subject, look no further.

In my review of Professional Java JDK 6 Edition, I said I didn't think one book could cover such a wide variety of topics and expect to do a good job overall. This volume is, I think, an exception that proves the rule.

It is indeed 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, and I must say this title has become 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 in the text, presented in a way that makes it easy to gloss them in favor of the soft copy available by download.

If you need lots and lots of code work on different topics to burn Java into your fingertips -- and there really is no other way to do it -- this book is an excellent choice.

Like many reviewers I find the the Core Java series to be very valuable. However, be forewarned that the kindle edition is not a good representation of the book. The figures are completely useless either because they have not taken the time to convert them properly or because the kindle technology is simply incapable of displaying non-text content properly. I wish I had known this before I paid for the kindle edition of this book.

Updated for Java 6, "Core Java Advanced Features" does not disappoint. This is for those of you who have finished volume 1, either this 8th edition or the 7th edition. Quite frankly, I think in the case of Volume 1 you can skate by with the older 7th edition. However, in the case of the eighth edition of Volume 2, there is quite a bit of expanded coverage to the tune of the resulting book being over 1000 pages in length. It follows the same format as past versions of Core Java Advanced Features. The authors start at the beginning of each topic and walk you through increasingly difficult programs and very well done illustrations and screen shots of applications that are really quite helpful. I include the table of contents since it currently is not included in the product description.

1. Streams and Files
2. XML
3. Networking
4. Database Programming
5. Internationalization
6. Advanced Swing
7. Advanced AWT
8. Javabeans Components
9. Security
10. Distributed Objects
11. Scripting, Compiling, and Annotation Processing
12. Native Methods

Before you go out and buy expensive books on the topics in any one of these chapters, get this book and read the corresponding chapter. It will make whatever you hear or read from that point forward much clearer.

Excelente libro trata cada tema que puedes encontrarte en el iReport, claro muestra ejemplos sencillos y clásicos pero te da las herramientas necesarias para que tú experimentes por tu cuenta.
100% RECOMENDADO

The book is great, helped me learn new techniques to use and to use new tools, such as graphics or subreports.
I recommend to new and experienced users.

Very good book, it is very practical, concise and clear. Examples are very usefull and you can start with almost no knowledge about insides of jaspereport

This was a complete waste of $50. I am a Crystal Reports designer, and wanted a resource that would bring me up to speed with the expression language. This book is 300 pages of screen shots with no examples of input! I don't need to know how to navigate the UI (I learned that in much less time than reading the book would require.) Instead, the critical information - writing conditional expressions, building parameters, creating running total fields - was omitted.

If you have any comfort level with report writing, save your money or buy a reference guide to Java or Groovy.

Good Bits but does not Hang Together Ablan is obviously a good 'techie' but has problems in communicating his ideas. I do not blame him but the sloppy Editing - Sams should hire a new Editor. Not for those starting off with Java & Inet projects. Typos, the CD has wrong chapters & after a few days gave up in trying to get the JIF examples working. There is no documentation / instructions on how to get it up & running (not in the book/CD). What a waste, as looked quite interesting.

No discussion on Servlets vers Applets et al, or the limitations of doing it his way. Advice to Jerry Ablan: get a new editor, cover Servelets & reissue the book Note to SAMS (you seem to be more interested in $$$$bucks~$$$ for profits, too much sloppy & poor editing,compare that with O'Reilly; if I see book released by you versus O'Reilly - GUESS which pedigree I'll buy !!)

I mean like, this book changed everything. Jerry Ablan is the KING of JAVA. He must have had a lot of it to put together a winner like this! Kudos!

Could provide fully developed ready to use applications complete with pass word, http inclusion and references to primer books on data base and jdbc as prepatory to Intranet Applicatons with Java.

This is one of the few Java books that goes beyond being documentation of the API's to actually showing how you would make some applications. His tools coincide with tools we have made for a real application. This is a Java 1.1 book, but the frameworks and utilities Jerry introduces are very useful.

I've used this book to teach my CS1 course for two semesters. The authors implemented some handy classes to make it easy for students to manipulate images and sound, however the book is rough.

One of the authors (I presume Erikson) writes some really terrible code. Here's a sample of some of the worst:

//loop through the columns
for(int sourceX = 0, targetX = 0;
sourceX < sourcePicture.getHeight();
sourceX++, targetX++)
{
//loop through rows
for(int sourceY = 0, targetY = 0;
sourceY < sourcePicture.getHeight();
sourceY++, targetY++)
{
...

(for reference this does exactly the same thing without the extra two variables and the terrible comma operator:

for (int x = 0; x < sourcePicture.getWidth(); x++) {
for (int y = 0; y < sourcePicture.getHeight(); y++) {
)

The images in the book are almost entirely amateur photographs taken by the authors. The subjects of those photos are almost entirely the authors (husband and wife) and their kids, as well as some shots they took on their vacations. This gives the book a very amateur feel.

The later chapters of the book are unpolished. Topics are rambling, some simple ideas with potentially elegant algorithms are explained poorly and implemented roughly (like the code example above).

I've decided to teach the course using the author's Java classes (which contain a few bugs) without using the book. I'd recommend the same; Guzdial makes the code freely available on his website.

I'd give the BOOK 1 star, but the Java classes themselves are worth 4.

This is a GREAT ComputerScience resource for Java Beginners. It has really helped me connect everything that my Professor has taught in class with the actual java applications. There is a CD that comes with this book, that has all of the needed media files to work on the examples and problems.

I used this book to teach a college-level course in Java Programming this year. 70% of the students had taken a 'CS1' level course in Java, and I didn't want to bore them with the same examples. At the same time, the students new to Java needed to get over the syntax and OO hurdles.

The author introduces DrJava early in the book (chapter 2), and provides a set of simple classes that students extend by adding their own methods. The use of Turtle graphics (Turtle class) really helped students 'see' what was happening, and the Picture class allowed them to view and manipulate graphic images as well as learn about arrays.

The Picture class is used extensively, which allowed students to build their own set of methods to manipulate pictures, and use them in a big project to build a collage. Pictures provide a way to get interesting data into a program without reverting to using random() or keyboard input. DrJava allowed students to write their new methods in the 'Definitions' pane, and then test them using the 'Interactions' pane.

Integrating web pages using the URL class as the basis for File I/O is also a great idea. It connects programming to 'real' pages that the students can see in their browser.

The only concerns I have about teaching Java using this book are:
1) Strings are covered quite late and not very deeply (chapter 12)
2) No Swing GUI coverage (students want to write GUIs)
3) Late coverage of 'main' method (p. 366)
-- Students became somewhat dependent on DrJava's interactions pane to test their apps
4) Dependency of book classes for Picture handling
-- Students had to use the getBufferedImage method to display pics on a swing container

I was able to supplement with other GUI material to help students over some of these instead of covering sounds chapters.

Overall, the students did very well. Two-thirds of the students new to Java were able to follow and did very well. All of the students with previous Java experience did well. A few students that had struggled to pass the 'CS1' course showed significant improvement in the ability to complete complex projects.

This is the first of the books I've read that tries to teach computer science via Java to programming novices that I think actually does a good job. It is intended to introduce computing, including programming, to students with no prior programming experience.

This book is full of interesting projects and programs such as splicing words into sentences, reversing sounds to make interesting effects, removing red eye from images, and writing programs to generate web pages from data in databases. There are also lessons and projects that create animations and movies using special effects similar to those found in the movies. This book is not just about programming to manipulate media. Media manipulation programs are hard to write, and can behave in unexpected ways. Thus, answering questions about speed, writing for testability, and other issues of program efficiency and software engineering are handled in the last two chapters of the book.

When dealing with media, apparently the authors did a very good thing and did not have the student attempt to work with Sun's tragically abandoned Java Media Framework, which malfunctions to such a degree that it would discourage even an experienced programmer. Instead the author uses something called "MediaTools", which is in much better shape and is included on the CD along with the development environment, DrJava. With both the development and media-handling utilities already handled for the new programmer, he/she can concentrate on what is important - which is how to accomplish interesting tasks in Java while learning the basics of computer programming. I highly recommend this as a textbook for any introductory programming class. The reader won't be an expert Java programmer by the time they finish the book, but he/she will understand the basics of Java programming and know what questions need to be answered when embarking on the writing of a computer program in any language. The table of contents is as follows:

1 Introduction to Computer Science and Media Computation
2 Introduction to Java
3 Introduction to Programming
4 Modifying Pictures using Loops
5 Modifying Pixels in a Matrix
6 Conditionally Modifying Pixels
7 Drawing
8 Modifying all Samples in a Sound
9 Modifying Samples using Ranges
10 Combining and Creating Sounds
11 Creating Classes
12 Creating and Modifying Text
13 Making Text for the Web
14 Encoding, Manipulating, and Creating Movies
15 Speed
16 JavaScript

APPENDICES
A Quick Reference to Java
A.1 Variables
A.2 Method Declarations
A.3 Loops
A.4 Conditionals
A.5 Operators
A.6 String escapes
A.7 Classes
A.8 Fields
A.9 Constructors
A.10 Packages

This is a pretty well written book, but it's lacking in two respects:

1) The index is terrible. You literally have to thumb through the book to find what you're looking for. For a technical manual, this is inexcusable and greatly reduces the usability of the book.

2) The examples are far too trivial and it never ups the ante so you can see JasperReport examples that are closer to "real world."

I was looking for complex examples on crosstab reports but found only basic examples. I wish they had a chapter on Dynamic reports and a section describing the jasper report object model.

Otherwise it is a good introduction into Jasper Reports as it goes through all the features (rather than searching through the jasper report forum).

There is such a dearth of documentation on JasperReports. This is a very nice explanation on how to use it, there a good set of examples.

Heffelfinger's book meets all my tests for excellence in technical manuals. First, it addresses a development problem I am having today; and it is the only book on the market - including books and articles published by the vendor - that does so. Other favorable attributes include these: the book is less than 3/4ths of an inch thick, weighs less than a pound; cost less than $50 bucks; and there is more white space than dense text.

Some authors of technical books must think we buy their books in order to better understand and appreciate their verbose writing styles. I did that sort of thing in my literature courses. When I am under the gun to produce bullet-proof code I want the insight and keyboard sequences that get me to user acceptance with the shortest time, and the least grief.

Finally, maybe most important, the book is full of brief, readable, complete, and relevant code. When compiled, the code actually works on my ratty old development machine with a minimum number of obscure error messages. There are many references to needed downloads and sources of information relevant to the topics discussed. The error messages can be resolved with some careful re-reading and re-thinking. Thus do we get through our learning curves. Unlike some technical books, the error messages generated by the code in this one are not black holes where hours of time disappear without ever regurgitating a solution to the problem that caused the error.

My first programming opportunity in college had me using machine language techniques to write a five card inventory program on an IBM 1620 with 4K of magnetic core memory. I followed that up with a couple of years on a Displaywriter. In recent years I've had better equipment, and I've learned how to make Agile XP and use cases a part of my daily life, but youthful and sophisticated users who have grown up with the web want lots of tricky stuff on their pocket-size devices. The problem for old guys like me is that the tricky stuff and the devices themselves were never dreamed of in the late 20th century when I was trying to get my programmer chops, but today's users want the stuff, and they want it now.

So, since I enjoy trying to make this stuff, I have been recently engaged in a massive struggle to figure out how to drag my decades of programming experience with Basic, Visual Basic, MS Access, and client-server architectures into the brave new 21st century world of n-tier, the web, java, open source, and mobile, disconnected data gathering.

On page 25 David H told me, the reader, that I was required to use ANT in order to work the examples in his book. This was not an option. By doing so he has shined a light on the yellow brick road to the geek promised land, and this old geek is now going happily down that road. Five stars for "Jasper Reports for Java Developers."

Sadly, I was required to purchase this book for an introductory Java course. The concepts presented are too basic to justify the price for this book, if purchased new. You can just as easily learn the same concepts from the excellent tutorials available online at Sun's, IBM's and other's websites for beginning Java developers. If you insist on a book, I suggest Bruce Eckel's "Thinking in Java," which is cheaper in print and also available at no cost as a PDF download.

In studying for my java certification exam I found the topics in Barbara's book very usefull.One of the fascinating phenomena about this books is it wealth of examples and its "Learn it fast" method which has made the book really commendable.
Topics on writing your own classes I think was one of the best for me.
Props to you Barbara!!!

Simply THE BEST book to learn Java and object oriented programming. The concise examples and easy to follow instructions set all other Java books = null; Advanced topics are made simple with helpful and fun examples such as, "NoCockroaches!". Java Programming Today even includes the Java Development Kit and one of the best programming editors out there. Everything you need to get started is in this book.

This book is jam packed with examples, and down to the point about what you need to learn when working with java. I found it very easy to understand and Barbra makes leaning Java fun. Java is now my favorate programming language! This lady really knows her stuff, I wish she could write all my textbooks!