Product Description
This concise guide to the Java programming language, version 5.0, offers a quick reference for the reader who wants to know the language in greater detail than that provided by the standard text or language reference book. It presents the entire Java programming language and essential parts of the class libraries—the collection classes and the input-output classes.

The second edition adds material on autoboxing of primitive types, string formatting, variable-arity methods, the enhanced for statement, enum types, generic types and methods, reflection, and meta-data annotations. It has been updated throughout to reflect the changes from Java 1.4 to Java 5.0. The final section summarizes and illustrates the new features of Java 5.0 and compares them to the C# programming language. General rules are shown on left-hand pages and corresponding examples on right-hand pages. All examples are fragments of legal Java programs and the complete ready-to-run example programs can be found at the book's Web site, http://www.dina.kvl.dk/~sestoft/javaprecisely/. ... Read more

Customer Reviews (11)

Java precisely... and efficiently
This book reveals the true meaning its title "Java precisely". I wish all authors could learn from the beauty and teaching methodology of this book. Everything is explained with sheer simplicity, without making matters more complicated than they should be. It is very concise and to the point, without any unnecessary waste of paper. So many computer books are becoming bloated and heavy without offering any substance. As one of the other reviewers mentioned, this book reminded me of the K&R book of C. I can't wait to see more "Precisely" titles.

Off the scale...
If your Java is dated (I left around 1.2 and am now returning) or you know another OOP language and wish to get to the meat of the matter in short order, this is the book you need. As of this writing they're asking twenty bucks, which in my estimation gives it an extremely high bang for the buck. Programming neophytes may have issues with this book, however.

I want to see more brief and concise books like this (and indeed the author has done a C# version) on various computing topics. Does anybody really *read* the thousand page tomes that are out there nowadays? Folks, life is too short to waste on extraneous information.

complete in no more space than necessary=the perfect reference
This is a very small book, but complete. These two characteristics allow you to find very quickly the precise and complete information you are looking for. Nevertheless, the book is not for learning Java from start; instead, it is to be used as reference by people who already has a general knowledge of the language.

I am ordering a new copy because I lost my first one.

Precise and Complete
This book is a quick reference for most questions in Java usage. What I find particularly useful is the section on Java Collection and generics. A great work overall.

If you took the Java Language Specification ...
... and boiled it till only the essentials remained, this is what you'd get.There is no other book as concise and yet as complete.The 2nd edition covers Java 1.5 which addresses the concerns of some other reviewers that it might be outdated.Another reviewer compared it to K&R, which is a good comparison.You could very nearly write a Java compiler based on this book.Companion books include the "Java Language Specification" (Gosling, et. al.), and "Java Rules" (Dunn). ... Read more

Product Description

The highly anticipated JavaFX™ technology and platform, including the latest version 1.2 update, is essentially Sun’s approach to Adobe Flash and Microsoft’s emerging Silverlight. JavaFX lets developers play with the open source scripting, desktop, and mobile APIs offered to create dynamic, seamless visual user interfaces (UIs) that are “Flash–like” and beyond…

Learn from bestselling JavaFX author Jim Weaver and expert JavaFX developers Weiqi Gao, Stephen Chin, and Dean Iverson to discover the highly anticipated JavaFX technology and platform that enables developers and designers to create RIAs that can run across diverse devices. Covering the JavaFX Script language, JavaFX Mobile, and development tools, Pro JavaFX™ Platform: Script, Desktop and Mobile RIA with Java™ Technology is the first book tha fully provides JavaFX version 1.2 code examples that cover virtually every language and API feature.

This book contains the following:

• Tutorials that teach JavaFX 1.2 to an application developer or graphics designer who has had no exposure to JavaFX. These tutorials will be exhaustive, covering virtually every facet of JavaFX Script and are fully updated for the JavaFX 1.2 release.
• Reference materials on JavaFX 1.2 that augment what is available from the JavaFX 1.2 Language Reference and API documentation.
• How to take JavaFX 1.2 to other platforms besides the desktop, such as mobile.

Visit projavafx.com for more resources and information from the authors.

What you’ll learn

• Get started with JavaFX Script, including downloading the JavaFX SDK 1.2 and available tools.
• Express user interfaces with declarative scripting.
• Define classes, functions, and attributes.
• Use JavaFX 1.2 and associated tools so that an application developer and a graphics designer can effectively collaborate on an application.
• Uncover the JavaFX 1.2 language and APIs to whatever degree you choose. The tutorials, reference materials, and pointers to resources will be exhaustive.
• Have fun learning JavaFX 1.2 because of the engaging and friendly style in which it is presented in this book.A lot of people have been waiting for a real 1.2 book to buy and this is it!

Customer Reviews (5)

JavaFX Instructional Designer - Sun Microsystems
I learned many details about JavaFX from reading this book. I do work closely with the JavaFX development team, but there are facets to using the JavaFX platform that can only come from end users who are pounding on the code every day. The authors of this book bring their real world examples to their instruction, and they give developers practical information to help them develop with JavaFX. Their expertise spills from the covers of the book--They are all very approachable and willing to answers questions via email and blogs.

They have done a nice job of chunking the material into logical units that progress nicely as you work through each Chapter. The material is ordered from beginning topics to more advanced topics. You can read this book from cover to cover, or you can use it as a quick reference. I'm keeping my copy in my laptop bag so I always have it with me!

Most thorough book on JavaFX
Pro JavaFX Platform is the most thorough book on JavaFX 1.2 to date. I have to admit that the first Chapter was a little daunting like when you are getting ready to get into a cool pool on a hot day.But you know, once you get into the pool, you are glad you did. And I am glad I got past the first chapter.This book is very well written and edited putting the together chapters of four diverse JavaFX experts.

Jim Weaver author and speaker from [...]and author of the first JavaFX book, JavaFX Script: Dynamic Java Scripting for Rich Internet/Client-side Applications is back.

Weigo Gao software engineer with Object Computing Inc, and [...].

Stephen Chin of [...] and founder of the likes of WidgetFx and JavaFXtras, and senior manager of Inovis.

Dean Iverson RIA expert and co founder of Pleasing Software Solutions and now blogging at [...].

This book covers everything from the basics, to using the documentation, to using other libraries, and even mobile device development.My coworkers and I who have been working on a major JavaFX project have used it for reference quite often as it is the most up to date.I particularly like the fact it covers creating and using custom UI components and layout. If you want to go from zero to JavaFX expert or anything in between I recommend you get a hard copy of this book.

Great Comprehensive Reference
The authors of this book have been tracking the bleeding edge of the JavaFX technology from its very inception and along the way have worked closely with us (the JavaFX engineering team) both to understand the technology and give us practical feedback on making it easier to learn and use.This book is everything we'd like our documentation to be: organized, thorough, practical, and easy to read. In fact, I'll be using it as a general reference myself for the areas of JavaFX for which I don't personally work on.

The Definitive Reference for JavaFX
"Pro JavaFX" is a very well-written, detail-oriented, yet approachable read. While learning JavaFX over the past year, mostly from blogs, hearsay, and copious amounts of trial and error, I had a functional, yet "swiss-cheese" understanding of the language. I was effectively a Java programmer writing JavaFX code -- but I wasn't writing idiomatic JavaFX. I wasn't a JavaFX programmer.

PJP answered nearly all of my questions by not only explaining language features and corner cases, but also usually the rationale and implications behind them as well. It made it easy to get excited about the language itself all over again.

For example, take this small code fragment taken from Chapter 7 which will return the number of cells for a given player in a Reversi game (but I don't need to tell you that, because I think the code does a better job):

public bound function getScore(owner:Owner):Integer {
def cells = for (row in board, cell in row.cells where cell == owner) {
cell
}

return cells.size();
}

There's a lot going on here that I like (but not necessarily news): the bound function makes for easy updating of state, and constructing a sequence from a "for" loop almost feels like cheating it's so concise (I think that "return" is optional though).

What's really great though, is JavaFX's "nested" for loops. I find "for (row in board, coll in row.cells where cell == owner)" not only concise, but about as clear as if it were written out in English. PJP is littered with these "idiomatic pearls of wisdom" that helped me realize how Java-centric my JavaFX code was.

The book is a good survey of JavaFX as it exists today (version 1.2). In addition to the language proper, it covers many of the third party libraries (JFXTras, et al.), has a chapter on building a professional RIA book store front type app, and finishes with a solid chapter on JavaFX Mobile.

While readable cover-to-cover, I've found it more valuable as a reference to pick and choose from as needed. For example, today I finally read up on mixins and the different forms of triggers.

I highly recommend this book to anyone interested in JavaFX. It will likely stay on my desk for some time to come.

Everything you need to know about JavaFX 1.2 in one place
Whether you are new to JavaFX or a seasoned Java desktop developer, if you want to get to know JavaFX, then I happily and wholeheartedly recommend the Pro JavaFX Platform book. It is a good book, and it will get you up to speed very quickly. It is based on the latest JavaFX 1.2 release, so you need not worry that you're learning old language and API's.

This book feels like it is primarily targeted towards desktop and rich internet application developers. It contains technical information for developers and designers, and builds a compelling case for choosing JavaFX for web applications and Rich Internet Applications.

Chapter 1, Getting a Jump Start in JavaFX, gives a good introduction to developing applications in the JavaFX language. It brings you up to date on the brief history of JavaFX, and shows you how to get the JavaFX software development kit. It then walks you through the process of compiling and running JavaFX applications, and teaches you a lot about the JavaFX language and API while walking through example application code.

Chapter 2, Taking a Closer Look at the JavaFX Script Language, covers the fundamentals of the JavaFX Script language, including concepts such as variables, primitive types, literal values, and basic operations.JavaFX sequences are introduced in this chapter, along with how to access their members and perform sequence comprehension. By the end of this chapter you have had a comprehensive introduction to the JavaFX Script language.

Chapter 3, Creating a User Interface in JavaFX, associates the metaphor of creating a theatre play with JavaFX development, and discusses creating a stage, a scene, nodes, a model, event handlers, and animating some of the nodes.It then delves into each of these concepts using JavaFX examples, finishing up with a Pong-like game that demonstrates how to detect when nodes in the scene have collided.

Chapter 4, Using Functions, Classes, and Other Advanced Features, discusses how to define functions and classes of your own. It then covers function signatures and function types, and how to write anonymous functions.From there, this chapter introduces how to define class hierarchies, and the covers the details about class types. It also discusses what happens when an object is instantiated and how you can exert control over the process. This is one of the more comprehensive and in-depth chapters within the book, and it will certainly require you to be on your A-game to understand it all. Alternatively, be prepared to re-read this chapter as the need arises.

Chapter 5, Creating Custom UI Components and Charts in JavaFX, explains how to define custom UI components of two fundamentally different types -- custom nodes, and UI controls.After showing you how to create custom nodes in the context of creating a couple of color selection components, it covers how to create UI controls in the context of a stoplight control that has multiple skins.The chapter finishes by teaching you how to use the charting controls to simply and easily create charts in JavaFX.

Chapter 6, Using the Media Classes, explores the capabilities of the JavaFX media classes that make it easy for developers to incorporate playback support for most of the popular formats. This chapter demonstrates how simple it is to include basic media playback support in your JavaFX applications and then shows you how to build more sophisticated playback applications.

Chapter 7, Dynamically Laying Out Nodes in the User Interface, shows how you can leverage the dynamic layout mechanisms of JavaFX to build complicated user interfaces with zero static positioning.These mechanisms include the bind statement, powerful custom layouts built on top of the Panel and Container classes, and the built-in layouts including HBox, VBox, Flow, Tile, and Stack.

Chapter 8, Extending JavaFX with Third-Party Libraries, introduces several of the JavaFX third-party extensions that simplify the development of applications. All of the third-party extensions introduced in this chapter are available as free or open source libraries. This ensures that anyone can make use of these libraries, and also guarantees that you will not be locked into a specific vendor.

Chapter 9, Building a Professional JavaFX Application, shows you some of the professional techniques we use to write real-world JavaFX applications. You will need them when working with a graphic designer, and you will find them useful when you are confronted with the memory usage and performance trade-offs that developers need to consider for real applications. This chapter also provides tips and techniques for enhancing the user's experience.

Chapter 10, Developing JavaFX Mobile Applications, teaches you the basics of JavaFX Mobile development, which will enable you to write portable applications that work on both desktop and mobile devices.During this chapter you'll gain an understanding of the Common Profile, learn how to take advantage of the Java ME capabilities beneath JavaFX Mobile, and adopt JavaFX Mobile best practices that will enable you to write high-performance applications.

The Appendix presents the keywords and the operators of JavaFX Script.Precedence and associativity rules are supplied for the operators.

This book is, I would argue, most relevant for people with previous programming experience. It does not require you to have any previous understanding of JavaFX Script, as it does a very good job of introducing JavaFX Script early in the book. Despite this, if you do come to this book with some knowledge of JavaFX already, the content within this book is very useful to quickly grow your understanding. ... Read more

Product Description
Java Peformance Tuning, 2nd edition provides a comprehensive and indispensable guide to eliminating all types of performance problems. Using many real-life examples to work through the tuning process in detail, JPT shows how tricks such as minimizing object creation and replacing strings with arrays can really pay off in improving your code's performance.Tuning J2EE applications bears many similarities to tuning J2SE apps, but important and specific considerations apply. For this reason, Java Performance Tuning, Second Edition includes four new chapters: a new chapter on J2EE application tuning in general followed by chapters on tuning JDBC, servlets and JSPs, and EJBs. Java Performance Tuning offers common-sense advice about what to tune and what to leave alone, emphasizing techniques that provide big performance gains with minimal code restructuring. It gives you crucial guidance that helps you tune without destroying your program's architecture. Blindly changing things in an effort to make a program run faster is a great way to create buggy, unmaintainable code. Java Performance Tuning teaches you to work efficiently and effectively, resulting in code that is robust, maintainable, and fast. ... Read more

Customer Reviews (46)

Outdated
Lots new features of JDK should be included.
Too much author's personal idea which are really debatable.Do not consider every thing mentioned in this book should be followed.

Good book on performance
Pretty good book on covering a majority of the performance issues for Java and how to code for performance.

Ups and Downs, but generally down
The book covers a wide range of topics with some decent, but out-dated examples.As a collective whole, this writing will get you thinking.However, some suggestions provided are impractical and simply not effective enough to warrant implementation.Providing pros and cons in the majority of examples provides some jewels of information and things to think about, but it does not live up to the massive amount of difficult, wordy reading involved or the overly verbose samples.

I was able to take some things away from this book, but not nearly enough to warrant recommending it.

Sorry guys, it's a dud.

Authoritative and practical, but not for everyone
If you are a core Java developer/architect who does performance tuning on a regular basis this should be part of your library.

Over time, this has been the most useful of the dozen or so performance books I own. It's scope is narrow - core Java tuning and it skates over the distributed computing smells that seem to be the most common cause of hot spots in today's Java apps. The author isn't afraid to describe unorthodox or ugly tricks when they can bear fruit. The custom Class object that seemed to offend some reviewers helped me track downa gnarly memory issue in an app that was too bloated for OptimizeIt to be practical. Doing the "wrong thing" to get the "right result" can be the essence of pragmatism. The section on StringTokenizer implementation is a great example of unpicking a typical performance issue from inappropriate use of a general purpose class.

Performance tuning is a specialty that demands pragmatism, confidence, persistence, creativity and a high tolerance for ambiguity and uncertainty. I suspect that only a minority ofthe population of competent developers have the necessary assortment of personailty quirks to be effective performance engineers. Black and white thinking, sometimes a trait of smart developers, is a disaster for performance engineering.

A report from the field...
... or "You had a whole SECOND to reply? In MY day..."

First: if you are not a 'hardcore' Java programmer: do not bother with the rest of this review, and do not buy this book until you reach that point. It won't help enough to offset the damage it causes.

That said, a bit of context: the project I was working on that inspired me to buy a copy of this book involved a telecom system that had to handle hundreds of transactions a second, with sub-second response times (yes, in Java). Not the biggest system, or the fastest, but definitely not "fancy GUI code", by any stretch of the imagination.

Don't buy this book to learn how to use an optimizer; it isn't a beginner's guide. After buying it, I only ended up using perhaps two of the items covered in the book, while working on the project. But those two points were things that the several hundred collective years of development experience on the project had missed, and every other topic in the book warranted at least the question "did we check for this?"

It is difficult to categorize the audience of this book; it is in the odd position of needing to be far too heavy on theory and detailed explanation to be a "cookbook", for it to be of any use, but it also has to cover topics so diverse that it is unlikely that more than a handful will ever apply to any single situation, so it isn't really a "how to" book, either.

So why did I give this book four stars? Because a different set of points in the book applied on the next project I had to work on. But those 4 stars with a warning: for the audience and topics that it covers, this book it is *very* good, and for anything or anyone else, it will be, at best, nonsense; at worst, using it can be actively counterproductive (as another reviewer noted, several of the things the author covers are not for the faint of heart, and for very good reasonss).

It failed to earn five stars for two reasons: first, while the author has a clear grasp of his material, his grasp of the audience seems to be hazy at times. Like the marketing of the book itself, he seems to have trouble deciding whether his audience is experts looking for that one golden tweak, or novices (who, in this case, should look for a more introductory book on profiling and optimization in general, or the tools they have available, in specific).

The second reason is not a problem with the material itself, just the passage of time - this edition predates the release of the Tiger version (of Java, not Mac OS X), and thus does not cover it. However, anyone attempting to use this book to work with Tiger should, in my opinion, strongly reconsider doing so; while the fundamentals of how to do the analysis remain the same, the details of several of the issues the author discusses are *completely* changed in Tiger. ... Read more

Product Description

Have you thought about building games for your cell phone or other wireless devices? Whether you are a first–time wireless Java developer or an experienced professional, Beginning Java™ ME Platform brings exciting wireless and mobile Java application development right to your door and device!

Beginning Java™ ME Platform empowers you with the flexibility and power to start building Java applications for your Java–enabled mobile device or cell phone. The book covers sound HTTPS support, user interface API enhancements, the Mobile Media API, the Game API, 3D graphics, Bluetooth, and more.

Further, this book is easy to read and includes many practical, hands–on, and ready–to–use code examples.

What you’ll learn

• Discover the various aspects of Java ME, including J2ME and CDC, with special attention paid to the up–and–coming JSRs that will be integrated with future Java ME releases, such as MJSP (JSR248 and JSR249).
• Solidify your understanding of the Java platform and which parts of the platform are in various JSRs to help you select the appropriate market–supported platforms on which to deploy and port your applications
• Explore the full life cycle of Java ME application development, from design to application obfuscation to signing for carrier validation and release.
• Create multimedia and game applications from scratch using the Mobile Media API, Game API, and other APIs most suited for mobile Java–enabled devices and cell phones.
• Work with the latest tools, including NetBeans 5.5 and the NetBeans Mobility Pack.

Customer Reviews (2)

The earlier book by the same title is better
The notes are too brief - not for beginners. The earlier book with the same title is better (although dated). This book would be 5-stars if the author had taken the trouble to go into greater depth on the explanation using tutorial-style writing. Nevertheless, it is the only latest book (as of date of writing) on JME. Since I already have background knowledge in JME I was able to follow along with the summary-style writing.

Ideal for beginners
Mobile device programming is a fast-growing area of information-technology industry. There are new advanced mobile devices with interesting software platforms lounched every day. They provide a various range of programming languages and rich APIs. We can program in c++, objective-c, python, etc. and use almost every functionality that our phone or smartphone offers. But only one platform is available on almost every phone and will be available for a long time. Only one platform provides us such portability that our software could be used on almost every handset regardless of it's manufacturer. I think that this is a good enough reason for anybody interested in mobile device programming to learn Java ME regardless of how he likes java and how limited and obsolete he thinks the platform is.

"Beginning Java ME Platform" is an ideal position to begin the adventure of programming mobile devices in Java ME. In the first chapters of the book we will find the basic information about the platform and philosophy behind many of it's solutions. Thanks to this the platform will become more friendly and our complains about possible limitations lesser. Later chapters explain how to use our java knowledge to write first applications. And yes, we need to have at least a basic java knowledge to start with the book. The book explains the differences between standard and mobile Java editions from the differences in basic assumptions to quite detailed differences in packages. We will learn how to use almost every API provided by the Java ME platform, including Game API and Wireless Messaging API.

This book is even more than a beginner needs. It is targeted for the beginner but in can be used by more advanced java me programmers as well. If you already had experiences with mobile java you can use this book to verify and complete your knowledge.
The only concern I have with the book are very long code listings, often stretched out to many pages. I agree that thanks to them we can see exactly how the full program is constructed and that it is an excellent feature for beginners in the Java ME world but I think that to understand some issues short and clear snippets would do.
... Read more

Product Description
This book teaches the reader how to write programs using Java. It does so with a unique approach that combines fundamentals first with objects early. The book transitions smoothly through a carefully selected set of procedural programming fundamentals to object-oriented fundamentals. During this early transition and beyond, the book emphasizes problem solving. For example, Chapter 2 is devoted to algorithm development, Chapter 8 is devoted to program design, and problem-solving sections appear throughout the book. Problem-solving skills are fostered with the help of an interactive, iterative presentation style: Here's the problem. How can we solve it? How can we improve the solution?.

Some key features include:

• A conversational, easy-to-follow writing style.
• Many executable code examples that clearly and efficiently illustrate key concepts.
• Extensive use of UML class diagrams to specify problem organization.
• Simple GUI programming early, in an optional standalone graphics track.
• Well-identified alternatives for altering the book's sequence to fit individual needs.
• Well-developed projects in six different academic disciplines, with a handy summary.
• Detailed customizable PowerPointTM lecture slides, with icon-keyed hidden notes.

  Student Resources:

• Links to compiler software - for Sun's Java2 SDK toolkit, Helios's TextPad, Eclipse, NetBeans, and BlueJ.
• TextPad tutorial.
• Eclipse tutorials.
• Textbook errata.
• All textbook example programs and associated resource files.

Instructor Resources:

• Customizable PowerPoint lecture slides with hidden notes.Hidden notes provide comments that supplement the displayed text in the lecture slides.For example, if the displayed text asks a question the hidden notes provide the answer.

• Exercise solutions.
• Project solutions.

"The authors have done a superb job of organizing the various chapters to allow the students to enjoy programming in Java from day one.I am deeply impressed with the entire textbook. I would have my students keep this text and use it throughout their academic career as an excellent Java programming source book".Benjamin B. Nystuen, University of Colorado at Colorado Springs.

"The authors have done a great job in describing the technical aspects of programming. The authors have an immensely readable writing style. I have an extremely favorable impression of Dean and Dean's proposed text".Shyamal Mitra, University of Texas at Austin.

"The overall impression of the book was that it was friendly to read. I think this is a great strength, simply because students reading it, and especially students who are prone to reading to understand, will appreciate this approach rather than the regular hardcore programming mentality".Andree Jacobson, University of New Mexico. ... Read more

Customer Reviews (9)

Absolutely Outstanding Book!!!
This book was required for a course I was taking at University.Having read the entire thing I must say, it is hands down the best programming book I've ever read!This is saying a lot as I have been through several different books.This book is the most logically arranged, comprehensive treatment of the subject I've found.The authors have a great writing style that is conversational and very easy to read.Although I read this book for school, I would highly recommend it for someone wanting to learn how to program.Upon completing the book I was able to write a relatively advanced level GUI program in Java, with no help from another programmer!I would buy this book and read it even if it hadn't been required.

Introduction to Programming with Java
The book was in stock and cheaper than what my son could get it from his school. It was delivered to our house very quick. It was the correct book and everything is great. What else can I say?

Perfect
Quick shipment and conditiona as promised. But do not take this class unless you need it. Terrible class.

An excellent tool for teaching Java
I am currently using this book to teach Java to a group of students with widely differing backgrounds.The detail the authors provide, the accessible language make this an excellent teaching tool for both students with limited programming backgrounds and those who are more knowledgeable.

The optional sections for introducing GUI interfaces in the early chapters were very popular with all the students. As a teacher I found both the assignments in the book and the project suggestions in the teaching resources very helpful in giving students practical experience.

The book organization allows you to easily pick the topics you wish to discuss and tailor your class to the needs of your program.I'm very happy to recommend this book.


SLOOOOOOOOOOOOOOOOOOW
I ordered the expedited shipping and it was still shipped late, I did not get a refund for the expedited shipping and I was not able to use my book for class when I needed it. ... Read more

Product Description
With a variety of interactive learning features and user-friendly pedagogy, Java 5 Illuminated provides a comprehensive introduction to programming using the most current version of the Java language, Java 5. In addition to providing all of the material necessary for a complete introductory course in Java programming, the book also features flexible coverage of other topics of interest, including Graphical User Interfaces, data structures, file input and output, and applets. Object-Oriented Programming concepts are developed progressively and reinforced through numerous Programming Activities, allowing students to fully understand and implement both basic and sophisticated techniques at a pace which is neither too fast nor too slow. OO concepts are blended appropriately with fundamental programming techniques, including accumulation, counting, finding maximum and minimum values, and using flag and toggle variables, and supplemented with coverage of sound software engineering practices.

Distinguishing this text from other introductory Java books is the authors’ extensive use of an "active learning" approach to presenting the material through abundant use of graphics, visualization exercises, animations, numerous full and partial program examples, group projects, and best practices. These and other pedagogical devices facilitate hands-on, interactive learning, and make the book equally appropriate for use in "traditional" lecture environments, a computer-equipped classroom, or lab environment. ... Read more

Customer Reviews (2)

Nice exercises
The school I've been teaching CS I and CS II at for the last five years used this text for both classes recently.Some members of my department criticized it (fairly, I think) for being somewhat weak on OOP (user-defined classes don't come until Chapter 7 and even after that their use is not pervasive in the examples) and deficient in OOD. We were therefore switched to another text.I now find myself sorely missing the strengths of Java 5 Illuminated: the exercises.Each chapter has a _ton_ of exercies, many of the drill type (what's the output of this, what line completes that, etc) that are tedious to construct but that weaker students need in order to build confidence with syntax.The authors write most of the exercises without referring back to the examples they've used earlier in the chapter, which is a big plus for me since I usually write my own examples.Each chapter is written clearly if a bit simplistically.Until I find what I consider to be a 5-star text I would be happy to use Java 5 Illuminated again since the missing pieces in it are easier for me to make up for than the missing pieces in other texts.

Excellent intro to Java 5
The book is an excellent introduction to Java 5. This book does a very good job at teaching Object-Oriented Programming in an easy to understand progressive manner. All examples in this book are very instructional, and yes, the examples do compile. Kudos to the authors, Herve and Julie.

As an experienced Java programmer, I found this Java resource very useful in emphasizing my software engineeering practices and helping me to focus on designing and writing correct, maintainable java programs.

Chapter 4 detailing Applets and Graphics was very informative for me detailing methods for creating graphical output and drawing shapes and text.

In Summary, this resource is a must have for any Java Engineer's technical library. ... Read more

Customer Reviews (30)

A good reading which could be better
Mark Allen Weiss's "Data Structures and Problem Solving Using Java, 3rd Edition" is a good reading if you're already familiar with Java and a few other programming languages, and want to start learning about data structures in a structured fashion. The text is easy to read and understand, and is accompanied by a good plenty of examples. Even if Java is not your primary language, the author reviews basic Java programming in the first few chapters in a way that you can learn/remember most of the important features of Java.

"Data Structures and Problem Solving Using Java, 3rd Edition" is a good reading and I advise it to people who want to learn about data structures. Nevertheless, it could be a better reading. Weiss is also the author of similar book for C++, and it appears that he has simply ported the C++ examples of that book to "Data Structures and Problem Solving Using Java". Therefore, some of the examples don't follow a good coding style or are not compliant with the traditions in Java programming. The author also skips the proofs of some theorems in the interest of space, but it would be a better idea to provide them as an appendix at the end of the book.

Perfect
The book arrived, no discernible damages. Even smelled brand new -- as described. Excellent product.

Not For Beginners
I was required to purchase this text for my course. Having never programmed in java before and not having a strong programming background, I found this book almost impossible to follow. This book is definitely not for beginners and assumes previous knowledge of java. I did not find the explanations or examples in the book clearly written. After continued complaints from the class, the professor abandoned the book altogether after just 3 weeks. If your a beginner, stay away from this book.

Certainly not for beginners in OOP
This book is a college textbook for my data structures java class.I was not new to programing at the start of my course, however I was new to OOP.This book does a horrible job of explaining the concept of OOP which, in my opinion, is difficult to grasp at first.The information in this book is very dense.Complex concepts are only given an explanation that is a page or two long (ex: Binary search trees).The examples aren't horrible, but they lack ample documentation.Now that I fully understand the concepts (thanks to the internet) this book makes an alright reference.Overall, if you already know Java or C++ or a similar OO language, this book is probably exactly what you need to learn how to store your data in Java, but if you don't know what OOP is, look elsewhere.

not so good
book is not so good. explanations are overcomplicated, even for simple issues. If you are beginner get "Teach yourself Java in 21 days" instead. ... Read more

Product Description

Design Patterns in Java™ gives you the hands-on practice and deep insight you need to fully leverage the significant power of design patterns in any Java software project. The perfect complement to the classic Design Patterns, this learn-by-doing workbook applies the latest Java features and best practices to all of the original 23 patterns identified in that groundbreaking text.

Drawing on their extensive experience as Java instructors and programmers, Steve Metsker and Bill Wake illuminate each pattern with real Java programs, clear UML diagrams, and compelling exercises. You'll move quickly from theory to application—learning how to improve new code and refactor existing code for simplicity, manageability, and performance.

Coverage includes

• Using Adapter to provide consistent interfaces to clients

All source code is available for download at http://www.oozinoz.com. ... Read more

Customer Reviews (10)

Good book on design patterns.
This is really a good book on the design patterns which I reckon being better than the original one, in the sense it provides a higher clarity degree. Each pattern is explained in depth along with some good code and UML diagrams.

Poorly written
I am going through this book now. It is horrible.

The authors use examples from rocket science to explain the concepts in the book. They could have picked simple day-to-day examples like a library or a movie store. But instead decided to use rocket science. Then there is something called Oozinoz. I don't get exactly what that is or how it is relevant to Design Patterns. But the authors use that a lot. If what I have written sounds vague, well that is because it is.

Secondly, the organization is very bad. The meat-and-potato of the learning is hidden away in "challenges." Let me explain. At the beginning of every chapter, the authors briefly explain the problem to you. Then instead of providing a solution, they throw a challenge to you to solve the problem. To view the solution one has to flip to the back of the book where it is provided in vague esoteric diagrams. This is not the way to write books.

There are 23 patterns allegedly described in this book. I haven't understood any of them. The few I knew from before like Singleton and MVC, I am now more confused about them. I wish I could get a refund for this trash.

Horrible book
I have read the classic Design Patterns book (from the GoF) and wanted the same book but with Java examples. This book isn't even close. The explanations are so shallow and/or convoluted that even with previous knowledge of design patterns I struggled to understand what the author tried to explain. The Java examples are incomplete, boring and completely fail to illustrate the topic.

And most of all, the book is a collection of "CHALLENGES". They are not questions meant to challenge the understanding of what has been read but ask the reader fundamental questions and concepts, without any attempt to offer any basic explanation first! It's infuriating and frustrating. You must constantly turn the pages to the solution chapters! It's, at best, distracting.

I don't understand why authors would follow such formats. When I buy a study book I don't want to be challenged I want to be taught! Challenges already exist and are the reason why I buy study books - to get answers! This book doesn't offer any.

I threw that book in to the recycling bin the day after I received it.

Good Book
pros:
1. Good descriptions of the patterns.
2. Good explanation of how to use the patterns to solve a particular problem.

Cons:
I wished the examples were better. Most people are not familiar with CAD systems, so a more common software problem would have been more helpful.

not a GoF for javarians
I am a beginner in OO programming and Java. I have had to read a lot recently and this is not one of my better purchases.

An earlier reviewer commented that the format/structure is a problem - I also found it annoying. I dislike authors that play pantomime with complex topics like this. Further, when my mind is in computer mode the often used sentences in this book like"if you want to ..." confuse my subconscious learning brain. This is because I may not "want" but may "need" - and I need to figure out why/if/when I may want this thing.I feel that this indicates that the authors are not confident in concisely explicating a complex topic.

Some things grate, for example the Singleton Pattern is classified differently (Responsibility Pattern) here to the GoF book (Creational Pattern).I don't see the communicational point in messing with the acknowledged but the perhaps disputed GoF masters (Design Patterns) and their accepted wisdom.

Technically this book does not appear complete. In discussing thread safety for the Singleton the book provides a synchronized example but not a "double-checked locking" example as does Head First Design Patterns (Head First). The double-check reduces the use of synchronization in a frequently accessed singleton and speeds things up dramatically.Omissions like this don't inspire confidence.

The book feels light in Java code examples. It is not a clear Java focussed exposition on patterns. It does not provided comprehensive Java examples on common patterns to insert in production (where I am personally at now). It seems a missed opportunity because I wished so much.

I was hoping to outgrow my Head First(HF) experience, but this book does not do that. I would recommend the HF book over this one - even if you are annoyed by the HF style. HF seems to have been more thought out.

This book added little to the GoF and HF books I have read.

This book maybe useful for Java programmers who have not been exposed to patterns or for undergraduate classes.

... Read more

Product Description
To ease readers into Java, Programming with Alice and Javaintertwinesthe ideas of object-oriented programming in both languages. Programmingin Alice is explored first to establish fundamental principles andskills using 3D animations in a fun, visually rich environment. WithAlice as a foundation, Chapter 6 introduces readers to Java. The remaining chaptersimplement concepts in the Java programming language using interestingexamples and drawing parallels between the two languages to keepreaders engaged. Alice: Objects; Methods and Data; Control Statements; Events; Lists and Arrays. Java: Objects and Classes; Events; Lists and Arrays; Inheritance; Exceptions and I/O; Recursion. For all readers interested in an introduction to programming using Alice and Java. ... Read more

Customer Reviews (2)

Fast and fantastic
The book and software came in at a very fast timeline. I needed it for class. The condition was also top-notch. Thanks!

rapid migration from Alice to Java
There are already several books out there devoted to Alice (eg. Learning To Program with Alice (2nd Edition)). But the current book differs significantly. It gives a quick introduction to Alice, with a stress on conveying some key ideas in object oriented programming. Here, there is less space devoted to an exhaustive tour of Alice's features.

Instead, the intent is to take the student well beyond Alice. Thus it explains the shortcomings of Alice. Like how it is difficult to add new classes, which is a very basic task when coding any "real" OO language. This severely limits the student's experimentation. Books solely on Alice rarely bring up these issues.

The pedagogy is to rapidly migrate the student from Alice onto Java. Alice is used as the starting point, and it might help to have some prior acquaintance with it before reading the book. A Java graphics program, Thunkit, is explained by the text, and used to aid this migration. Simple GUI programs are written out and run. The student gets accustomed to reading and understanding a mass of source code. The verbosity can initially be daunting. But the book soon lets her absorb this.

If you are an educator teaching Alice, the text lets you recognise and educate your students about the true use of Alice. It is meant for youngsters, to grab their attention and teach OO. But Alice is not an endpoint. Other than such teaching, Alice is not used for professional coding. Unlike Java.

... Read more

Product Description

In this text, readers are able to look at specific problems and see how careful implementations can reduce the time constraint for large amounts of data from several years to less than a second. This new edition contains all the enhancements of the new Java 5.0 code including detailed examples and an implementation of a large subset of the Java 5.0 Collections API. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amount of efficiency. Readers should have some knowledge of intermediate programming, including topics as object-based programming and recursion, and some background in discrete math.

Customer Reviews (19)

An awesome advanced data structures & algorithms book
This book is quite advanced as many others have written in their reviews. Maybe it should have had a "pre-requisites" section, telling what background the author expects from the reader. BUT with that said, I love this book and could not put it down from the time I started reading it.

Weiss has driven the points across very well. Right from page 1 the book is quite exciting to read. Weiss stresses the importance of recursion and shows many good (and a bad) uses of recursion. Chapter 2 illustrates bad and good algorithms with elegant examples - all the algorithms and their computational complexities are explained in detail very well in Sec. 2.4.3. I could not wait to get to the O(N) algorithm, and then there is the surprise - it is so simple, what the heck am I missing? And then you realize you are not dumb and the short program does involve some serious intelligence behind it!

This book has really flexed my mind very well and I love reading it! I am sure I will learn a lot more as I read more from it. And I feel this book does not deserve a poor 3-point rating and does deserve more 5-point ratings by advanced readers.

book was stolen from a library??
Condition of the book is acceptable, somewhat used and marked up. No problem with delivery.BUT:

This is evidently a book from a college library, with the library name, stamp and barcode still in it, and a due date less than 2 months before I purchased this book.The RFID set off alarms when I carried the book into the library at our university here.

I checked the library's website and this book is listed as Missing. It's upsetting to find I am at the receiving end of a book that was either improperly removed from a library or stolen from the person who checked it out. I would not patronize this seller again.

Could have been better
I felt the author has a firm understanding of the concepts and truly what he wanted to convey, but this book lacked a great deal for beginners or newcomers to Java. Far too many of the examples were tough to understand and in many cases simply un-answered. This is not a book for beginners.

Not as good as I expected
It is a nice book but i expected something better. I don't know what it is but something is missing here. I like the C/C++ version of this book better for some serious learning. On the other hand this is a good opportunity to learn java programming at the same time if you haven't mastered it yet.

not a book for beginners
If you don't know Java, don't expect to be able to learn the things you need to for a class.If you learned how to do alorgithms in mathematics, it may not be enough for computer science.You probably want to get a supplemental or two if you have to get this book for class.It is quite advanced and a hard read. ... Read more

Product Description
Expert Solutions and State-of-the-Art Code Examples

SOA Using Java™ Web Servicesis a hands-on guide to implementing Web services and Service OrientedArchitecture (SOA) with today’s Java EE 5 and Java SE 6 platforms.Author Mark Hansen presents in explicit detail the information thatenterprise developers and architects need to succeed, frombest-practice design techniques to state-of-the-art code samples.

Hansencovers creating, deploying, and invoking Web services that can becomposed into loosely coupled SOA applications. He begins by reviewingthe “big picture,” including the challenges of Java-based SOAdevelopment and the limitations of traditional approaches. Next, hesystematically introduces the latest Java Web Services (JWS) APIs andwalks through creating Web services that integrate into a comprehensiveSOA solution. Finally, he shows how application frameworks based on JWScan streamline the entire SOA development process and introduces onesuch framework: SOA-J.

Customer Reviews (22)

Excellent book on JAX-WS insides
The book is excellent for an experienced Java developer. Some JAX-WS practical knowledge is almost a must as the book dives into very details and you would get lost if you didn't work with JAX-WS (Metro) before. But that's exactly what I needed. Definitely recommended. I don't know any better JAX-WS book so far and so comprehensive.
The only downside could be that it's an early bird and thus is based on first GlassFish/Metro implementation (JAX-WS 2.0) and doesn't cover WebSphere web services or any extensions going beyond JAX-WS. But hey, that is a story for a different book.

Excelent book about how a general WSPA ( web-service platform architecture) works
It's absolutely an excellent book! It goes in enough details to understand everything about web-services, and what technologies an web-service platform (e.g. J2EE) exposes to developers.

Covers a lot of the details needed
This book covers many of the details needed for successful use of web services with Java.It goes a little further and gives some philosophy for use of web services that should lead to maintainable services.

A great and very difficult SOA book
I've read all of the reviews here, which are interesting and provocative. The ironic thing is that I agree with much of what the one and two star reviewers said but still rate this book 5 stars.

Potential buyers need to know what they are getting. This is the single best book on JWS programming available. It's incredibly dense. The acronyms fly all over the place. Hansen dives into technologies and if you don't know the technologies already you will find yourself spending hours digging into things like XSLT. We're talking about many, many hours to swallow the whole thing. It's an expert's book - anyone who is serious about JWS and SOA has to have this book with Monson-Haefel 'J2EE Web Services' right next to it to cover the stuff Hansen doesn't address.

But I also recommend the book to people who are less serious and have less time, and even to beginners. These readers should buy the book, start with section 7.7 (an excellent demo of the Java 6 Endpoint class, which is as simple as JWS gets), and maybe do Chapter 3 to learn something about REST (also fairly simple). Then put it on your shelf until you have a few hours free, and tackle a section of one of the chapters. Keep at it, though it might take a while. This book will improve your understanding over time. I've encountered a few technical books which I've worn into a limp condition from reading and re-reading - this looks like another.

Good book, too fine grained project distribution
This book can be really good if you are used to work with maven and ant, otherwise it will be hard to follow. So if you are the kind who likes and best understands things by putting your hands on source code, I'd recommend getting a grasp on the mechanics of maven first, otherwise you'll be struggling with the book contents as well as with maven gimmicks.

I personally like to import maven projects into eclipse to dive in the source code, but since eclipse does not support "project nesting" I have to create a new project for every example. Take chapter 3 for instance:

It has 4 subdirectories:

eisrecords
rest-get
rest-post
xslt

Inside rest-get for instance there a 4 maven projects, 2 for services and 2 for their respective clients, and they all have 1-2 classes.

The projects work fine once you have set up your environment properly, however I'd much prefer that every project was put into a single unit (on a per chapter basis) with proper pure ant tasks - which in some cases wouldn't be so hellish to code because there aren't that many dependencies to manage, but still, using maven to build is less error prone.

Other chapters are indeed built as maven modules which makes it easier to import to eclipse but still, it's not cool having to deal with so many projects for such small examples.

I personally like the writting. I'm still on chapter 5 but so far it was the best book on the subject I could find. It goes beyond hellowordish examples and is filled with code which can be "easily" tested. ... Read more

Product Description
LEARN TO USE JAVA MESSAGING SOFTWARE IN YOUR DISTRIBUTED APPLICATIONS!

As software becomes more complex, and the Web is leveraged further, the need for messaging software continues to grow. Virtually all software written today requires at least one form of internal, and even external, communication. Java Messaging explores the various methods of intra-process and inter-process messaging for Java software, such as JavaBean events, JMS, JAX-RPC, JAXM, SOAP, and Web Services. Programmers will learn the basics of these APIs, as well as how, when, and why to use each one, including how to use them in combination, such as combining SOAP with JMS over a WAN. The book begins by walking the reader through simple intra-process communication using JavaBean events. A set of classes is constructed that extend JavaBean events beyond one JVM, transparently using JMS. The messaging paradigms of JMS are explained thoroughly, including in-depth discussions on the theory and mechanics of message queues. Design patterns and helper classes are also explored, which ultimately combine to form a generic messaging framework that helps programmers avoid common pitfalls. This framework, explained throughout the book, provides for the seamless integration of JMS with SOAP Web Services that is required to build distributed applications. Starting from the first chapter, a comprehensive sample application (an online stock trading system) is built using the framework and messaging paradigms discussed in the book. By the end of the book, programmers will not only understand the various messaging paradigms, but they will also understand how to architect complex distributed applications that use them together – with a framework that provides a running start.

KEY FEATURES • Explores the various methods of intra-process and inter-process messaging for Java software, such as JavaBean events, JMS, JAX-RPC, JAXM, SOAP, and Web Services• Provides programmers with the practical knowledge of when and how to use each API alone, as well as together• Explains the messaging paradigms of JMS, including in-depth discussions on the theory and mechanics of message queues • Includes a development framework of classes for programmers to apply to their own projects• Teaches concepts through a comprehensive sample application (an online stock trading system) that uses the framework andmessaging paradigms discussed within the book• Includes a CD-ROM with all of the sample code, the complete messaging toolkit that is explored throughout the book, open source tools, and all of the figures from the book

On the CD! * Source Code: Includes the sample applications referenced within each chapter * Figures: Contains all of the figures from the book, arranged by chapter * Java Tools: Includes the open-source tools used in the development of the book’s sample applications and toolkit* Toolkit: Contains the final, complete, messaging toolkit that is explored throughout the bookSYSTEM REQUIREMENTS (WIN) Windows NT/2000/XP/2003; 256 MB RAM minimum, 512 MB recommended; 250 MB of available disk space, 500 MB recommended; J2SE version 1.4.2_06 or higher; CD-ROM or DVD-ROM drive; keyboard and mouse, or other pointing device ... Read more

Customer Reviews (6)

Good one
good book. author has explained it very well and do try chapter code it will help understanding concept easily.

Nice work
As other reviewers pointed out, this is indeed a nice work on Java Messaging. For the most part, the concepts are presented clearly and I had no trouble following them. What's good about this book is that there are enough examples to play with and most of them indeed work as promised in the book. This book uses ActiveMQ 2.1 for JMS Provider while the current version is 5.x. However, the ActiveMQ 2.1 libraries are included in the CD, so using those you will have no problem in running most of the examples. I could not get the examples that use Java Web Service Developer Pack (JWSDP) to work however (chapters 8 and 9). This book uses JWSDP 1.4 version which I could not find on the web (at the time of this writing only JWSDP 2.0 is available for download on Sun's site). The book says that JWSDP 1.4 is included on the CD but it was not. Except for these minor issues, this book is worth reading and owning. Highly recommended.

Saved my job
Although the book uses a specific JMS engine for the examples the details and the concepts were all right on and covered everything I needed for JMS.It literally saved my bacon, especially the peer to peer stuff over topics.Whew!

Super job.

Sam

Concise, no-nonsense, but framework hinders learning
Excellent introduction to messaging, including healthy portions on JMS and web services.

The writing style is clear, consistent, and to the point. Probably what I liked most was this no-nonsense writing style. If it's on a page, it's important to understand. The author doesn't waste your time with irrelevant discussions or out of scope topics.

Editing and code presentation are top notch, making it easy to follow, and build upon from one example to the next. The author also shares some gotchas and considerations that I wouldn't have expected to see in an introductory discussion which were particularly valuable.

Another great feature is one of the drawbacks of the book. The framework presented in the book is elegant, but in many of the examples, there is too much cognitive overhead involved in grokking the level of abstraction in the framework, and this takes away from actually learning the concepts. I would have liked to see more non-framework code for the introduction, which is then tied together with the framework.

For programmers: messaging basics
Eric Bruno's JAVA MESSAGINGexplores different ways of messaging using Java software, from JavaBean events and JMS to SOAP. Web programmers receive all the basics to using these features, tips on how and why to use each feature and when to choose something else, how to combine features, and more. The basics of Java communication processes are revealed in chapters which form 'classes' to link related information in a logical progression. An excellent, basic foundation for Java users. ... Read more

Product Description
This new book presents concise and complete coverage of Java Persistence API 2.0, the latest Java technology on persisting Java objects to relational databases. JPA 2.0 is part of Java EE 6.0 standards, but can be used in both Java SE and Java EE applications. This is a new Java persistence standard based on object-relational mapping and utilizing object-oriented features of Java. It is expected to gradually replace JDBC and proprietary object-relational mapping frameworks/libraries for most Java applications with database access. JPA makes software development fun and leads to improved productivity.

The book introduces concepts, techniques, and application trade-offs in a manner that is easy to understand and provides many code examples for an online book ordering system. The Java source code and database DDL are freely downloadable from the author%u2019s web site. The book contains instructions on how to run the code examples so that the reader can easily learn the concepts through running the code. The book is suitable for Java developers and architects who want to learn this new and standard technology, but have no prior knowledge of JPA.

This book is also aimed at experienced JPA developers who may use this book as a reference, by providing complete coverage of JPA 2.0. It has a special chapter on JPA design patterns and performance tuning. This book will prove to be valuable for novice and experienced JPA developers. ... Read more

Customer Reviews (8)

Great Book About JPA
This is a great book for learning JPA.The book starts with strait forward CRUD examples that can be coded up in a short time to get the reader moving right away.The examples use top notch technology (Eclipse, JBoss 5.x, EJB 3.x, and JSF).

I have previously purchased Hibernate books that start a reader out with a very complex situation and then proceed to explain how Hibernate can perform all of its complex capabilities - I quickly lost interest in those books.

The author's web site ([...]) shows that he is a very accomplished computer scientist.I look forward to future books from this author.

Decent, but not as good as it could have been
I really have mixed feelings about this book: the author is definitely well versed on the subject, but his english and presentation style leave much to be desired. A little more attention ( and editing ) would have done much to make this book more readable and easier to go through. The author also shares the typical defect of researchers and scientist: not being able to discern the hard from the easy and the important from the futile, presenting all material with the same level of detail and a general dullness in the presentation style. This book does have some strong point though: it touches all aspects of JPA programming in decent detail, does not shy away from what other book consider "advanced material beyond the scope of this book" and tried to do that in a pragmatic way. Example code need a lot of work anyhow, it's given basically as a bunch of poorly organized java source files and will require quite some sweat to be put to work. Nothing that can't be done, but if I spend money on a book I expect the source code to be better organized and ready to run, at a minimum with an ant script, if it's a book on java technology. The part of concurrency and locking if far from clear and detailed enough, but unfortunately that is an evil common to all JPA books I have seen. To sum it up, this is a decent book if you have the patience to go through the example code and organize it with ant scripts or and ide to make it run on you application server of choice, but it won't be a good choice for a real beginner in JPA and J2EE technology, and a generally dull and boring read for everyone.
I do have the disturbing feeling that many of the 5 star reviewers of this text are actually friends/colleagues of the author...
This is far from a 5 star book , it's a decent text which could have been great with a little more effort and attention to the example code and presentation style...
If you have time, budget or space only for a single book on JPA I think that the best one is still
Pro JPA 2: Mastering the Java™ Persistence API (Expert's Voice in Java Technology)
though even this one is far, very far from perfect..

A must-have for all Java developers
I have to admit that I like this book and its presentation style. It starts with an introductory chapter with an example showing many good features of JPA. It has detailed steps on how to run the example in DOS command line and in the Eclipse IDE as standalone Java SE projects, and then in JBoss using an EJB and JSF sample in a Java EE environment. By running this example, I feel that JPA is very easy to use, as promised by the author.



Then the book covers all the concepts through a more complete set of examples with a data model. Frequently used features are covered first and followed by more advanced features. The book provides a lot of useful analysis and insights on different trade-offs of many important features. The chapter on design patterns and performance tuning is very good and easy to understand.



I strongly recommend this book to all Java developers who want to embrace the new Java persistence standard. It is a pleasure to read this book and learn everything that I need to know about JPA 2.0.

Excellent pragmatic guide for JPA
Daoqi Yang's new book is an excellent pragmatic guide for the Java Enterprise programmer wishing to learn JPA.The book tackles the complexities of persistence technologies by quickly getting you started and then taking deep dives into the many features offered by JPA.Many different scenarios for using JPA are explored including stand alone, web/EJB containers and the application of different design patterns.The book offers a rich set of real world examples demonstrating JPA's ability to target multiple database vendor's from a single code base.The examples include the use of multiple persistence providers (Hibernate and EclipseLink) and a special section on performance tuning.The examples integrate well with the Eclipse IDE and I was able to easily port the example code over to an Oracle DB implementation.This book is sure to be well received by the working programmer who quickly needs learn JPA. Kudos to Daoqi !

Good introduction to JPA, Great examples.
Though the number of books that touch the topic of Java persistence is by no mean a small one, this book is one of the first few dedicated to JPA 2.0. As we all know, JPA has been adopted as the only OR mapping standard for Java persistence, which is probably why readers like you and me pick up this book in the first place. However, books on standard (whose specification can be a book by itself, especially in Java land these days) are not easy to write. I have seen too many such books ended up as a mere reiteration of the API specification or the reference implementation. This book is not one of them. The author has done a great job with his organization of the topics. The chapters flow in a natural way and it has an emphasis on the practice side than the theory side. This will play well with new comers to the Java persistence field. What I like most of this book are the concrete examples that the author uses to explain the concepts and demonstrate certain techniques. The examples are to the point and easy to understand yet they are by no mean trivial. The examples also relay well with someone like me who is seasonal in the field but not totally sold on OR mapping (plain old SQL and technologies like iBATIS hold the same weight as OR mapping in my heart). The "Design Patterns and Performance" chapter is another bright spot of the book. IMHO, this chapter alone would worth the money. Many techniques are explained in great details, again with solid use case scenarios and examples. This chapter is definitely something you don't want to miss.

I wish the author had formally listed the API (cheat sheet format not the full blown document) centrally as an appendix. With all those sophisticated IDE, this is a fairly minor issue though. Overall "Java Persistence with JPA" is a concise practical guide to learn and use JPA. Highly recommended. ... Read more

Product Description

Product Description
Agile Java is a valuable tutorial and reference. It introduces the Java languagewith no assumptions about a developer's background in Java, object-orienteddevelopment, or TDD. The book will also retain significant value as acookbook that readers will turn to time and again to learn how to approachTDD with respect to various language features.Teh author stresses the importance of TDD by showing coded tests for everyJava feature taught. A programmer learning with this book will understand howto translate oral requirements into tests, and tests into working code. Readersalso learn how TDD impacts the design of the system, and vice versa. In short,anyone who wants to understand what it takes to build a professional, robustsoftware system using Java will want this book. Agile Java will be ideally timedto coincide with Sun's forthcoming release of Java 5 (J2SE 1.5). ... Read more

Customer Reviews (15)

Agile Java is great
This book is well worth the read. It is a great concept to learn to test as you create your code. This is something that I was not taught when I started learning to code in Java. I wish that all classes taught to test as you go when learning to code.

Best book for learning Java!
This is an excellent book on Java. I have read several books on Java in the past years, but none of them teaches Java concepts like this one. I wish I had got this book 7 years back when I started developing in Java. I wish there were more recent books by this author.

Great for testing your skills as a developer
How do you get good at something when making a mistake has a decent chance of getting you fired?

It's hypocritical of companies who want their developers to be open to learning new things but don't provide a safe environment for them to learn and make mistakes. This book actually encourages the developer to create tests to fail and then provides suggestions on how to make them succeed but it does so much more.

Unit testing used to be primitive as well as frustrating but not anymore. With Agile Java, JUnit comes alive in the hands of the developer. It's a joy to test and refactor code that looks good and is good.

Bought for my son, read it cover to cover!!
I had originally bought this book for son who was going to spend the summer working for my development team writing unit test for our database POJOs.I was so impressed way in which concepts were incrementally introduced I read the book cover to cover.It is now the only book I recommend to beginners and I introduce it as a 'must' read for all my new hires.

Don't Let the Title Fool You
This is my new favorite-book-to-give-to-anyone-who-is-learning-or-using-Java.

The title is misleading in that this book is about much more than just the Agile Programming stuff.While it does a great job talking about Agile techniques and always starts by creating a unit test, the book really is about all aspects of Java (specifically Java 5) programming.Anyone who takes the time to work through the examples will become a much better Java programmer.

OO patterns, collections, type safety and more are covered and explained in the context of a rich, in-depth example.And because the author has you construct a high-quality test suite around the example, you are free to experiment with different ways to implement each new feature - thus proving to yourself the benefits of Agile design.

Just like it says in one of the quotes on the cover, this book is now required reading for the Java programmers at our company.

... Read more

Product Description
In this second edition, you will find thoroughly updated coverage of the Java(tm) 2 platform and new or expanded coverage of:

* Memory model * Cancellation * Portable parallel programming * Utility classes for concurrency control

The Java platform provides a broad and powerful set of APIs, tools, and technologies. One of its most powerful capabilities is the built-in support for threads. This makes concurrent programming an attractive yet challenging option for programmers using the Java programming language.

This book shows readers how to use the Java platform's threading model more precisely by helping them to understand the patterns and tradeoffs associated with concurrent programming.

You will learn how to initiate, control, and coordinate concurrent activities using the class java.lang.Thread, the keywords synchronized and volatile, and the methods wait, notify, and notifyAll. In addition, you will find detailed coverage of all aspects of concurrent programming, including such topics as confinement and synchronization, deadlocks and conflicts, state-dependent action control, asynchronous message passing and control flow, coordinated interaction, and structuring web-based and computational services.

The book targets intermediate to advanced programmers interested in mastering the complexities of concurrent programming. Taking a design pattern approach, the book offers standard design techniques for creating and implementing components that solve common concurrent programming challenges. The numerous code examples throughout help clarify the subtleties of the concurrent programming concepts discussed.Amazon.com Review
Concurrent Programming in Java, 2nd Edition surveys a wide field of research in parallelism and concurrency and shows how to do more with multithreading in Java with dozens of patterns and design tips. Written for the advanced Java developer, this book offers a comprehensive tour of leading-edge thinking about parallel coding processes.

Within the dozens of techniques and tips offered here, this book accomplishes at least two goals. First, it shows how concurrency is implemented by default within Java, with material on how built-in features (like the synchronized keyword and its memory model) can be expected to perform when dealing with multiple threads. Naturally, Java threads themselves are also covered, including priorities, scheduling, and the like.

Much of this book looks at ways to improve performance of concurrent code beyond the simple default strategies. After defining criteria for measuring concurrent code (such as safety and "liveness," a measure of running live threads effectively), the book presents dozens of techniques for letting threads work together safely. For the working Java programmer, coverage of patterns that have been implemented in the downloadable java.concurrency package will be the most immediately useful. (Within this nearly encyclopedic survey, short code snippets are used for every pattern and concept.)

Though theoretical at times, this book offers plenty of ideas and sample code to get you started thinking of ways to improve multithreaded code.

Impressively comprehensive, Concurrent Programming in Java offers a veritable bible of techniques for doing two things at once with threads in Java. It's a worthwhile guide to the state-of-the-art strategies for improving the performance of your Java threads. --Richard Dragan

Topics covered: Threads and concurrency in Java, design considerations (safety, liveness, and performance), Before/After Patterns, layering, adapters, immutability and synchronization, deadlock, resource ordering, the Java Memory Model and concurrency, using the java.concurrency package, confinement, refactoring for concurrency, mutexes, read-write locks, recovering from failure, notifications, semaphores, latches, exchanges, transactions, one-way messages, worker threads, polling and event-driven I/O, parallelism techniques (fork/join, computation trees, and barriers), Communicating Sequential Processes (CSP). ... Read more

Customer Reviews (48)

Very Good
I don't know about this book but having him as a teacher is pretty weird. I'm assuming his book style is the same as teaching, and that is pretty good, he helps you and knows everything about java seeing how he made some of java. Very bright.

Too Theoretical
The book contains a lot of concurrent and parallel programming theories, but the organization of the contents is not well formed, such that the reading and understanding of the book are hard. The examples giving in the book are not very helpful either.

Overall, the book seems to target for academic researchers rather than developers. Highly recommend "Java Concurrency In Practice" which is much more practical and easier understood by Brian Goetz

5 for knowledge; 0 for the writing -> 2.5-> 2
Sure he knows his stuff but doesn't have a clue on how to write. This is appallingly poorly written. It is one of the most ridiculously disorganized collections of academic 'verbage' (verbiage subsumes garbage) I have ever read. It's almost useless as a reference: its very non-linear (say non-deterministic almost) in concept elucidation (perhaps he's taken the notion of multithreading too much to heart and tried multi-threaded writing???). It's useless as a book to learn from- since learning by example is not just a way to learn, but the only way to learn (Einstein) and this book largely disavows examples.

What it needs is another edition with a ghost writer. Seriously it's not good. Try Paul Hyde for a good intro to threads.

While those at guru-ish level may love this book, those of us for whom threads represent a means to an end, not an end in and of themselves, would probably want to throw this book in frustration of the author's inability to structure a coherent sentence with a clear point. This meanders on like great uncle herb's war stories and is equally will sapping.

Avoid if you can or check it out when you reach guru-ness. It's a good cure for insomnia though.

If you want to program concurency in Java you need this book
This is a kind of book you'll need to start developing concurrent systems in Java. It shows details of what should be done to safely handle patterns for concurrent programs.
I beleive this book is a must for every developer who want to start learning concurrency design priciples for Java.

Great Threaded Programming Information for More than Java
This is the best book I have ever read on threading, and certainly applies well to other languages naturally (especially languages with a modern and mature thread library like Mono/.NET). Unlike other reviewers here, I encourage so-called "beginners" to read this book. He has plenty of examples so you will not get lost, and this *is* the right way to do things, so start with this one. ... Read more

Product Description

Using the latest features of Java 5, this unique object-oriented presentation introduces readers to data structures via thirty, manageable chapters.

KEY FeaturesTOPICS:

Introduces each ADT in its own chapter, including examples or applications. Provides  

aA variety of exercises and projects, plus additional self-assessment questions throughout. the text  

Includes generic data types as well as enumerations, for-each loops, the interface Iterable, the class Scanner, assert statements, and autoboxing and unboxing.

Identifies important Java code as a Listing. Provides

NNotes and Pprogramming Ttips in each chapter.For programmers and software engineers interested in learning more about data structures and abstractions.

Customer Reviews (9)

Good condition!

The condition was better than I expected.
It was almost like brand new book!

Great Product!
The book I ordered came just as I ordered.The shipping time was very quick.

Terrible
I am in an advance program course at my university and this book was required.It is a terrible book and does not describe ideas or the process every well.The first few books I used for earlier classes were better.As I said though, it was required and cheaper here new then used at my book store.

Poorly Organized and Not Enough Depth
Easily the worst thing about this book is the organization. Basic data structures such as stacks and queues are presented near the end of the book, and heaps aren't explained until after priority queues! There is no logic in this book's organization.

The explanations are weak and incomplete. The author can ramble on about some things without really explaining anything. Also, the book barely scratches the surface of the explanations it attempts to give.

A positive, though, is that the diagrams and pictures are helpful.

Overall, it is useful for last minute review and not much else.

Easily the worst $100 investment I ever made
If you are planning on learning Data Structures and Algorithms, this is definitely the book to avoid!

Concepts are so horribly explained that I've ended up creating an aversion towards them. This book makes easy topics appear to be the most difficult things that you can ever learn.

Mr Carrano may be a top notch Computer Science person, but writing books is definitely not his forte. That is my opinion, after having to deal with this book for about two semesters.

I love books and have read good amount of books on computer science. I usually hate to sell them or give them away , but this book is definitely going to be off my shelf as soon as I am done with my course. In the future, I would for sure avoid any course that requires reading this book.
No other book bothered (read it as irritated) me as this one did. ... Read more

Product Description

In all, Elliotte makes a good case thatJava streams are a flexible and powerful part of the language, andcertainly not a limitation. --Richard Dragan ... Read more

Customer Reviews (30)

simple as it can be
Just read few pages and you will realize this is a well written book. I enjoyed it and learned a lot. Java NIO is good book, but this is much better and simpler.

Great book
This is a great book, honestly I have using a lot of its know-how on my job.
My advise is that all reader should know the decorator pattern to understand better the class structure, and I hope in the next version add some information about it.

Java I/O
Thorough guide to the java.(n)io API. Less useful as a cookbook as the organization of the book follows the API rather than focusing on specific tasks (e.g. how to best copy a file). Could have done without some of the cool chapters such as the one on J2ME (better treated in other books), or the one that describes hooking up a temperature sensor via USB, or a GPS via Bluetooth (publish these projects in a blog). Could also cut the rants about how outdated command line applications are, and I don't think the Swing-based file browser application that's built up throughout the book adds much. On the other hand I'd rather have more on performance considerations and error handling strategies!

Far better resources available
It covers a lot of topics but I did find it particularly helpful in any way. The idea of gathering all the information about I/O into one book to use as a single resource is nice, but this book doesn't do a good job. Not that much help in explaining things and no help at all as far as practical examples went. You will learn much more from general Java books and Google searches.

HAVE A CUP OF JAVA I/O!!
Howell do you know I/O? If you don't know it very well, then this book is for you. Author Elliote Rusty Harold, has done an outstanding job of writing a 2ndedition of a book that shows you the I/O tricks and techniques used by gurus and wizards of the Java world.

Harold, begins with an exploration of I/O in Java. Then, the author discusses the two most common targets of I/O, the filesystem and the network. Next, he discusses filter streams, which are Java's mechanism for processing data as you read or write rather than doing it after the fact. The author also discusses a completely new I/O model based on channels and buffers instead of streams. He continues by discussing operations on files themselves as distinct from the contents of those files. Then, the author explores how text is represented in Java and how it can be manipulated through special text streams called readers and writers. Finally, he shows you how to communicate with different kinds of peripherals and small devices that don't have traditional filesystems or network connections..

This most excellent book assumes you have a basic familiarity with Java. More importantly, this book is not a language tutorial, and the emphasis will always be on the I/O-specific features. ... Read more

Product Description
The award-winning team of Abraham Silberschatz, Peter Galvin, and Greg Gagne gets system administrators right up to speed on all the key concepts of computer operating systems. This new edition gives them a thorough theoretical foundation that they can apply to a wide variety of systems as they progress to the next level of their computer work. It presents several new Java example programs including features in Java 7. Increased coverage is offered on user perspective, OS design, security, and distributed programming. New exercises are also provided to reinforce the concepts and enable system administrators to design with confidence. ... Read more

Customer Reviews (5)

Good Book.
A little hard to read if you have no previous knowledge. A lot of information/content to learn but that was because i took it as a summer class. Read and understand the book properly as I did and i got rewarded with an A.

A sound introductory text
This provides a solid introduction to the basics of operating system (OS) internals. After an introductory section, this covers the major subsystems in an orderly progression: processes, memory, storage, protection, distributed systems, and special purpose systems. Although I might quibble with some of the ordering, (e.g., virtual memory vis a vis process management), this gives a firm foundation for anyone teaching introductory OS internals. As an aside, instructors should also be aware of the additional support they'll find at the book's web site.

I have no real objections to this book, but find that some of its emphasis won't suit all readers. For example, 99% of all processors don't run Windows or Linux. Instead, they run your DVD player, car air bags, microwave, digital watch, and just about everything else with a power cord or battery. Engineering students headed for embedded system development will need supplementary material. Also, like every other undergrad text I know, this underplays the critical importance of standards in everything from APIs and file system structures to network protocols and safe coding guideline.

The Java emphasis definitely adds to this book's breadth. For years now, OS examples have featured the Unix API or, perhaps grudgingly, examples from Windows. They're not the only games in town, though. Java's API differs in many ways from the Winux (Lindows?) models, especially in areas having to do with threading and safe execution. When you add in Java's wide popularity and its role as conceptual predecessor to .NET and C#, that makes it a logical candidate for study. Compared to the non-Java version of this title, the additions are minor but well-chosen.

I've taught from the non-Java version of this book and from Tanenbaum and, to tell the truth, have no strong preference between the two. They present comparable material at roughly the same level, both offer good case studies, and both offer on-line support to students and instructors. Each outweighs the other on specific topics but, on the whole, that seems to balance out.

-- wiredweird

Well written!
This is a well written book compared to other books about Java. It gives logical explanations and is easy to understand. Now I understand why my Prof. said they've used this book since he was in school studying Java. Its a great source for the novice, intermediate and advanced student. Great Book to keep if you ever need to refer to it in the future!

thanks again..
Great product, great price and great service " too good to be true", but it is.

Great Book
Currently I am a CS student in my senior year. I am taking my final for the class tomorrow and the book has done an excellent job of taking some complex topics and translating them into legible english. That being said, I will just explain some of the flaws.

The first problem is the pictures or figures in book which are trying to give a visualization of the topics being explained. There a surprising amount of figures in the book that are completely horrid. I mean that they just either further add confusion or are just completely useless. Very shocking because the author/authors are very talented with words, yet seem to very bad when it comes to creating visualizations. There are a few with flat out errors as well.

The second problem is that the questions in the back of each chapter are acatastrophe. The questions are typically just very vague or just aren't very good questions. For instance, there is a question that is similar this

"Does virtual memory need to be supported by the operating system of a handheld system?"

The answer in the teachers guide is apparently "yes". But clearly, this answer is truly "no". Handheld device operating systems don't NEED to support virtual memory. There are plenty of handheld devices that don't, and certainly you don't ever NEED to support alot of things. The question really means to ask "Is it beneficial for a handheld device to support virtual memory?" The obvious answer that is "of course". I got this question wrong on my homework, but myself and a few others talked with the teacher and he quickly agreed that we were right. There are just far too many questions like this that are poorly written.

Regardless of these two problems, the book is really well done. ... Read more

Product Description
Working as an effective professional Java developer requires you to know Java APIs, tools, and techniques to solve a wide variety of Java problems. Building upon Ivor Horton's Beginning Java 2, this resource shows you how to use the core features of the latest JDK as well as powerful open source tools such as Ant, JUnit, and Hibernate. It will arm you with a well-rounded understanding of the professional Java development landscape.

The expert author team begins by uncovering the sophisticated Java language features, the methodology for developing solutions, and steps for exploiting patterns. They then provide you with a collection of real-world examples that will become an essential part of your developer's toolkit. With this approach, you'll gain the skills to build advanced solutions by utilizing the more complex and nuanced parts of Java JDK 6.

What you will learn from this book

• How to use tools to make your work easier and more productive
• Methods to develop effective user interfaces with Java Foundation Classes (JFC)
• Steps to build web applications using the Model 1 and Model 2 architectures
• Ways to interact with the databases and XML using JDBC and JAXB
• Techniques for developing enterprise applications using EJB 3.0 and web services
• How to package and deploy Java applications

Who this book is for

This book is for Java developers who are looking for an all-purpose resource, are ready for more advanced Java solutions and language features, and need assistance when tackling new Java problems that may be outside their technological experience.

Wrox Professional guides are planned and written by working programmers to meet the real-world needs of programmers, developers, and IT professionals. Focused and relevant, they address the issues technology professionals face every day. They provide examples, practical solutions, and expert education in new technologies, all designed to help programmers do a better job. ... Read more

Customer Reviews (3)

Comprehensive, nice to have book
Courtesy of Blazej Ksycki from Szczecin JUG:

Learning Java from scratch isn't very difficult, but if you want to know all the good practices it can take quite a big amount of time and effort. The book Professional Java JDK 6 Edition" is here to help us out.
This book is very interesting and relates to quite a few issues. The first thing I found interesting were the differences between JDK 1.5 and JDK 1.6. Another subject is the design of web applications in two architecture models. This book also describes the basics of Enterprise Java Beans. Furthermore the reader will enter the world of many different, but very useful tools such as: Maven, TestNG or JMeter. Another very good chapter is about integrating Java and C++ using JNI (Java Native Interface). Everybody will find something interesting in this book. The number of problems this book is about is really impressive. But there is one thing missing - the J2ME technology.
All the texts in the book are described very clearly and they have very good examples. These examples are very helpful and allow you understand the meaning of the book quicker. However since the book is about many aspects of Java an doesn't concentrate only on one subject, some of the issues were described a bit to briefly. Sometimes when you read this book you get a feeling that there is something that this chapter lacks. When this happens unfortunately you have to find another book which is more specialized than this book.
At the end of the review you ask yourself one question - for who was this book written? The answer is frankly quite simple. For those people, who have some experience in Java and know the basic and now would like to continue their studies on Java, but don't know where to start their journey. Another group of readers that will the book useful are professional that would like to have some kind of quick reference guide. The book is really great and worth having but as for me it's a nice-to-have, but not a must-have. Still we have to remember that though this book is about different aspects of Java it won't replace a collection of more specialized books. But if had to give this book a grade it would be a B+, because of the drawbacks I mentioned above. However I think everyone should read this book - it's worth it!

Can't tell who this book is really for
Professional Java attempts to do something I don't think any one book can do well, which is to say something useful on just about every topic. This book's sections include: important additions/changes to JDK 5; a whirlwind tour of project methodologies; design patterns; build tools; persistence tools; UIs; web applications; JNI; EJB 3; SOA; security; and packaging and deployment. The book wants to be a "one-stop shop," and that's fine. After reading through most of the sections and skimming some, however, I'm not sure what the profile of the target shopper might be.

The topic coverage varies wildly from section to section, in the writing style (and quality) and in the effectiveness of sample code to illustrates a point. Too often the descriptions are both verbose and phrased in the passive voice. Some code samples seem like proof-of-concept sketches of a feature or library facility, rather than a compelling example of its use. Still other samples seem full of boilerplate code that speeds up the page-turning but isn't illuminating. And sometimes the text changes its diction strangely; the style changes from a general description to a "follow-along" activity without warning. Some sentences sound as if the author left them in as a reminder to complete a task.

The result is a thick book that, for me, is sometimes tedious or exhausting to read. I think it would have been helpful to give author credit by chapter, if only to know the presentation might change significantly.Also, a concerted effort at paring things down, and keeping the diction clear and active, would help make it more readable and something worth referencing.

As mentioned, the topic coverage is quite broad. This book might come in handy to someone who just needs many topics in one book. So long as you don't need your one reference also for getting started, this book could be a useful collection.

Good book for reference if you have done Java before
The book provide really helpful for you if you are trying to know more about Java after you have done it. It provides a lot of examples for doing one thing in different ways. ... Read more