Customer Reviews (3)

Very good bridge from theory to practical...
Target Audience
Web developers who are looking for real-life examples of the use of servlets and JSP.

Contents
This is a companion-type book that goes beyond strictly reference material to the use of different servlet and JSP features, along with working examples of code to illustrate the concepts.

The book is divided multiple chapters that each cover a different technique or function:

Writing Servlets and JSPs; Deploying Servlets and JSPs; Naming Your Servlets; Using Apache Ant; Altering the Format of JSPs; Dynamically Including Content In Servlets and JSPs; Handling Web Form Data in Servlets and JSPs; Uploading Files; Handling Exceptions in Web Applications; Reading And Setting Cookies; Session Tracking; Integrating JavaScript with Servlets And JSPs; Sending Non-HTML Content; Logging Messages from Servlets and JSPs; Authenticating Clients; Binding, Accessing, and Removing Attributes in Web Applications; Embedding Multimedia in JSPs; Working With The Client Request; Filtering Request and Responses; Managing Email In Servlets and JSPs; Accessing Databases; Using Custom Tag Libraries; Using The JSTL; Internationalization; Using JNDI and Enterprise JavaBeans; Harvesting Web Information; Using the Google and Amazon Web APIs

Review
I really like the O'Reilly Cookbook series. I read a lot as part of my ongoing study, and often it's easy to understand conceptually what is going on. But making the jump to practical solutions can be difficult at times. The Cookbook series gets plenty of use on my bookshelf as I do my day to day coding. And when it comes to servlet and JSP coding as I continue to learn more about Websphere Application Server, this book will surely become dog-eared like the rest of them. Bruce Perry has done a great job.

As with most Cookbook titles, each chapter in the Servlet And JSP Cookbook is made up of a number of Problem/Solution/Discussion groupings. This format proposes a coding problem, states the solution to solve it, and then devotes the necessary space to discuss the solution both with text and code. By using this format, you can think through a working solution and determine how to apply that technique to your own problem. Perry covers a wide range of problems that will help both the beginner and the experienced coder. For beginners, the solutions for setting cookies with servlets and JSPs may be just what you need to get started. Experienced people will find the internationalization and JNDI/Enterprise JavaBeans solutions useful. I appreciate the fact that coders of all experience levels can get something out of this book.

The only caveat I have on this book is that it is very focused on the Tomcat and WebLogic web application servers. If that's your platform of choice, you're going to get everything this book has to offer. For me, I'm partial to the WebSphere platform. While I will benefit from a lot of this book, there are chapters that will have no appeal to me, such as using the Ant package. I will also need to pay attention to the coding examples to make sure that the techniques are coded correctly for my platform of choice. Even with that warning, I would still highly recommend this book to all coders working in this area.

Conclusion
This is definitely a title that will be useful to you as you learn more about servlet and JSP programming. It will give you the ideas you need to solve real business problems you'll encounter as a developer.

Must-have book for any Servlet/JSP developer
In the great tradition of cookbooks, O'Reilly has published the Java Servlet and JSP Cookbook. This book, written by Bruce W. Perry is a must-own book for anyone working with web applications in the Java space. I've been a Java developer for almost 8 years now and have been working with Servlets since early 1999 and I've learned quite a few things from this book.

The Java Servlet & JSP Cookbook provides more than 200 'recipes' or fully working and documented code snippets that you can directly cut-and-paste in your application. The book starts off with a quick intro to writing servlets and JSP pages. I was very impressed that the first JSP page that you write uses JSTL and is not loaded up with scriptlet code. I am just sick and tired of arguing with people with scriptlets are bad and it's nice to see a book that starts off with JSTL. Kudos Bruce.

Once the intro is complete, you move onto writing deployment descriptors, deployment along with a nice little chapter on Ant. One of the most common question after people deploy JSP based application is the idea of precompiling JSPs for performance reasons. The fifth chapter does a great job of suggesting several methods of precompiling JSPs. I should also mention that the book includes how-to guides for Tomcat and WebLogic, which covers a pretty large landscape of web containers. WebSphere, Resin, Jetty are not directly covered.

The book then moves on and covers topics such as handling Form data via POST/GET, uploading files, cookies, session tracking and URL rewriting. There is also a chapter on JavaScript and how they use JavaScript with servlets. I don't really understand the point of this chapter as most users just need a few cut-n-paste JavaScript for client-side FORM validation. There is also a chapter on streaming non-HTML content such as PDF, audio/video files and others to the browser.

I also liked the chapter of logging in Servlets and JSPs. This chapter includes a nice introduction to Log4j and a nice tag library that uses Log4j under the cover. My favorite chapter in this book was the chapter dealing with authentication. The chapter starts off by talking setting users in Tomcat and then moves into setting up BASIC authentication. The next recipe talks about using Form-based authentication. The chapter is rounded off with a good treatment of the Java Authentication and Authorization service (JAAS). In this chapter, you create your own custom LoginModule and then use JAAS in a servlet and JSP.

There is also a chapter about embedding multimedia content inside JSPs. This is not something I'm really interested in and I just glossed over this chapter. The same goes for the next chapter on manipulation of the HttpRequest. The next chapter does a great job of exploring Servlet Filters, which is a great feature introduced in the Servlet 2.3 specification that hasn't really caught on. Filters are great and the book includes some great examples of how best to use them.

The next section includes chapters on sending, accessing email from servlets along with database access. Most complex application usually will implement some backend service to access database and separate the business logic from the data and the data from the UI, but the included recipes will help get you up and running for simple application.

I really liked the section on custom tag libraries and JSTL. Tag Libraries are a great way to avoid scriptlet code in JSPs. The chapter on JSTL is also fairly comprehensive and includes code snippets for the core, XML, format, and SQL tags. There is also a great section on the Expression Language (EL) which has been migrated from JSTL 1.0 to the JSP 2.0 specification.

I could go on about this book but I won't bore you any longer, assuming you are still reading. I highly recommend this book for anyone doing any type of Web development using Servlet and JSPs. I mentioned this earlier, but I've been writing Servlets and JSPs for the past 5 years and I've learned quite a few things from this book. Add this book to your library today. The code for this book is available on O'Reilly dot com

Over 130 Hacks!
The 'cookbook' in the title means that Perry emphasises what he considers to be many common tasks needed to be done by Java Servlets and JSPs, in a J2EE context. Similar in spirit to OReilly's other books like 'eBay Hacks' and 'google Hacks'. In fact, in the 26 chapters of Perry's book, there are on average over 5 tasks in each that he explains, which are akin to the hacks of the other books. Except here, he gives you over 130 hacks.

He assumes you know the basics of the subject. Certainly, the book does not claim to be a comprehensive listing of the subject's features. But if you satisfy this requirement, you can dive straight into any section of any chapter. Don't have to read this book linearly.

However, if you aren't using Tomcat or BEA WebLogic as containers, then the relevance of the book may, frankly, be more limited. Different containers have slightly different functionalities, and the examples he gives are very specific to those 2 containers. If you are in fact using another, perhaps you can use this book to provide design patterns and inspiration, but not actual code. ... Read more

Subjects:  1. Computer Bks - Languages / Programming   2. Computer Books: Languages   3. Computers   4. Java (Computer program language)   5. Microcomputer Application Software   6. Programming - General   7. Programming Languages - Java   8. Servlets   9. Java & variants   

Customer Reviews (19)

Java 2 For Dummies - Awesome Book
Just a quick note to say what a great and informative book the author has put together. The book has been a great kick start into Java programming and explains everything in simple terms so beginners like me can keep up.
Throughly recommended.

no pain, no gain
After reading some of the other reviews of this book, I was quite daunted at the prospect of venturing past chapter 6. Yes, it does get more complicated, but I think it has to. Chapters 1 - 6 are a great introduction to understanding the grammar of the Java language but the author purposely keeps it simple by not developing the Object Oriented concept until the reader has got settled in. He does everything in an old fashioned procedural manner inside the Main method so that the reader learns some basic ideas such as do loops and if statements. If like me you have previous knowledge of a procedural language, chapters 1-6 will definitely seem a breeze compared to the following chapters.
I do agree though that the book could explain some things better. I didn't think the explanation of the importance of accessor methods was very precise, for example. It wasn't until I'd read on in the book that I really understood how they could be used. I found the introduction of getters and setters into all the example programs unnecessary, just serving to confuse the reader and obscure the concepts being demonstrated.
I too had to re-read bits over and over to understand them but I don't consider this a criticism of the book. From my previous aborted efforts to learn Java I already knew what a difficult language it is for a complete newbie to pick up. Having read this book (in two weeks) I now know enough to get me trying out my own code and reading some more advanced books.

As a read, it's quite entertaining. There are jokes along the way and the author is chatty rather than overly dry and technical. I'll definitely take a look at the other Barry Bund Java book in the Dummies series.

Ok for the absolute beginer
It covers all basic aspects, but that's all. It's not a bad book as long as you know what you're looking for. People knowing the basics should avoid it and search for something more detailed ... Read more

Subjects:  1. Computer Bks - Languages / Programming   2. Computer Books: General   3. Computer Networks   4. Computer Programming Languages   5. Computers   6. Java (Computer language)   7. Java (Computer program languag   8. Java (Computer program language)   9. Programming Languages - Java   10. Computers / Programming Languages / Java   11. Java & variants   

Customer Reviews (9)

An Eclipse Textbook
This book is a very good explanation of what Eclipse is and does. It does assume the reader is somewhat familiar with IDEs and quite familiar with Java. It describes the reasons for Eclipse coming about and the way it is different from other IDEs. It gives some description of how to use it to start a project and how to set some preferences and properties. It does not give all the various details about every preference and property but does give some idea about how to find out what they are and do.
The examples it uses are on some very basic and useful features that Eclipse has integrated well. There is an overview on the Junit plugin and how to use it to do unit testing. Eclipse was designed with the focus on Agile or 'Extreme' programming style. The examples are decribed in the language of that paradigm. The unusual part of the book's style is how it presents an example of a problem and a solution, and then it may state that this isn't the best way to solve this problem and presents an alternative approach that is more practical, and so on. In this style, the book is more of a textbook and less of a reference. You need to read the whole book and proceed with examples as if it were a series of classroom lectures rather than as a way to quickly find out how to do something. Many of the example programs that can be downloaded from the website don't actually work but serve to demonstrate some feature of Eclipse.
One frustration, which I find in many such books, is that the example problems are uninteresting and trite. Many such books offer some baloney programs such as a car/vehicle/machine issue, which can be rather boring and pointless. This book offers a similarly boring problem of a star finder. I would love to see a book whose example yields an application that I might actually care to use.
The book also describes how to use the Ant plugin, which is useful for someone building a large application with many setting options. Eclipse provides a way to tie all the various Ant features into a neat package. Since I had never used Ant or Junit these discussions were very useful but for someone with experience with them may be less enlightening.
The book also covers briefly how to use Eclipse's source control features and how to use a Tomcat server within Eclipse. These are features that probably everyone needs to use and the book discusses how to set them up to work with and be controlled from within Eclipse. These do require some reader ability and familiarity with the tools. You may need to do some outside reading if you do not have a CVS server or have not installed Tomcat before.
The last third of the book involves using Eclipse to create your own plugin. The example uses a common application introduced earlier in the book, log4j, which is an open source logger tool. The early reference merely used log4j to implement logging in an example. The plugin development section instructs you to build a set of plugins to wrap log4j as an Eclipse plugin so that the control of the logger is done entirely within Eclipse. This section also describes how Eclipse uses plugins to extend other plugins and how the usefulness of the tool grows as new plugins get introduced. It is a rather complicated bit and may not be of great interest to every programmer but does give an idea of how the development of Eclipse is proceeding.
The appendixes give some reference material to menus and plugin extension points, i.e. classes that tie plugins together. There are also brief appendixes on installing a CVS server, and using SWT and JFace. In my view they should be considered only introductions and would need outside reading to become useful.

Great Book in Less Than 400 Pages
Now that you've downloaded Eclipse and realized it is a big tool, if you are like me you thought you'd go looking for some books on the subject. I'd suggest stopping right here.

One pundant on usenet suggested that Eclipse has a learning curve like Emacs and that this is a good thing, because of boths power and flexibility. While I think Eclipse is more usable and seems to be easier to extend than that old war horse EMACS, the scope of what IS in Eclipse can be daunting. More importantly it is useful to get your head around the way the GUI is organized, so you can effecticvely use the tool. At less than 400 pages, you might think this book would not cover the ground, but this is not the case. This book specifically says it is not intended as a hardcopy version of the on-line help. The goal of the book is to get you started and you move you into some of the more interesting aspects of the IDE. I found the book to have succeeded well at it goal.

Continuing a recent trend from Manning this seems to be another well edited book that is kept managable in size, yet still containing a large amount of information. The book doesn't waste a lot of time getting started, by chapter three you are already learning about using JUnit, Log4J and the debugger. In later chapters, the authors have you working with Ant and CVS after working up a nice little example that that they even spend some time refactoring using the built in features of Eclipse. Integrated tool use would probably be sufficient, but they proceed to jump off into web development leveraging one of the hundreds of plugins available for Eclipse and show you how to debug directly in Eclipse using tomcat. In just over 200 pages a lot of very useful material has been covered.

Part 2 of the book goes on to show you how to write your own plugins which I haven't done yet, so can't comment. For those who just can't stand a well written narrative and instructional style, there is even a thin 16 page chapter of mostly tables for all the Java development menu options and another appendix listing all plug-in extension points. For those who are wondering if they can replace the IDEs they have which help with their Swing layout and development, you may be interested in noting that the SWT is regulated to its own appendix keeping with the emphasis of Java on the server. Since Eclipse is an open API and open source there are 300+ of plugins available for it. There are at least two Swing development plugins available, most of which appear to be in their early stages of development

So if you thought that such a little book wouldn't cover much more than what real newbie would need you will missing a good book.

Much needed book
This book certainly fills in a need for a well organized, easy to read and exhaustive reference for the open source Eclipse IDE and platform.

The book is in fact quite ambitious since it seems to want to teach readers how to program, how to design and build software, how to use the Eclipse IDE as well as how to use a number of open source tools such as ANT, Log4J, JUnit, CVS, Tomcat, SWT and JFace and even XML!

The surprise is that it pretty much achieves its goal. Seasoned Java programmers may elect to skim through the more familiar sections and concepts and concentrate on the Eclipse specific stuff.

I tried to find one important Eclipse feature that was not at least mentioned but could not find one. Even developers very much familiar with Eclipse will probably learn new tricks by going through the various chapters.

I was expecting more or less a user's guide to the Eclipse IDE but in addition I found a very good although brief introduction to the Eclipse APIs and platform as well as relevent material on how to extend Eclipse by writing plug-ins

A few other books on Eclipse were recently published but I cannot compare not having read them but this one is certainly useful for newbies as well as regular Eclipse users and developers. ... Read more

Subjects:  1. Computer Bks - Languages / Programming   2. Computer Books: Languages   3. Computer software   4. Computers   5. Development   6. Java (Computer language)   7. Java (Computer program languag   8. Java (Computer program language)   9. Programming - Software Development   10. Programming Languages - Java   

Subjects:  1. Computer Bks - Languages / Programming   2. Computer Books: Languages   3. Computer Programs Testing   4. Computer software   5. Computers   6. Java (Computer program language)   7. Programming Languages - Java   8. Testing   

Customer Reviews (16)

This Book Deserves It!
dont you get sick of all these 5-star reviews ...? i sure do. but this time, i liked this book so much, i am sending one in anyway.

i don't mean to overstate things, and no, i am not related to Sun OR any of the authors, but this is simply one of the best 'computer books' i've ever read, even though it came from a vendor, and even though it's title (not to mention its topic) is rather pedestrian. here's why:

1) unlike many of the 'teach yourself Java' books, it finds just the right level of metaphor. am i the only one tired of the use of fruit, etc. when explaining objects? this book does that a little, but it also relates everything back to real-world problems that are complex enough to matter but simple enough to be graspable.

2) no irritating humour. I'm sorry, but i have had enough of computer-book authors who can't restrain their wit (like Bill Vaughan, so is otherwise a great writer).

3) a great explanation of threading. in all the other java books, i gave up after a few pages. i read the threading chapter in this book while driving home, and it made complete sense the first time round!

4) NO TYPOS. actually, i found one this morning. page 372, line 4, there is an extra hyphen. but that's it! it is almost unheard of, in my experience, anyway, to find such high quality in a 'computer book'. and personally, i find it insulting to spend $... on a book only to find the author didn't even proof their work.

5) after reading an explanation of interfaces in at least 4 other places, i THINK i finally get it, thanks to this book!

ONE BIG BEEF: having the answers to the exercises available only on the web is a major irritation. what were they thinking? for one thing, sun.com always seems to be the slowest site on the web. and that's assuming you have a networked PC handy, which i did not when i read this book.

i also agree that the space taken up by references to sample code was distracting and useless. on the other hand, there were 1 or 2 places (in the Swing chapter in particular) where the book did NOT include a printout of the complete source, which it should have.

notwithstanding the preceding comment, i believe this book was about right. it wisely omitted JDBC and stopped at a fairly skimpy coverage of Swing, which is correct, IMHO, in a book at this level. i also don't need another 4" thick book full of screen prints and fluff, which is what many of the competing books have.

all in all, i found that despite my interest in Java being modest at best, i literally could not put this book down. i read it almost nonstop cover to cover. no, i am not a freak, normally i fall asleep after two chapters. solid writing, well scoped, and near-perfect execution earn this a *****.

Best Java book if you have a Visual Basic background!
Coming from a Visual Basic background, a lot of other Java books weren't as helpful as this one (I bought the 3rd Edition of the Tutorial). The beginning chapters on OOP were very well written, I think it was the only Java book I've perused where every sentence made sense the first time I read it. The authors' use of metaphors to help make a point is done just right, not too little and not too much. If you have *some* experience with programming techniques, even just doing some .BAT files, I think you'll do well with this book. I had started reading Bruce Eckel's "Thinking in Java" before this one, but I think the best sequence for anyone else struggling with the transition from Visual Basic, etc. to Java is as follows:

- first read the Java Tutorial (3rd edition) and work through the exercises at end of each chapter
- second, read Peter van der Linden's "Just Java 2" for a very readable (sometimes funny) way to wade a little deeper into how Java does things.
- finally, and I have yet to do this myself, read Bruce Eckels' "Thinking in Java" to really wrap your head around object oriented programming and thinking like a Java guru.

Woefully Inadequate on Basics
For someone already familiar with C type programming this is probably an excellent book. It has lots of examples, great linked online resources, a pretty good index, and is one of the most error-free technical books I have read in 5 years of programming. However, this is NOT the book for those with no C (or maybe VB) type programming background.

The authors jump right in using the Java language. While this makes it more interesting it leaves non-C programmers to wonder about the constructs. Examples area great IF they explain everything new that is introduced. For example, the following are used in the first part of the book:

String[ ] args
String args[ ]
String[ ][ ]

But it is not until nearly halfway through the book (end of Ch 4 of 10) that array constructs are discussed. And even then I don't recall any discussion of the difference between the first and second example above. Another example:

Sleep((int)(Math.random() ...))

What is this? Casting maybe? Casting is not even in the index so you just have to guess.

This book needs 2 things to make it excellent: First, an appendix that clearly and thoroughly explains the constructs, syntax rules, and naming conventions - all in one place. For example, what do the curly braces signify, why are empty parens or empty curly braces or semi-colons used, when do you use String[ ] args vs String args[ ] - the works. Secondly, it needs more comments in the examples, including the reasoning involved (eg why variable was declared outside instead of inside method) and an explanation when anything new is used. Admittedly, experienced programmers will not want heavily commented examples, so making those available on line would be a good solution. ... Read more

Subjects:  1. Computer Bks - Languages / Programming   2. Computer Books: Languages   3. Computer Programming Languages   4. Computers   5. Java (Computer program languag   6. Java (Computer program language)   7. Programming - General   8. Programming Languages - Java   9. Computers / Programming Languages / Java   

Customer Reviews (230)

Dry but useful
I already knew Java pretty well, but I'll be changing jobs soon and I wanted to put certification on my resume to make keyword-grepping HR bots happy. (Sigh.) I figured I could pass the test cold but didn't want to bet money on it, so I bought this book.

I think it's a pretty good book, but I haven't read any other Java certification books so I have no basis for direct comparison. It's seems a bit dated, but the Programmer exam hasn't changed much in a couple of years (still based on JDK 1.2 without Swing) so that's okay -- adding more coverage of newfangled stuff that isn't on the current test would not please the intended audience. The one big change in format versus the sample test in this book is that the current test tells you how many answers to check on the more-than-one-choice multiple-choice questions. (Poke around some Java certification web sites.)

It covers both the Programmer and Developer exams, so it's thicker than books that only cover the former. I haven't taken the latter, so I don't know how on-target that part is, but it was an interesting read. (Certainly more interesting than the half of the book that focuses on the Programmer exam, but that reflects the nature of the two exams. The Developer exam is about writing real code, while the Programmer exam is about being a human compiler and language lawyer.) The Developer section does not give a complete solution, though, just hints. I understand why the Sun-employed author doesn't want to do that, but they could have invented a problem similar to but not identical to a real assignment and then solved it completely.

The Programmer exam is a multiple-choice test based largely on memorizing a bunch of exact rules about how the language works. Some of them are things you really need to know (e.g. what private and final mean), and some are just stupid memorization. (Do you remember the exact nested constructors of all those Writers and Readers and Streams in java.io, or do you just look them up in the handy online API help?)

My one criticism of the book is that, perhaps because the main author works for Sun and is directly involved with the certification exams, the book isn't blunt enough in places. If I wrote it, I would say things like "I know it's idiotic, but memorize every single method signature in Thread and which ones are deprecated" rather than just teaching what really matters about Threads, because the exam unfortunately focuses on both equally rather than on the important parts. People buy this book because they want to pass a test, not because they want to learn the language. They've already done that using other sources. So the book should teach more directly to the test. Maybe the non-Sun-affiliated books are better in this regard.

The book comes with a CD. It has a Java-based program that lets you take the chapter exercises and sample test (only one, unfortunately), which IMO beats taking it on paper. The text of the book is also available on the CD, in encrypted PDF, but unfortunately you have to run a Windows-only setup.exe to install it. Yes, a book about a portable language, stored in a portable document format, with a non-portable installer. Some people just don't get it.

By the way, I passed the Programmer test, but it was harder than expected. I would not have passed it cold. My advice is to buy a certification book (can't say which one since I only read this one), study, and make sure that you can pass a couple of sample exams by a comfortable margin before you drop money on the real thing. If you don't already know Java pretty well, I don't think you'll be able to pass this exam via just studying a couple of books (unless you have a photographic memory) -- write some real code first. Even if you do know Java, write some small test programs dealing with areas you might be weak in (threads, AWT if you've done primarily non-GUI work, collections if you mostly use arrays, inner classes, exceptions) to cement what you've learned.

Excellent Review, Easy to Understand, Missing 1.4 Objectives
Having recently passed the new Programmer 1.4 Exam, I found this book does a very good job of explaining all the basics need for certification.

Each chapter is devoted to a different topic and has 10 review questions at the end to reinforce chapter topics. Unlike some of the other prep books on the market, I did not feel overwhelmed at the amount of information. The author does a good job of going through the material at a slow pace and clearly explaining the topics. Since I have only read the Programmer section, I can not comment on the Developer section.

The only negative aspect of this book is that it is geared for the Java Programmer 1.2 exam, not the new 1.4 exam (released October 2002). While the 1.2 exam is still available, I imagine most people will be looking to take the new 1.4 test. The 2 versions of the exam are very similar, but 1.4 exam omits IO, AWT, and Swing. These 3 sections take up a large chunk of the programmer portion of the book (200 pages approx.). This said, you may want to wait for a new 1.4 version of the book to come out that covers the new topics (assertions, hashCode()/equals(), etc).

Overall, a great exam preparation book and worth the money.

Don't Buy Just For Sun Certified Java Developer Exam
This book will get the job done if you're using it to pass the SCJP exam. However, it is not at all helpful when it comes to the SCJD assignment. The book gets way too advanced when it comes to the SCJD part. It glosses over topics like distributed event notification, and creating a thread pooling mechanism. These things are not necessary for the exam at all and the book's explanations are way too generalized to help you understand them anyway. I found the book's style to be too formal and much less readable than the book by Kathy Sierra. If you're just taking the SCJP test, this book will work for you. But, if you're going for the SCJD, I recommend "The Sun Certified Java Developer Exam With J2SE 1.4." This latter book goes into way more detail and is much more helpful for SCJD. ... Read more

Subjects:  1. Certification   2. Certification Guides - General   3. Computer Bks - Languages / Programming   4. Computer Books And Software   5. Computer software   6. Computers   7. Electronic data processing per   8. Electronic data processing personnel   9. Examinations, questions, etc   10. Java (Computer program languag   11. Java (Computer program language)   12. Programming Languages - Java   13. Study Guides   

Customer Reviews (12)

Great for College Course
I'm a Java instructor at a state university, and I recently received a copy of this book. I think it addresses the needs of a classroom far better than many of the other Java books I've seen so far. We used Core Java for a while, but it lacked the pacing, visual aids, and examples that were needed for our students. I think it will be perfect for our 2nd-semester students who have had a semester of C++ and now need to explore inheritance, polymorphism, and recursion. I particularly like the fact that Big Java introduces container classes and elementary data structures, providing a smooth path from this level into a full-blown data structures course in the following semester. Another plus: Horstmann introduces graphics at a very early point in the book, making this topic easily accessible and providing motivation for the students to explore graphical programming at a deeper level later on in the course.

Clear as Mud
This book was in use by my High School son's computer science class. I am a C programmer with little Java background, and I found this book confusing and of little value. Multiple examples were carried through the book, but in a sporadic fashion that makes it difficult to follow from start to finish. This is a terrible reference book, and I've got to believe there are better books about Java available.

The one star is for the benefit of those that want some of the computer science knowledge that is contain within. The author should have focused on that aspect of their knowledge-base, and used Java for the examples.

If you're new to Java, but not programming, look elsewhere as this book won't be of much use.

tough to read
I am only a novice. While I have read several other books on Java; I did so very rapidly and without really trying to work out the problems. When I read "Big Java" I find myself going to other books (e.g. Sun's Java 2 Language Manual; Complete Java
ver. 2, etc.) They just seem easier to comprehend -- more straightforward. Mr. Horstmann omits a lot of detail-- he "elides" many code snippets.* When I get through the book, I'll probably love it; it's a class text and I can't avoid it's use. For now ... arrrrrrgh!

Billy Hess

* In case you're wondering "what the heck?" it means to use an elipsis(...) in place of ... ... Read more

Subjects:  1. Computer Bks - Languages / Programming   2. Computer Books: General   3. Computer Networks   4. Computer Programming Languages   5. Computers   6. Java (Computer program languag   7. Java (Computer program language)   8. Programming Languages - Java   9. Computers / Programming Languages / Java   10. Java & variants   

Customer Reviews (22)

More than just a Java Certification guide
There are many books on the market dealing with the topic of Java Certification, and this is a newer entry in that popular field. From the title, A Programmer's Guide to Java Certification, one is led to believe that this book is for experienced developers who are looking to complete their knowledge of Java and go on to the next level of mastery. This book does achieve this goal, but it goes far beyond this objective and is worth much more than a simple study guide or reference manual.

In the preface of the book, the authors state that this book will not address graphics, as graphics topics are not part of the Sun Certification exam. Since this book is aimed squarely at helping the reader pass the certification exam, there is no need for topics dealing with graphics, and the authors make this very clear from the beginning. This is therefore the wrong book for you if you need AWT or Swing material.

Consistent with its implied goal of expanding the knowledge base of experienced developers, the book has deep discussion of the structure of Java applications, but the discussion is taken a step further. The authors use UML diagrams, starting as early on as page 3, to give a more graphical depiction of the relationships and structures they describe. This is very different from the other Java books I have seen and is a very strong reinforcement for the topic. Not only does the reader read about the topic, but the UML diagrams drive home the point so that the reader can *see* the relationships. The authors even explain in enough detail how to interpret the UML notation, so previous knowledge of UML is not a requirement. UML is not the focus of this book, so there is not an emphasis on it and there's no exhaustive tutorial on it, but it's enough to supplement their main topic -- Java.

Each chapter follows a logical format, beginning with a brief summary of the exam and chapter objectives, followed by one more sections of discussions with review questions for each section (some small sections do not have associated review questions following immediately). The chapters are concluded with a chapter summary and one or more programming exercises to reinforce the material. Answers to the questions, and solutions to the exercises, appear in an appendix towards the end of the book.

Appendices A, B and C describe the different certification exams and states which exam this book targets. They explain in general terms what is involved in taking the test, from registration to getting the certificate from Sun, as well as the objectives of the exams as determined by Sun. Pay close attention to Appendix C -- it draws special emphasis to topics that are highlighted on the platform upgrade exam and points the reader to relevant sections in the book.

The book includes a mock exam for certification as well, and the CD that comes with the book has additional mock exams. After digging through the book as well as taking the mock exams, the reader can expect to be very well prepared when taking the certification test.

This book might be written with the express purpose of taking the certification exam, but it serves other purposes as well. After the exam, this book will serve the reader well as a reference guide for Java, arguably one of the best reference guides at that. For non-Java developers (coming from C, C++ or another developmental language) it serves as a marvelous introduction to Java that will propel the reader to an excellent understanding of Java from go.

So, how does the actual content of the chapters stack up? I'll break this up into two paragraphs, because there's two different aspects I'd like to address. Many Java books are written in the typical 8th-grade English designed to be more "personal" and approachable. This book, however, uses more advanced grammar and vocabulary, being more in line with university reading levels. It gives the book a more "sophisticated" feel, and I personally like that.

As far as the actual material, the reader cannot read this book and come away without a good understanding of the subject. For example, Chapter 9 deals with threads. Another certification manual I have follows the topic of threads by giving a tidbit of information, followed by a blob of code, followed by the next subtopic. There is never a real discussion of threads. This book, however, explains the need for threads, how they work, how to create them in both manners, and gives supporting code to emphasize the material. In the middle of the discussion are UML diagrams, depicting relationships of the structures used. After the supporting code, there's a little more discussion, followed by a section for review questions. ONLY THEN does the book move to more advanced thread topics, instead of teasing the user.

A Programmer's Guide to Java Certification is an excellent preparatory work for taking the basic Java Certification exam, but it is much, much more. Readers can expect to come away with a thorough knowledge of Java fundamentals, as well as a basic understanding of UML and object relationships. After passing the exam, the reader will have a superb reference manual that will server him/her well. If you are wanting to take the exam, or even if you just want to learn Java, this book is the right place to start.

Excellent Certification/Basic Java Reference Book
I used "A Programmer's Guide to Java Certification" as a study guide for achieving my Java Certified Programmer (JCP) status two years ago, so when I had the chance to review the second edition, I jumped at it (full disclosure: the publisher sent me the second edition to review). As I expected, I was again aghast and delighted at the level of detail, the exercises and the arrangement of this fine book.

Mughal and Rasmussen do a good job of covering all the nitty gritty details that the JCP requires one to know. Whether the length in bits of an int, the difference between overloading and overriding, or the order in which initializer expressions get executed, this book gives one enough detail to overwhelm the novice Java programmer, as well as cause those more experienced to scratch their heads and perhaps write a small program to verify what was read was valid. While this book lacks the discussion of I/O and the GUI of the previous edition (due to changes in the JCP test), it has a fine set of chapters on some of the fundamental libraries and classes. My two favorite explications are the chapter on Threads (Chapter 9), where that complicated subject is treated well enough to motivate more learning while not overwhelming the reader with detail, and the String and StringBuffer section of Chapter 10. So much of the Java programming I've done has been dealing with Strings, so this section, which covers the String class method by method and deals with issues of memory and performance as well as normal use, is very welcome.

The exercises were crucial to my passing the JCP, and they remain useful in this book. Grouped at the end of logical sections of chapters, they break up the text and re-iterate the lessons learned in the previous sections. The answers to these exercises are in the back of the book. Also, a full mock exam is included at the back, as well as an annotated version of the JCP exam requirements which serves as a study guide (both for the full JCP 1.4 and for the upgrade exam). Reading over the mock exam definitely let me know what areas I'd need to study if I was taking the JCP again. In short, the didactic nature of this book has not been lost.

The arrangement of this book is also useful. A fine index and the logical progression through the features of the Java language eases the onslaught of detailed information mentioned above. The extensive use of UML diagrams (especially class and sequence diagrams) was helpful as well. If one reads the book sequentially, one learns about how object references are declared (Chapter 4), then the various control structures available in Java (Chapter 5), then the basics of Object Orientation (Chapter 6), then the object life cycle (Chapter 8), in a very linear fashion. Additionally, there is extensive cross-referencing. This may not be useful to the novice programmer, but to anyone using this book as a reference, it's invaluable, because it allows Mughal and Rasmussen to provide yet more logical linking of disparate topics.

However, this book is not for everyone. I wouldn't buy it if I wanted to learn to program. While there are a few chapters that have general value (Chapter 1, Chapter 6), the emphasis on mastering idiomatic Java, not general programming concepts. Also, as they state in the preface, this is not a complete reference book for Java. It covers only what is needed for the JCP. Finally, if one wants to know how to use Java in the real world, don't buy this book. While most of the java programming I've done has benefited from the understanding I gained from this book, it has not resembled the coding I did for the exercises at all. This makes sense--this book is teaching the fundamentals, and does not pretend to cover any of the higher level APIs and concepts that are used in everyday programming.

The best book on the market
This is a very good book. It's very well written. It is not an easy book, it covers a lot of details. If you learn this book you
will have a VERY high score on the exam! I can really recommend this book. This book stands out from the rest of the crowd. Sadly
you can't say this about many books out there today... ... Read more

Subjects:  1. Certification   2. Certification Guides - General   3. Computer Bks - Certification   4. Computer Books: General   5. Computers   6. Electronic data processing per   7. Electronic data processing personnel   8. Java (Computer program languag   9. Java (Computer program language)   10. Programming Languages - Java   11. Study guides   12. Computers / Programming Languages / Java   

Customer Reviews (10)

Simple, and elegant
If I were looking for a Spring or Hibernate book, this one would let me down. But that's not what Gehtland and Tate are trying to do. They are showing why Spring and Hibernate are important, and how they have passed up enterprise java beans. They have shown basic rules for lightweight development, and they have done it effectively. The book is simple, well-written, and in conflict with established J2EE development. I get into the emphasis on JUnit.

I also like how Gehtland and Tate show me more than programming. They let me see how companies sell. They show me how a better process can work. I like extreme programming, but my manager doesn't. They give me some good ideas about how to use the best parts without doing all of XP.

I also like the idea of showing the principles, and then seeing how those principles apply to open source software, and then showing me how to put them into use. I don't think that the book would have been useful if they would have simply tried to invent some application that fit their model. Instead, they picked a couple of open source projects that seem to do what they are advocating.

Lighter Faster java is a home run. If you're looking for a Spring book, just go buy Expert J2EE One on One. If you want to understand why Spring, and other technologies like it, are important, get Lighter Faster Java. I can understand how to program Spring and Hibernate with tutorials on line. This book gives me something far more valuable. Insight.

I think I'm also going to pick up one for my boss.

Good book for architects and senior developers
Better, Faster, Lighter starts by explaining the basic problem in J2EE, complexity and API bloat, and then builds around five principles that should guide Java application development. Each of these principles are enclosed in an individual chapter, and in the second half of the book, these principles are explained using open source frameworks and example code.

The most useful chapter for me was the chapter called "You Are What You Eat" as it explains alternatives to the standard J2EE architecture. It discusses all the major technologies that J2EE architects and developers care about - XML, Web Services, Session and Entity EJBs, Distribution etc, and gives scenarios under which it is suitable or unsuitable to choose each. This is the sort of information that is useful for persons who make architectural or design choices. The book also proposes two alternate deployments to the traditional 3-tiered architecture and gives reasons why these would lead to improved performance and lower complexity. This chapter explains how to make the technical decisions that will impact application development down the road.

This book gives an introduction to two of the most popular open source frameworks today - Spring and Hibernate, and argues that they have become successful as they focus on simplifying Java development. The chapters on Hibernate and Spring are relatively short at 22 and 25 pages respectively, and so should not be relied upon for a detailed exposition into these frameworks. Persons wanting to get up to speed with these technologies should buy Rod Johnson's Expert One on One J2EE Development without EJB, or Matt Raible's Spring Live, as well as the Hibernate in Action when these books are released. But the chapters fit nicely into the overall argument in favor of simple tools that help simplify development.

The Spring chapter explores the JPetstore sample application that uses IBatis as the persistence layer. Later on Bruce Tate discussed moving to Hibernate, and also supports the use of JDO.

Better, Faster, Lighter Java is a little different from the traditional Java/J2EE books, and is written in a conversational, rather than a technical style. Thus it's more useful for persons seeking the big picture surrounding Java development, rather for pure techies. Relatively few books focus on the why of application development, and I recommend this book as one of these. If you enjoy reading authors such as Rod Johnson, Martin Fowler, and Scott Ambler, then this book won't disappoint.

A useful guide to successful development
"Better, Faster, Lighter Java" does a great job of walking the reader down a path to successful J2EE projects. In the vein of "Bitter Java" and "Bitter EJB", it exposes some of the myths -- both procedural and technical -- in today's J2EE world. Additionally, it goes a step further than the "Bitter" series by providing holistic solutions to managing and implementing successful projects, rather than localized solutions to specific anti-patterns.

The first few chapters provide excellent coverage of practical agile development, as is often seen in the real world. Bruce and Justin explain the motivations behind concepts like test-driven development, continuous integration, scope definition and creep, and the trade-offs of coupling. They then show examples of how to implement these concepts in an enterprise Java project. These concepts are absolutely critical to any non-trivial project, as they make or break the ongoing maintainability of a project. Anyone who has not used agile processes in the real world (i.e., anyone who thinks that tests belong in the QA department only) should read this book just for those chapters.

The book then continues to discuss common framework components and how they interact, including the pros and cons of different persistence and container strategies. In an interesting twist, the authors analyze the framework components discussed against the criteria for successful projects established earlier.

One of the points that the authors make is that a project should do one thing, and do it well. This book focuses on one thing -- a high-level analysis of how to execute on a successful development project. This is not a definitive reference guide on any of the technologies or processes discussed. Rather, it distills out the essence from the various types of components that you will encounter in your project, and puts them together in an easy-to-follow format.

One gripe that I had was that the Hibernate and Spring chapters delved a little too deep into their respective topics. I would have preferred to see more coverage of other aspects of the development cycle (preparation of content for hand-over to the UI design team, the role of Swing / SWT front-ends in enterprise development, etc.) rather than more depth on particular framework components. ... Read more

Subjects:  1. Computer Bks - Languages / Programming   2. Computer Books: Languages   3. Computers   4. Handbooks, manuals, etc   5. Java (Computer program language)   6. Programming - Software Development   7. Programming Languages - COBOL   8. Programming Languages - Java   

Customer Reviews (27)

Good work, a real 5 star XML book
The buzz is all around. XML and all derivatives are attracting everyone. There are many XML books in the market but few are satisfactory. I like the books which can offer more than tutorials on the web. This is one of those. First of all, the book is well organized and easy to follow. Learn the idea behind SAX, DOM and then JDOM. Having a good understanding of these basics, go on with three main application areas of XML:"web publishing","interoperatibility", and "data binding". This is what XML developers should do, and author follows this order very well. In fact, I remember Brett's one article where he suggested developers not to forget basics of parsing while working with higher level APIs and protocols.

If we look at the details of book... After covering the basics of parsing, Brett introduces some -very good- real world examples: Cocoon(for publishing frameworks), soap, xml-rpc, and web services for communication or interoperatibility and Castor etc. for data binding.

What is missing or not intended in this book is XML data structure design and XSLT. This is understandable since both are very detailed topics that wouldn't fit in a single book. For XSLT there are the O'reilly Java & XSLT or Wrox XSLT books and for XML-Schema... I'm just waiting for a good one.

Especially for those intermediate level XML programmers with Java knowledge.

Good introduction, a little diffuse
Compared with .NET and XML this book tends to wander and rat hole a little. The book covers the basics. The SAX and DOM approaches. It also covers XSLT and serving XML. It also covers advanced topics like Castor, JDOM, and web services. But most of the subjects are covered at a cursory level and do not serve as a complete introduction.

There is a small reference at the end of the book which is not as easy to read as the APIs described in the Nutshell style.

I gave this book four stars because, while it does lack focus, it is a good introduction to the XML APIs for Java. In the third release they should concentrate a little harder editing in some focus and a better reference section at the end.

Good coverage of XML programming in Java
XML and Java, true to the title, provides detailed and broad coverage of XML programming in Java.

The chapters on SAX, DOM and JDOM provide a strong foundation for selecting and leverage these libraries at a practical level. The coverage of rapidly emerging XML topics including XML-RPC, SOAP and Web Services is timely and reasonably detailed, providing adequate information to allow these to be practically applied.

The author's writing style is easy to read and has a code-centric focus. The numerous examples were intelligently explained without providing detail that someone already familiar with the Java programming language would find verbose and boring.

This title is best suited to for those with some background in Java and a general understanding of XML. Assuming this background, this book can help bridge the gap from being a Java/XML programming novice to being a Java/XML programming expert. ... Read more

Subjects:  1. Computer Bks - Languages / Programming   2. Computer Books: General   3. Computer Networks   4. Computer Programming Languages   5. Computers   6. Internet - Web Site Design   7. Java (Computer program language)   8. Programming Languages - HTML   9. Programming Languages - Java   10. Programming Languages - XML   11. XML (Document markup language)   12. COM051320   13. Computers / Programming Languages / Java   14. Java & variants   15. XML   

Customer Reviews (33)

Hey all you Java beginners, read this review before u buy...
Warning to all you Java beginners: Don't expect to read this book and immediately graduate to an "intermediate" Java programmer - ESPECIALLY if you're new to programming and/or object-oriented programming.

This book gives you a fairly good introduction to the basics of Java; Ivor Horton is a bit "dry" but does the job. If you don't have experience with object oriented design (like C++), you'll NEED to also purchase, "Beginning Java Objects" by Jacquie Barker. And when I say "NEED", I mean NEED!! Jacquie's book is absolutely ESSENTIAL for any person new to objects.

It is impossible to fit all the beginning Java topics into one book (even if it is 1200+ pages) and Ivor doesn't try too. He goes over threading and Swing but you'll need to seperate books for these topics.

Another warning for Java newbies: Beginning Java topics can be quite boring, I'm sure many will want to jump straight to the cool stuff like Swing, JSP/Servlets, J2ME...but you MUST understand objects, java terminology, and other basic principles FIRST. You may want to check out books like "Java Cookbook", "Design Patterns Java Workbook", "Design Patterns Explained", "Objected Oriented Thought Process" and especially "Beginning Java Objects" to complement Ivor's book.

I gave this book 4 stars because "beginning" books should take you by the hand and babystep you through the process (in my opinion), this book doesn't quite do this (Jacquie's book does). You may feel more comfortable with one of these "dummies" or "teach yourself in 21 days" or "Java Bible" instead (though I haven't read any of these). But stay away from the "Core series" or "O'Reilly" books if you don't want something too hard.

To learn Java you're gonna need to drop some $$ on a bunch of books and you'll need to spend some SERIOUS time practicing, but as Ivor Horton says, "Nothing worthwile is achieved without effort. You'll need to put in the work and have the ambition to succeed when the going gets tough."

Best book to learn Java
Ivor Horton has once again produced an exceptional beginner's book for Java. I have reviewed many beginner books on Java in the search for a textbook for an "Introduction to Java" class that I teach at Hofstra University. Few of these books have met the goal of providing a solid base of knowledge upon which a programmer can build. Ivor Horton's "Beginning Java" is one of those few. This book is an excellent introduction to Java for anyone who has a basic understanding of programming and is willing to apply some effort to learn the language. Horton proceeds at a rapid pace to cover virtually every important topic in Java outside of the Enterprise Edition. Starting with the basics of the Java language Horton explains the Java syntax in great detail. He then goes on to cover exceptions, streams, utility classes, threads, GUI (with a concentration on Swing), and file processing. In addition, Horton covers all the important new features of the 1.4 release including more than 100 pages on XML. Each chapter builds upon the previous chapter using extensive, well designed and clearly explained examples. Although the book covers a wide range of topics, it does not treat any of them lightly. Many introductory books fall short in the very important topic of object oriented technique. Horton does an excellent job of both explaining OO and then using it in his many examples. Unlike other books that you may read and discard, this is a book that will continue to provide help far into your Java career.

Clear, well-written, and comprehensive
While the voluminous nature of Horton's introduction may scare away a Java beginner, they should know that there is no better introduction to the language and the library. Horton uses visual aids whenever it brings added clarity to a situation, and spends just the right amount of time in each chapter on preliminary text-book style writing before throwing any Try-it-out programs at you. Like all Wrox books, if you don't understand how the code works, there's a short explanation of the syntax and classes involved following each example.

The book teaches Java from the ground-up - starting with object orientation and basic language syntax. These first few chapters are solid explanatory.

Next, the chapters on classes, inheritance, and exception handling describe the more advanced language concepts with just as much clarity as the more elementary information.

The core library features are given attention and a large portion of the book is devoted to GUIs and drawing. I have never seen a more in depth and yet understandable guide that doesn't assume prior knowledge of the concepts. Additionally, Horton only uses the newest and most robust methods of doing things when there's a choice; for example, he opts to use the New I/O API rather than the old file input and output streams, but still gives you an explanation and example of how the basic streams work before bringing in the new material.

I cannot recommend this book more for someone who wants to learn Java. The only requirement is some free time and devotion. Even if you don't intend to read the entire thing, the first 10 chapters alone are worth it. ... Read more

Subjects:  1. Computer Bks - Languages / Programming   2. Computer Books: General   3. Computers   4. Java (Computer program languag   5. Java (Computer program language)   6. Programming - General   7. Programming Languages - Java   8. Computer Programming   9. Computers / Programming Languages / Java   10. General Theory of Computing   11. Java & variants   

Customer Reviews (25)

Practical Examples Beyond Basics
OK, you've learned the basics. You know 'public static void main string args' from a hole in th ground. What now? I teach Java at a college. Only a small percentage of my students are CS majors. Most introductory java books lack good practical problems to solve. The Java Cookbook is a list of common problems and code examples on how to solve them. I learned more in two days with this book than I did with several very good java books because I need to see examples and how things work in context. If you're like that too, you'll love this book. I pack it with my laptop so I'm never without it when I need it -- it's that useful to me!

More than a cookbook
The examples in this book are truly useful. I am an experienced programmer just starting with Java and in finding an answer in this book, I often discover better ways of doing related tasks as a welcome side effect.

In addition, the author presents each code example with a thorough and useful explanation. His writing style and attitude are humble, opinionated, direct and humorous. This is the only book in my java collection that's a pleasure to read.

I tried using Java examples in a nutshell... I haven't picked it up since obtaining "cookbook". Plus I look to "cookbook" first before either java in a nutshell (except for simple reference) or java servlet programming.

Excellent reference!
I had been searching for a good book that served as a reference for short snippets of code, similar to what "The Visual Basic 6 Black Book" did for VB and my understanding of it. I had seen "Java Black Book" at bookstores, but really was hesitant on purchasing it after seeing an unkind review for it. After mentioning this to someone, he loaned me his copy of Java Cookbook so that I would see what it was like. A few days later, I was returning his copy because I had already obtained my own. I was sold!!

There is tremendous amounts of detail in this book, starting from the author's own package of goodies, to small routines adapted from other texts on programming (and giving due credit to these references), to extended examples of code that solve a myriad of problems. All of the code is downloadable from the 'Net. The table of contents, 5.5 pages long, lists a condensed one-line description for each piece of code in the book.

But the book is not only code. The descriptions themselves of the code are practical and helpful as well, explaining reasons behind design decisions for certain structures. I've created my own version of some of his programs (a Roman-numeral class he develops seems to do well in writing them out, but not at reading them. Strange topic to adapt, but I just wanted to challenge myself.) and found that I like mine better, but I'd probably never have gotten around to doing such until I saw his routines.

All in all, this book is a prize possession, and one I'd like to recommend very heartily. ... Read more

Subjects:  1. Computer Bks - Languages / Programming   2. Computer Books: Languages   3. Computers   4. Java (Computer program languag   5. Java (Computer program language)   6. Programming - General   7. Programming Languages - Java   

Customer Reviews (19)

Very Good Book
I have purchased a few of the C# and .NET books for Java people,
and this is the best. The feature that stands out for this book
is the great Java to C# class reference, so you can look upa
Java class and find out which C# class does the same thing.

Very Pleased
Before I found this book, I was rather lost. I was trying to learn C# and the framework using the docs that came with the .Net Framework installation and was only getting so far. I didn't feel like I was learning it comprehensively.

Even though this book is large, it's easy to read, has example code throughout, and covers a lot of what I needed to know. It had a breadth I found lacking in other Java to .Net books.

Unlike the other books I looked at, this one provides enough information so that you learn how to compile the example code using the free command-line compilers of the .Net Framework SDK rather than making you get Visual Studio.

for the experienced java developer
This books hits the spot for java developers, the intended audience. A one page description on delegates, for example, has all the information you need to get started with delegates. The Oreilly book has a long winded chapter on it and the essence was lost in the obtuse example provided. ... Read more

Subjects:  1. C# (Computer program language)   2. Computer Bks - Languages / Programming   3. Computer Books: Languages   4. Computer Networks   5. Computer software   6. Computers   7. Development   8. Java (Computer program languag   9. Java (Computer program language)   10. Object-Oriented Programming   11. Programming - General   12. Programming - Object Oriented Programming   13. Programming Languages - C#   14. Programming Languages - Java   15. Computers / General   

Customer Reviews (4)

Not as useful as expected
This book would have been better if it had been written by people who had the ability to be a bit more objective about these technologies. (The authors work for Sun, of course.) There is a large portion of the book devoted to repeated explanations about why the J2EE platform is the best available. There are a number of plugs for client-side Java programs (applets, etc.), which is a marginal technology in practical terms, despite its theoretical advantages. I just wanted more objective information and less marketing hype. That being said, the book does have some useful information. A better and more dispassionate look at the J2EE platform spec is "Java for the Web with Servlets, JSP, and EJB" published by New Riders.

An overview of technologies and architectural models
The book is a high level overview of the application design with the Java 2 Platform, Enterprise Edition. It may be helpful for someone who wants to know how different architectural choices and technologies fit together in an enterprise application.

It starts with an introduction to different enterprise application scenarios (Stand-Alone, Web-Centric, EJB-Centric, B2B, etc.), and then goes on discussing each of the architectural tiers in detail. In addition, in separate chapters it covers important issues like security, transaction management, internationalization, and localization.

As a rule, each chapter gives an overview of the involved technologies, considers most important issues, and provides some tips on design and proper usage. Available tools are also discussed. Each chapter is followed by a list of references and resources. Many resources have URLs.

The last chapter presents an architecture of the sample application. Unfortunately, quite a bit of space in this chapter is wasted reiterating general pros and cons of distributed and local architectures. My impression is that the author of this particular chapter (each chapter in the book is written by a different author or group of authors) assumes that the reader does not have any prior knowledge about the subject and have not read preceding chapters.

A few code samples in the entire book illustrate some points in the discussion; the code snippets are neither complete nor complex, and obviously are not written for reuse.

Essential read for designing J2EE applications
A must read for seasoned professionals and those new to the subject. Invaluable insights and guidelines are detailed at every tier of architecting a J2EE enterprise application. I found myself frequently relating to the examples and wishing I had read this book to help with earlier projects. This would have saved hours of re-factoring because the authors have already detailed solutions to common design problems.

If you are looking for code examples, don't look here. Code examples throughout the book are minimal; however this book is not about code examples, the purpose is to provide proven principles for architecting and developing J2EE applications. Instead, one chapter describes the design of the sample Java Pet Store application in regards to the books principles.

I now have a better understanding of the J2EE platform and how to apply its technologies. I will be referring back to this book often! ... Read more

Subjects:  1. Business   2. Computer Bks - Languages / Programming   3. Computer Books: General   4. Computer Programming Languages   5. Computers   6. Data processing   7. General   8. Hardware - Personal Computers - General   9. Java (Computer program languag   10. Java (Computer program language)   11. Microcomputer Application Software   12. Programming - General   13. Programming Languages - Java   14. Computers / Programming Languages / Java   

Customer Reviews (29)

Not for a threads newcomer
I have read a great many books on Java, and have come to expect high-quality, no-nonsense writing from O'Reilly. Java Threads stands out as the worst book I've read from O'Reilly. For a time it was the only book that covered Java threads in detail, but that time has past, and there are far better sources of information out there.

Programming with threads is complex, and though java has built-in methods to provide multithreading, java's thread-handling syntax won't do it all for you. For example, using the "synchronized" keyword isn't enough to make a program "thread-safe." Fine. But rather than discuss solutions to this, Scott Oaks rambles on teaching a solution, and then telling you why what he just taught you won't work. Certainly, this is a professional book, but there's no reason to make it inscrutible. My only real learning came from sifting through the example programs and trying to forget the first four chapters.

If you don't already possess a good understanding of how to program using threads, this certainly isn't the place to start.

A good overview of the subject for intermediate programmers
This isn't the best O'Reilly book in the Java series, but it will provide a reasonably good overview of the subject. I wouldn't recommend this book to beginning programmers, because the topic of threading is overly complex for beginners. Look for a general Java book that gives you some simple templates for using threads, if you need them for something. I also wouldn't recommend this for advanced programmers who have special needs in the area of threading. A more advanced book would survey how real JVMs actually perform thread scheduling, comparing them and provide tips for programmers who ned really precise timing or scheduling optimization. Likewise, if you know most of the ins and outs of preventing deadlocks off the top of your head, this book isn't going to teach you very much.

Who this book is good for is experienced programmers who need to understand the ins and outs of making their applications threadsafe. If you don't have much (or any) background in threading or you've forgotten some things, this book will cover the topic thoroughly, and demonstrate common pitfalls. It's ideal for people who need to code up things like database connection pools, complex synchronized-access data structures, and statically-accessed resources. As others have mentioned, some of the examples are kind of synthetic and fake, but the book is still extremely usable, and it's an easy read.

This book is also effective at covering timed and recurring tasks in Java 1.1 and 1.2, though Java 1.3 now has new helper classes (Timer and TimedTask) that this book doesn't cover. Then again, if you understand how to do it in 1.1 and 1.2 (and really, even if you don't), understanding the new 1.3 classes is dead easy.

This book blows!
I started reading it for the second time, and it stinks! I'm just gonna put it down and spend some more money. It was a twisted learning experience, not worth a cent. ... Read more

Subjects:  1. Computer Bks - Languages / Programming   2. Computer Books: Languages   3. Computers   4. Java (Computer program language)   5. Parallel Processing   6. Programming Languages - Java   7. Programming Languages - XML   8. Threads (Computer programs)   

Customer Reviews (14)

If you use (or want to use) Eclipse, you will need this book
Target Audience
Java developers who want to learn how to use the Eclipse IDE or how to develop enhancements for the Eclipse framework.

Contents
This book is a comprehensive coverage of the Eclipse framework, both from the perspective of using the tool and writing extensions to Eclipse.

The book is divided into 3 parts:

Part 1 - Running Eclipse - Getting Started; Using Eclipse; Using Java Development Tools; Debugging Java; Teaming Up With Eclipse; Eclipse Configuration Management

Part 2 - Extending Eclipse - Overview Of The Eclipse Architecture; Getting Started: Plug-in Development; Action Contributions: The Integration Fast Track; The Standard Widget Toolkit: A Lean, Mean Widget Machine; Dialogs And Wizards; Views; Editors; Perspectives; Workspace Resource Programming; Managing Resources With Natures And Builders; Resource Tagging Using Markers; Contributions Revisited; Advanced Plug-in Development; Creating New Extension Points: How Others Can Extend Your Plug-ins; Serviceability; Developing Features; Providing Help; OLE and ActiveX Interoperability; Swing Interoperability; Extending The Java Development Tools; Building A Custom Text Editor With JFace Text

Part 3 - Exercises - Using Eclipse; Using The Java Development Tools; Debugging Java; Using CVS With Eclipse; Modifying Your Configuration With Update Manager; Using The Plug-in Development Environment; Feature Development And Deployment

Review
As an IBM software developer using Domino and Notes, I'm hearing more and more about WebSphere Studio Application Developer. That's the IBM WebSphere Integrated Development Environment (IDE) that is built upon the Eclipse framework. But just what is Eclipse, and why is it so important to you as a developer? This book will help you answer those questions.

The book serves two purposes. Part 1 of the book will allow you, as a Java developer, to understand how to use the tool to code and test your programs. They also devote coverage to how CVS, the open source version control tool. Even if you're not interested in extending the Eclipse tool for your own use, this first part of the book would be worth the purchase.

Part 2 gets into how the Eclipse framework can be used to write your own tools to integrate into the environment. Granted, this part of the book won't necessarily appeal to everyone, as some of you will only want to use the core functionality of Eclipse as an IDE. But you can think of this section as a lesson on the internal architecture of Eclipse. The more you understand about the tool, the more effective you can be with it.

And finally, you have the third part of the book that consists of a number of exercises to bridge the gap from theoretical to practical. Taken as a whole, working through this entire book will give you a solid foundation in Eclipse.

And for Notes/Domino professionals... I think a case could be made that you should seriously consider buying this book to prepare for your future. ND8 is projected to be a rich client built on this platform. By reading up on it now, you'll be prepared for what's coming. And if you're a business partner who builds tools for the Notes/Domino client, you'll need this information to start to figure out how you can transition your business in the future. Don't let it sneak up on you.

Conclusion
If you're thinking about diving into the Eclipse world, get this book. And if you're already an Eclipse user but want to make changes to your environment, this book will give you the information you need to start down that path.

Classic like Rich Stevens books
Back in 80's when unix network programming was a black art, Stevens book on Unix Network Programming showed the way to common programmers about how to write something magical in unix/c/sockets. I can only compare this book with the same spirit.

By reading the book and practicing the exercises in the accompanying CD, it is almost guaranteed someone will not only become a good java programmer but it will also help to extend and share the knowledge of creating tools. Writing good code in java is not simple. This book clearly explains what is really needed from a user perspective to become a good programmer and team-oriented productive resource using eclipse.

The first part explains what a freely available Eclipse can do for you. This is the most comprehensive introduction I have seen so far. It will teach you the smartest way to deal with java projects from a life cycle perspective - create, test, debug and maintain. Each chapter is clear and concise. Tips and tricks are every where.

The second part explain that extending and customizing eclipse is no rocket science. It is hard in a way but definitely manageable even for a starter. Referencing eclipse api is a must while reading this part. I wish some concise reference (like O'Reilly's "...nutshell" book style) would have helped the programmer a lot.

The third part is a gem. Added to the explanation of materials of each chapter, it went far beyond. Just by practicing the examples will take the user to a commanding position. This part also makes the book a handy desk reference on using eclipse tools. I'd also recommend the reader to take a look at the eclipse.org site to check the plug-ins. A lot of them are very useful and free too.

Overall, this book is excellent. In my opinion, this book is one of the major contributors to the community in the increasing the popularity of using eclispe tools, customizing and enhancing it.

Great Organization and Well-written
This helpful and extremely well-written book is really many books in one. The Java Developer's Guide to Eclipse provides a coherent, organized, and well-written reference for using the Eclipse platform and developing plugins. In addition to the basics, the book covers such advanced topics as Eclipse Configuration Management and Providing Help. One section of the book provides a comprehensive set of exercises that enable you to get hands-on experience working with Eclipse.

The book is organized into three sections, each geared towards a different level of experience with Eclipse. While you may make use of all three sections, the organization of the book helps you to quickly find and focus on the material that you need.

The information provided with Eclipse and the Web sites that support it is considerable. The great aspect of this book is that it offers so much usable content in one convenient source, while providing additional information to supplement the online help already provided with Eclipse. ... Read more

Subjects:  1. Computer Bks - Languages / Programming   2. Computer Books And Software   3. Computer software   4. Computers   5. Design   6. Development   7. Java (Computer language)   8. Java (Computer program languag   9. Java (Computer program language)   10. Programming - General   11. Programming Languages - Java   12. Computers / Programming Languages / Java   

The Java Message Service (JMS) provides a way for the components of adistributed application to talk asynchronously, or for welding together legacyenterprise systems. Think of it as application-to-application e-mail. UnlikeCOM, JMS uses one or more JMS servers to handle the messages on astore-and-forward basis, so that the loss of one or more components doesn'tbring the whole distributed application to a halt.

JMS consists of a set of messaging APIs that enable two types of messaging,publish-and-subscribe (one-to-many) and point-to-point (one-to-one). The highlylucid explanation of the ways in which these work makes the technical content alot more approachable. In practice, however, Java Message Service isstill a book for Java programmers who have some business programming experience.You need the background.

After a simple JMS demonstration in which you create a chat application usingboth messaging types, the authors dissect JMS message structures, explore bothtypes in detail, and then move on to real-world considerations. These includereliability, security, deployment, and a rundown of various JMS serverproviders. The appendices list and describe the JMS API, and provide messagereference material.

Considering the complexity and reach of the subject matter, Java MessageService does a great job of covering both theory and practice in asurprisingly efficient manner. It's easy to see why JMS has become so popular soquickly. Recommended. --Steve Patient, Amazon.co.uk ... Read more

Customer Reviews (23)

Lightweight introduction
Java Message Service (JMS) is relatively new and this is the first book out on the subject. Others are in the offing. This book will be of more interest to Java programmers unfamiliar with message-oriented middleware (MOM) than to more knowledgeable programmers.

The first chapter introduces MOM. There are two models that a JMS provider might implement -- point-to-point (or queue) and publish/subscribe messaging. The second chapter develops a simple pub/sub example, a chat room application. The third chapter discusses messages in some detail -- headers, types, and selectors. Selectors allow a receiver to be selective about which messages it's interested in receiving. Among other things, a selector can be used to match a reply to a request.

Chapters 4 and 5 are devoted to pub/sub and point-to-point, respectively. For both, simple applications are developed for illustration. Chapter 6 discusses a variety of topics, for example, guaranteed messaging, that is, once-and-only-once delivery. Chapter 7 is devoted to deployment considerations, including performance and security. Chapter 7 discusses JMS in the context of J2EE and EJBs. Chapter 8 provides an overview of some JMS providers. One would do well to go to the Sun website instead, as it is more inclusive. There are appendices on the JMS API, message headers, and message properties.

There is the usual smattering of misprints. Then on page 112, there is a serious error. The authors say, "Unless you are doing a synchronous request-reply, you should avoid grouping a send followed by an asynchronous receive within a transaction." Even with request-reply, you don't want to group a send followed by a receive within a transaction. The reason is simple -- deadlock. The sending application sends a request and does a receive with wait for the reply. Within a transaction, the sent request is not committed until the reply is received and so, is not visible to any potential receiving application until then. Of course, a receiving application won't send a reply until it receives a request. The result is deadlock.

A good no-nonsense explanation of Java Message Service
This is a book with 200 pages of easy to read material that gets right to the point. It delivers basic knowledge about JMS but it is not any advanced text on the subject.

Chapter 1 present the basic concepts about Message-Oriented Middleware. Chapter two introduce you to JMS programming by the help of a simple code example. The size of the programming code feels appropriate and illustrates the concepts well. Chapter 3 dwells on the actual message. Chapter 4 and 5 takes a close look at Publish-and-Subscribe messaging respectively Point-to-Point messaging by the help of code examples. These chapters are built around two code examples that contain the necessary code for illustrating the subject, and no more.

Chapter 6 is about the important concept of guaranteed messaging. Chapter 7 tries to cover a lot of important topics, such as performance, scalability and security, but it only scratches the surface and does not give you much value. Chapter 8 cover J2EE and JMS. Again, this chapter is a bit thin and there are more to say about this subject. For instance, there is a very brief introduction to the use of message-driven beans in EJB 2.0, but does not give any example of how to solve the problem of consuming asynchronous messages in EJB 1.1.

The appendix is a quick reference guide to Java Message Service API and Messages. I found it quit useful after reading the book.

I would recommend this book as the first book to read about JMS. It gives you basic knowledge about JMS without being unnecessary wordy and provides simple and easily grasped code examples.

Decent Book on JMS
If you're looking to learn JMS, then this is a decently good book to get you started. One of the best things about it is that it's not very thick and it gets to the point pretty quickly. ... Read more

Subjects:  1. Computer Bks - Languages / Programming   2. Computer Books: Operating Systems   3. Computer Networks   4. Computer Programming Languages   5. Computers   6. Electronic mail systems   7. Java (Computer program languag   8. Java (Computer program language)   9. Message processing   10. Networking - General   11. Programming Languages - Java   12. Telecommunication   13. COM020020   14. COM043000   15. Computers / Programming Languages / Java   16. Java & variants   17. TEC041000   18. Java (Computer language)   19. Programming   20. Computer Bks - Languages   

The 3rd edition of the well-known reference, Java in a Nutshell, covers the essential APIs of Java 1.2, including networking, security, input and output, and basic language and utility classes. Due to the size of the Java 1.2 API, graphics and graphical user interface classes are now examined in a volume called Java Foundation Classes in a Nutshell, and server-side and enterprise programming are detailed in Java Enterprise in a Nutshell.

Though primarily a reference, the book starts off with a thorough, fast-paced introduction to Java, exploring all the key topics, including syntax, object-oriented programming, security, beans, and tools. These discussions are brief and very information-dense, and if you are buying this book to learn the language, you will probably be overwhelmed by the speed of this initiation.

This book intends to document quite a bit of Java, and it easily succeeds with broad coverage of Java programming in Part I, and API cataloging broken down by package in Part II. For example, discussions in Part I explain Types, Reflection, and Dynamic Loading. The handling of these topics takes a little over a page, but the book gives a useful overview with code examples that clearly illustrate the points made. It is one of the clearest and most concise treatments of these three topics available.

The chapters in Part II include an introduction, diagrams, and sections for each class in the package. The sections for each class can be very informative, as in the discussion of the Socket class in the java.net chapter, which includes how to instantiate a Socket object, getting I/O streams from the object you instantiated, and how to alter the behavior of sockets. This discussion, like most in this book, is brief, clear, and to the point.

If you are looking for a Java reference, this is a solid volume that will provide lasting value. --John Keogh

Topics covered: Part I, "Introducing Java," provides broad coverage of Java programming topics, including data types, syntax, classes, and objects; Java file structure; inner classes; interfaces; packages; creating and initializing objects; destroying and finalizing objects; input/output; cryptography; networking; security; threads; JavaBeans; JavaDoc; and tools that come with Java 1.2 SDK.

Part II, "The Java API Quick Reference," includes chapters on the following Java packages: java.beans, java.beans.beancontext, java.io, java.lang, java.lang.ref, java.lang.reflect, java.math, java.net, java.security, java.security.acl, java.security.cert, java.security.interfaces, java.security.spec, java.text, java.util, java.util.jar, java.util.zip, javax.crypto, javax.crypto.interfaces, javax.crypto.spec, and a final chapter, which provides an index for classes, methods, and fields. ... Read more

Customer Reviews (105)

Irreplaceable........
This book will NOT teach you Java. This book is intended for experienced individuals who need to quickly locate information concerning syntax issues or the names of methods in classes. With the exception of the chapters toward the beginning of the book there are no examples. This book assumes you know how to use the classes covered, as such, it is intended for those who have simply not explored all of the class's methods or haven't memorized the available methods and their parameters. Too the first 3rd of the book provides a very concise overview of the language in case you've forgotten some details. Additionally, you get a chapter that details the java tools included with the JDK. Overall it think it is a wonderful book! It gives you a small, usually one paragraph, summary of each class followed by a list of the methods in the class including their access modifiers and any exceptions they may throw. Reaching for this book is a lot easier than going to my computer and bringing up Sun's API documentation. I've used this book so many times that pages are going to start falling out at any time. ********Note that this isn't a replacement for Sun's API documentation as this book only covers some of the packages, not all of them. Be sure to examine the table of contents to decide whether this book is right for you.

Thank Java for giving us a reason to read such a great book.
I experienced this book at two different levels. As a beginner this guide took me through the syntax and concepts while I was studying the language. At a later stage this book was used as my reference material. Without any hesitation I have to say that this book is my Java Bible!

Like most reference guides, the beginning of this book will give you an introduction to the language. However it is definitely not a tutorial for those who are unfamiliar to the Java language, but rather a quick reference to remind programmers why certain concepts are in place within the Java language. If you forgot how or why to cast data, you can find it right here. This part of the book can also be used by C++ programmers to understand the differences between the two languages.

This book is loaded with information regarding the language. APIs, methods, tools and mechanisms are all covered with numerous short examples that demonstrate how to perform common tasks with the classes and interfaces that comprise the Java Platform.

Throughout my studies I had many questions regarding Java, but "Java in a Nutshell" never left me in the dark. I didn't need any other books, and I am sure I never will. Thank you Tim O'Reilly for giving us David Flanagan, and thank you David Flanagan for giving us, Java geeks, our own Bible.

Inexpensive Knowledge Repository
A long time fan of O'Reilly books, the CD bookshelves and this deluxe edition are one of the best ideas I've seen from a publisher. If you don't mind reading onscreen these will save you money. If you do pick this up in addition to the hardcopy simply for the search capabilities. A great reference tool from any serious programmer. ... Read more

Subjects:  1. Computer Bks - Languages / Programming   2. Computer Books: Languages   3. Computer Networks   4. Computers   5. Desktop Publishing   6. Java (Computer program language)   7. Programming Languages - General   8. Programming Languages - Java   9. Java & variants   

Customer Reviews (6)

Awesome Book!
Excellent addition to your shelf! Very straight forward and even humorous. I had some questions that I couldn't find the answers to in the book and I emailed the author directly. Was able to get response right away. Thank you for assistance, Barry, I don't think I'll fail my class any longer! :)

Great book for the beginners in the field.
The book "Beginning Programming with Java for dummies " by Barry Burd is invaluable help for the beginner in its area. The author stipulates every question, possibly occurring regarding installation Software, and many more. An easy presentation in light and humorous manner, with moderately apportioned theoretical material, makes one easy to cope with many difficult concepts. This book can satisfy the needs of a wide range of people, which are working in areas unrelated to programming or mathematics. Myself, being of non-English speaking background, found it pleasurable to read and understand. Its language does not contain slang expressions and can be considered as international. I would recommend it enthusiastically to all beginners in this field.

Natasha Pavlova (Dr. S. Gotis-Graham)

Good Java Beginner's Book!
This book is very good for people just starting to learn programming using java. Mr Burd done a good job explaining the basic fundamentals of Java language in easy to understand method. His style is good and you don't get bored reading his book. I fully recommend this book for anyone who wants to start programming in java language. Well done Barry! ... Read more

Subjects:  1. Computer Bks - General Information   2. Computer Books And Software   3. Computer Networks   4. Computer Programming Languages   5. Computers   6. Java (Computer program language)   7. Programming - General   8. Programming Languages - Java   9. Computers / Programming Languages / Java   10. Java & variants   

Customer Reviews (47)

A GREAT AND CLEAR JAVA PROGRAMMING BOOK FOR BEGINNERS
We use this book in my Java programming class and it's one of the easiest text books I've ever used. It's so easy that if I just bought it and used it myself without a teacher, I would do just as well. The authors use GREAT examples of programs, applets, and classes to use inside of programs. They also supply you with a CDROM of all the examples, java sdk 1.3, java Forte, and classes to help make programs easier including a crucial Keyboard input class. This alone should be the reason you buy this book. Another great aspect of this book is that the authors use what was talked about in each chapter in graphics orientated examples which is one thing absolutely needed to know for success in using java in the business world. In all, the best java programming book I've ever used.

A Java Book for CS Majors
This is the book required of my Intro to Programming in Java class, which is a class designed for those intending to pursue Computer Science as a major. I believe the book itself is just that: a great introduction for those serious about learning to program and then take it to a higher level with further education.

This is not an easy book to read with a light head. You cannot breeze through the code, which is explained minimally, or not at all, and expect to understand what is going on. Careful tracing and retracing of the code is what it takes me to understand some of the example programs. This said, once I've done so, I come away with a solid understanding of the concepts introduced.

Some of the chapters are especially lacking. I found the chapter on recursion to be confusing and hard to decipher until the professor gave us some solid real world examples (Russian stacking dolls) and a thorough explanation of what the code is doing. Others chapters were better than my professor in explanation, namely the chapter on loops and that on objects and primitive data.

I am taking this course with absolutely no programming experience, and am finding this book to be an invaluable complement to the lectures. However if you have no programming background and want to learn Java solely from this book, you would need more discipline than I have to do it. If you already have experience in programming, I'd imagine this book would help you to learn Java quickly and easily. If you've already done object-oriented programming some of the first chapters may be a little too basic.

Overall this is a great book for those new to programming but dedicated to through study and further education, or as an intro to Java for those with prior experience.

Had to buy something else...
This book was assigned as the text for my applications programming class. Even though I faithfully read and highlighted each section, I was still completley lost. While I normally appreciate succinct writing, this book is a little bit *too* right to the point. I don't find the explanations of key concepts to be thorough enough for a rank beginner like myself, and the code examples are not really all that helpful.

In hopes of salvaging my GPA, I went and bought Learn To Program with Java by John Smiley, and found it to be much more useful. The book is written as if you are sitting in a programming class, with fellow students who ask very lucid and insightful questions. I recommend it instead, if you are looking to be hand-held through your first Java programming experiences. ... Read more

Subjects:  1. Computer Bks - Languages / Programming   2. Computer Books: Languages   3. Computers   4. Java (Computer program languag   5. Java (Computer program language)   6. Object-oriented programming (C   7. Object-oriented programming (Computer science)   8. Programming Languages - General   9. Programming Languages - Java   10. Computers / Programming Languages / Java