5 comments about Java in a Nutshell : A Desktop Quick Reference (Java Series) (3rd Edition).

1. Avoid this book. Although there is no indication on the cover, it completely skips major sections of the language, such as everything pertaining to Sql and databases. It is organized around package names, which makes it difficult to look anything up. The index is incomplete and doesn't indicate what pages classes are actually defined on.(...)



2. JAVA IN A NUTSHELL (THIRD EDITION) is one of those computer science books that I had always been told was excellent. Professors, friends and co-workers all recommended it to me so many times that I eventually bought it soon after I began programming in Java. Having used this book as a reference on numerous occasions, I must say that it doesn't quite live up to its hallowed reputation, although it does have a number of positive points in its favour.

   The opening few chapters of the book are really good at setting the stage for the beginning Java programmer. While it probably isn't simple enough for someone who is a complete newcomer to the language, it is excellent for people who already know a little bit and require more information. The sections on Java syntax are quite thorough and understandable. The Object Oriented Programming portions are readable and informative, without bogging the reader down with endless detail. The background information on Java (the structure, the way methods/variables work, the flow of programs, etc) is all handled brilliantly. Part One of this book is definitely something you'll want to treasure.

   Part Two, the bulk of the book (Chapters 9 though 29, and covering a staggering three hundred, seventy-six out of six hundred, forty-eight pages), is devoted to what is referred to as the "API Quick Reference". It's the self-proclaimed "real heart" of the text. Unfortunately, this is the portion where the book really falls flat. What David Flanagan has done is to go through the most common Java packages/classes/APIs and cut them down to a bare listing of all their methods, exceptions, hierarchies, etc. While this covers a broad amount of information, it does not cover it deeply at all. I agree with his choice of most-used APIs, but he doesn't go in to nearly enough detail about them. Almost all of the methods are given no description; they're just named. If you are using this to look up the precise spelling/capitalization of your favourite methods, then this will do nicely. However, if you're curious as to what each method actually does, you won't find any enlightenment here. When one boils down the Java documentation this far, one finds that there really isn't much left at all. Certainly nothing that's actually useful.

   The first part of this book is first rate. It's easy to understand, well-organized and great for beginners learning the language as well as for experienced programmers who require reference material. The second part of the book is not so good. For any detailed information you require, you'll find yourself forced to consult other sources (probably Sun's own API specifications which are available for free on their webpage). Make sure you know what you're buying. The first half of this nutshell is excellent, but you'll need something else to go with it to have a completely worthwhile reference.




3. it is much better to use a jdk documentation which you can download instead of this reference book.



4. I've read the first 4 chapters as my introduction to Java. It was a struggle, but worth it.

   I'm now taking a college class and find Java a slippery beast to get one's hands around. Our text introduces snidbits that create so many unanswered questions my head swims. Reading these chapters layed a great foundation for understanding where Java's creators are coming from and why.

   There were many very insightful tips that lifted some very dense fog for me. He builds one's knowledge from the ground up. If you manage to get through it (ie: you have had lots of prior programming experience and about 5 days to read 165 pages) you are left with a pretty good idea of why the syntax and practices are the way they are. I'm sure other books are equally insightful, but this one sure says a lot in only a few words.

   Buy this book if you like to know that each sentence was written because the author had something to convey, not just because he wants another crack at clearing up the confusion he just created. Mr Flanagan (the author of Nutshell) says it crystal clear the first time. (note: He does bother to repeat a few very important concepts, but its rare).

   The remainder of the book is a library reference of selected Java packages. I'm not sure the usefulness of the list other than to see the headers and method signatures that are available. I would liken it to having a pocket dictionary - sometimes its all you need and sometimes the definition isn't useful and you have to break out the Webster.

   However, the presentation in the initial 8 chapters is so outstanding that I would give it 5+ stars if allowed. This is where to find the magical explanation to clear the smoke.




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

5 comments about Java(TM) Application Development on Linux(R) (Bruce Perens' Open Source Series).

1. Hi.
   This book covers many aspects of Java development under Linux without losing the reader in the details. To achieve that, the authors gave many references throughout the book in order to direct the reader to more in depth coverage of the subject.
   My only disappointment is not to find the hyperlink to the book's web site in introduction. Moreover, the site (www.javalinuxbook.com) does not contain much information to complement the book. For example, it would be great to find the list of all the hyperlinks given in reference in the book.
   
   This book is not intended for beginners but initiates in OOP and Linux. An excellent book of reference, well written, strongly recommended for those whishing to begin Java development under Linux and don't know where to start!



2. When first embarking on a new journey into a programming language, the average traveler might want a map and a compass to show them where they are, where they're going and how to get there. If where you are is Java newbie and where you want to be is programming Java apps on the Linux platform, then _Java Application Development on Linux_ is a map and compass you can use to get from here to there.
   
   This book is another in a long line of great technical reference books from Prentice Hall's Bruce Perens' Open Source Series. While some of the previous books I have revied from the series tended to be more in depth, this one has the benefit of starting out slow and covering all of the bases. You can know little to nothing about Java as a programming language and come out with a solid understanding of the fundamentals after the first few chapters. Anyone who has an object-oriented programming background will zip right through the opening pages, but for those that don't, spending a little more time will bring them into the ranks of the initiated.
   
   All of the programming basics are covered, from constants to strings, from arrays to variables, and all of the fundamentals and not-so-fundamentals of object-oriented programming, like classes, methods, objects, properties and polymorphism. Then the reader is steadily moved along into more involved topics, like putting your Java classes into JAR files, how to use the Java debugger, the software development kit and so on. At the end of each chapter, there is a small section on what the reader still doesn't know. The purpose of this is to keep the reader clued in on their progress, explain what is to come and keep things moving along. All of which makes for a fast-flowing read. Generally this is hard to find in a technical book, many of which tend to be dry and boring for the most part with the index being the most read section.
   
   By the end, the now initiated reader will explore programming applications for various interfaces and APIs, including Swing, SWT and JSP, and will even find out what JavaBeans are and how to use them and what JNDI is and how it can work for you.
   
   With all that said, this is a fundamental resource book for anyone who would want to learn how to program Java applications under Linux. Much of the information can be borrowed to develop applications on other platforms as well. The introduction and first few chapters of this book are extremely informative and give the reader an excellent comprehension of Java as an object-oriented programming language and all of the fundamentals he will need to go further as an application developer. The later chapters tend toward information overload, and while the information is good, some things are skipped over to save time and space. It may have been better to separate this book into two different volumes, giving the second half twice as many pages and more room to breathe. But overall, this is still an excellent technical book and adequately achieves its main goal of making a beginner application developer out of a Java layman.



3. Java was developed to be a cross-platform language. "Write Once, Run Anywhere" is the slogan, and an admirable ideal to attempt to reach. So when I first saw the title of the book Java Application Development on Linux, I expected to find descriptions of some idiosyncrasies in the Linux environment that affected the "Run Anywhere" part of the equation. What I got was a lot more.
   
   The authors, Carl Albing and Michael Schwarz, chose to create a book that is a complete guide to writing commercial-quality Java programs. They focused on how to use the tools of Linux to assist in the creation of Java programs. The book is broken up into five major parts: Getting Started, Developing Business Logic, Developing Graphical User Interfaces, Developing Web Interfaces, and Developing Enterprise Scale Software. Each chapter is self-contained, and the reader can choose what they read without losing track. Each chapter starts with a summary of what you'll learn, and concludes with a "What You Still Don't Know" section.
   
   Part I provides a 10-chapter overview of Linux, Java, the SDK's (Software Development Kits) from Sun and IBM, version control via CVS, and IDEs. The first two chapters cover a sampling of command-line Linux, plus the Vi editor to create your programs. Chapter 3 gives you a overview of the Java language, and Chapter 4 covers how the program can deal with the context in which it's running. The next two chapters cover Sun's SDK and IBM's development kit (briefly). Chapter 7 describes how to use the GNU Compiler for Java (gcj) to create native-code programs.
   
   Larger programs definitely need some form of source control, so the widely available Concurrent Versioning System (CVS) is clearly described out. For building and deploying the numerous files of a larger project, Ant provides value beyond what the make facility can offer. Finally, Integrated Development Environments (IDEs) are covered. The focus is on NetBeans, but SunONE Studio Community Edition and Eclipse are also covered.
   
   If the book stopped after Part I, you would still have a valuable addition to your bookshelf. However, Part II continues with a five-chapter discussion on how to get requirements, documentation, and buy-in; how to analyze the program and discover the objects to be created; automated testing with JUnit; storing data in databases using Oracle, PostgreSQL, and MySQL; and using the Java Database Connector (JDBC) to access them.
   
   Most users want some form of a graphical user interface (GUI) to access the program and their data. Part III describe how to create a GUI using Swing and the Standard Widget Toolkit (SWT).
   
   By far the most popular way to access programs is via a browser. Part IV describes Java Servlets and JSP (JavaServer Pages), and also talks about two Java-based web application servers (JBoss and Geronimo).
   
   Finally, Part V covers Enterprise JavaBeans (EJBs) in what the authors describe as "an almost criminally brief introduction". While it is definitely an overview, they still cover more than enough about EJBs to get you rolling. They wrap up the book with a plea for help. The book is an Open Content book, and therefore they are requesting comments, suggestions, and patch files to help improve the text and examples.
   
   I have to admit that Java Application Development on Linux is an extremely readable, very informative, and deep without being lengthy book. The tone used by Carl and Michael was very conversational. I found it enjoyable, interesting, and highly informative. The only complaint I have is that they tried to cover a little too much in a single book. EJBs definitely warranted more coverage than they provided. In all, I rate it a 4 out of 5.



4. Yes, another Java book. And this time it is specifically about developing applications on Java to run on Linux.
   
   What, Java is supposedly write once - run many so that it will work on just about any platform.
   
   OK, when you are developing something it often turns out that you do something specific that makes it rather tied to a particular platform. And if you are starting out on the development of a business application today, you're likely to at least think about doing it on Linux. So this book concentrates on combining Linux with Java. That way it can talk about the wide range of libraries, tools, GUIs, and other developmental assistance that really begins to tie the operating system together with the programming language.
   
   Probably some of the purists out there will complain, but this is a good place to start thinking about the application you need to write.



5. Java and Linux have come a long way since their respective introductions. Java is a serious contender as a platform for application development on the web, while Linux is widely regarded as an excellent platform for developing applications. For those who haven't kept current with Java development since the heady days of applet development, the myriad of Java technologies can look like a morass of car parts, musical genres, and acronyms. Java Application Development on Linux helps make sense of the current Java technologies and developments, while ensuring that the reader uses Open Source technologies as much as possible from start to finish.
   
   Part one of Java Application Development on Linux covers the Linux and Java foundations used in the rest of the book. Chapter one covers the fundamentals of UNIX and Linux by introducing Standard I/O, Pipes, Environment Variables, and rudimentary commands such as ls, find, chmod, tar, and man. Next, the authors introduce the venerable vi editor. The basic moves of vi are explained as well as regular expressions. (Lest other editor afficianados complain, other editors, as well as sed, are introduced, but not fully covered). Chapter 3 is a whirlwind tour of the fundamentals of Java and Object Oriented programming. This chapter is an admirable distillation of the concepts of Java, but by no means will it teach a rank beginner all of the points needed for full Java proficiency. Chapter 4 ties the first three chapters together by creating a simple Java program, compiling it, and reditecting input streams into the compiled program. The latter part of the chapter deals with incorporating environment variables into Java code using getProperties() and getproperty(), and with executing code via the Runtime class. Next, the book looks back at the Sun JDK, providing an overview of the Java Compiler, the Java Runtime, javadoc, JNI, and RMI, the Java Debugger (jdb), and jar. Chapter 6 is a quick look at the IBM Developer kit, and then it's on to chapters covering The GNU Java Compiler (gcj) and CVS. Chapter 9 picks up with Ant, and provides a look at why Ant was created and how to create buildfiles. Chapters 10 rounds out the first part of the book with an unfortunately dated look at Netbeans 3 and Eclipse 2 (both of which have recently released radically updated versions).
   
   Part two of Java Application Development on Linux is entitled "Developing Business Logic". Chapter 11 covers the not-so-fun portions of development: requirements gathering and prototyping. This chapter also introduces a budget analysis project used throughout the rest of the book. Chapter 12 covers Analysis and Design, while chapter 13 covers everybody's favorite part of development: testing! Chapter 13 discusses installing and using JUnit to create automated test cases. The last two chapters in part two cover using a databases and JDBC together.
   
   Part three dips into Graphical interfaces, and gives equal time for both Swing and SWT. Both toolkits are given equal time, and the Budget application introduced in part two is given a stand-alone application front-end using both toolkits.
   
   Java gained lots of traction lately on the web application server, and part four introduces Servelets, JSP Servelts, and Open Source Web Application Servers. All three of these chapters keep using the budgetting application as the basis for their examples. In part five, Enterprise Java Beans (EJBs) are introduced in the context of this same budgeting application. While the authors admit that EJBs may be overkill for the budgeting application, they give ample coverage to clarify the role of EJBs in the enterprise.
   
   Every chapter in Java Application Development on Linux includes a section describing what the authors didn't tell the reader, along with a section on additional reading. I found it extremely helpful to know what the authors didn't cover about each of the presented topics, and where to go for more information. Each topic is presented frankly, with a conversational style that makes the book easy to follow and easy to read. The book's style was so good that I found myself at the end of several chapters reading the "What you don't know" section hoping that there was more for me to digest. The authors had a large task in distilling the whole of Java and Linux development into one small book, but I wish that in future editions of the book they would have more space to delve deeper into these subjects.
   
   Java Application Development on Linux presents a broad picture of the state of Java and how Linux can play a part in developing applications under this framework. While this book did leave me wanting more, it still stands as an excellent introduction to Linux, Java, and the various Open Source tools for Java Development. Readers interested in stepping into the vast ocean of Java Development will find Java Application Development on Linux a handy guide, and a resource which they will refer to along the way.

No comments about Essentials of Food Safety And Sanitation Study Guide.

5 comments about Sams Teach Yourself EJB in 21 Days (Sams Teach Yourself).

1. This book is well organized and paced as a EJB study guide. It also covers ejb 2.0 with extensive elaboration on local interfaces, MDB and JMS. It is rich in examples and has best practices for each ejb/architectural/development topics covered in the book. Summary, Q&A and exercises sections at the end of each chapter are carefully phrased or designed to help the reader to review what's in the chaptuer. Besides its comprehensive coverage of EJB, it also covers all other aspects of J2EE (such as Servlet (Web Tier), JDBC, JavaMail, JMS, and so on). In comparison, it complements Ed Roman and Monson-Haefel's EJB books with more details on how to configure, deploy and run EJB application on Weblogic and JBoss, which (JBoss) is gaining popularity as a production ready application server among enterprises. Negatives for the book are it did not cover JCA and JAXP. Overall, it is a excellent beginner to intermediate EBJ/J2EE study guide.



2. This was the first book on EJB that worked for me. Although it
   took 1 1/2 months to warm up to all the concepts, it was well
   worth the effort. I was able to run all the examples on
   Weblogic 7.0 installed on Windows 2000 and Weblogic 8.1
   installed on Windows XP. The best practices section offers very
   good pointers for real world programming, it also proves
   the authors know their subject and are experienced in the field.
   The book also demonstrates how easy it is to start using
   BEA WebLogic Application Server that you can improve upon.



3. I completely agree with TonyGreen7. This book was a total disappointment. How are you supposed to learn such a complicated technology when have the time you are fighting your way through typos, ommissions and grammatical errors. UGH!!!!!



4. I dont think there was a single program that didnt have bug in it. Bugs in the programs. Bugs in the deployment descriptors. Typos and wrong statements in the text. You need to check each and every program, line-by-line, against the updated code which must be downloaded from SAM's website. Your weblogic 30-day trial licence will expire before you finish slogging through this book.



5. The book helped me to get fast into EJB, a lot of examples and easy language, it also covers some other J2EE concepts like JMS and JDBC.

4 comments about J2EE Web Services on BEA WebLogic (HP Professional Series).

1. If you are interested in developing web services on the BEA WebLogic platform, buy this book. It provides and excellent introduction to both web services and the WebLogic development tools. The examples are real world and explained in an understandable manner. The text, however, does not provide deep detailed coverage of web services specifications or implementations so I would not suggest this should be your only book on web services. For in depth web service coverage in a J2EE environment I recommend you combine this book with Richard Monson-Haefel's "J2EE Web Services".



2. This book is excellent for those developers and even architects looking to implement real-world web services. It gives a solid overview of web service technologies while also showing how the BEA platform can aid you in bringing those services to fruition. There is not an area that is left untouched. Finally a book that is gorunded in production services and experiences.



3. This is billed as a beginner/intermediate, and practical book.
   I would say it's more intermediate.
   
   It reads as sections of theory/definition, with a small example. I liked the first couple chapters, and I think it would be useful for a manager or analyst to get an overview of the terms, but I haven't found the rest to be that useful. It doesn't flow very well, and is hard to retain information.
   
   What does stick out in my memory from the text is that Weblogic and Weblogic Workshop are powerful, natural, and easy...
   
   These are the parts of the book that I found useful, well written, and/or just liked:
   Page 41 on Classloader
   Chapter 6 on WebServices
   Page 249 on Security
   
   (I did development on Weblogic 4.5-6.0, and am returning to Java from C++. I've read the first 80% of the book, and skimmed the last 20%.)



4. The content is obsolete and it does'nt worth anything now. Reading a BEA Weblogic Developer Guide should be more helpful than this book.

5 comments about Core Java Data Objects (Core Series).

1. In the march towards higher levels of abstraction and more powerful coding approaches, Sun came up with Enterprise Java Beans several years ago. But despite one's best efforts, instead of focusing on writing business logic in a modular, fully encapsulated way, you often also have to deal with reading and writing to a persistent format; usually a relational database. The gritty details of the impedance mismathc between your [hopefully] object oriented approach and the latter might eat up too much of your time.

   Realising this, Sun devised Java Data Objects. The book describes their main promise, which is to hide away the details of persistence. The big gain is in increasing the potential developer audience, as compared with EJBs. And you have less need of expert knowledge of RDBs. Previously, that was often a de facto requirement. You can now focus on the business logic. The second gain is shown in the JDO code examples, which are often cleaner without the persistence details. Of course, any realistic business logic will have more complicated details than the simple examples in the book, but at least persistence can be pushed offline.

   Last year, Robin Roos wrote "Java Data Objects" [also by the same publisher]. At that time, JDO was just getting started. Now, Sun has moved it deeper into J2EE. There is a lot more support for transactions and JDBC. JDO is no longer a speculative fling.




2. A good presentation for both architects and programmers, about JDO. The author explains the issues with Object oriented programs and relational databases then goes to show how JDO attempts to solve this mismatch (otherwise know as object relational impedance mismatch) Note from this book you will find that JDO is a standard to be implemented by vendors so that developers need not know varying interfaces object relational mapping frame works. JDO also has its own query language, which is not as powerful as SQL especially if you have complex joins or aggregation (OLAP) so, don't drop your JDBC yet! Well written with little fluff. It's not a O'rilly style code code book, it has the write amount of theory and code mix



3. Java Data Objects (JDO) is an alternative to JDBC that allows you to treat rows from a database as Java objects. The simplicity of JDO removes many of the complications involved with developing JDBC applications. This book does a decent job of covering the JDO specification and explaining how to properly use JDO. The book starts with an introduction to JDO and shows some examples of how to write code with JDO. The section on the object lifecycle isn't clearly explained having too much concentration on lists and not enough on explanations. The following chapters do a decent job of explaining the pieces of JDO. In addition to the basics, the book covers using JDO in a J2EE environment with a look at Enterprise JavaBeans, security, and transactions. A later chapter shows a comparison of JDO and JDBC. The authors wrap up with some tips, take a look at what might be coming in the future, and show a case study.

   The authors do not look at any JDO implementations, which leaves their explanations in essence, hanging in mid-air. Although they show how to code in JDO they don't show what a programmer needs to do to hook their code in to a database. This means that without further reading, you can't run any of the examples supplied. Although the book is not bad and might be worth a read, it is not as clear or as well written as one might like.




4. Name of the book: Core Java Data Objects
   Authors: Sameer Tyagi, Keiron McCammon, Michael Vorburger, and Heiko Bobzin.
   Published: Sun Microsystems Inc.,
   Publishing Date: Winter 2004.
   City: Upper Saddle River, NJ

   5=Well done! This book will be a valuable teaching and reference tool.

   4=I would recommend this book to someone interested in its topic.

   5=A complete reference. I would not need any additional reference on this topic.

   Write a minimum of three paragraphs describing the different aspects of this book.

   This is an excellent book on Java data objects for people who have worked with databases for a long time. the authors have taken the time to explain the concepts of JDO and how it can be implemented with fairly simple examples that are more real world.

   the authors also explain about the security aspects in JDO that need to be considered while implementing a real world situation. they also explain the differences between JDO and JDBC for people who have worked with JDBC and ways to implement JDO.

   the authors towards the end of the book explains how to explain the implementation of JDO for J2EE and enterprise solutions. they also provide tricks and tips for effective jdo implementation. a real world case study is presented for people who want to implement this solution.

   I would recommend this book to anyone interested in learning java data object.




5. Java Data Objects (JDO) is a persistence framework to save Java objects to a datastore. The example code shows you how to create, read, update, and delete a persistent object using the JDO API. The book goes through the JDP API, especially the five main interfaces needed. The metadata, an xml file, that is needed for JDO is make clear in one chapter and the various options in the JDO xml file are explained to show you how to store your type of objects. The explanation of first-class and second-class object could have been longer. It seems like a more important topic and the brief mention in the book.
   
   Part of the book shows you how to develop applications with JDO and the architecture scenarios where you should or should not use JDO. The third part of the book covers using JDO and J2EE application. The authors argue that JDO in most situations offers a better solution over EJB entity beans to store your objects or to use JDO and some direct JDBC. Practical examples showing how JDO can be applied to existing applications
   
   The authors also have a real world case study that provides best practices and tips for your projects. The only part missing from the book, are using JDO implementations, which makes the examples impossible to test without using an implementation from one on the JDO implementers. I would recommend this book for anyone trying to learn JDO, but more information would be needed to use an actual JDO implementation.

4 comments about Late Night Advanced Java.

1. Late night Advanced java is for the programer that does cool thing all though the night. It will show you have to work with sockets and other networking things and it is also great for the new programmer in the block



2. I found this book rather disappointing. Several of the examples are plain wrong, I wonder how the author ever got them to work. The IDE toolkit reviews are interesting, but went out of date very quickly after publication so are of amusement value only. Finally, it only deals with Java 1.0. JDK 1.1 came out fairly shortly after I bought the book, and with no information about the new event handling system, the book was unfortunately obsolete.



3. This is a great starter to Java. Explains the concepts of object oriented programming better than any other book on Java I have seen. Also doesn't speak in cryptic terms like many other Java books do. A great start to Java programming!



4. I bought this book on the run, and just sat in on my shelf. But then I needed write some threads in Java and I found this to be the best book around for this subject. Very clear. (My threads work great!) The chapter on sockets is also most useful.

1 comments about Learn Java In a Weekend (In a Weekend (Indianapolis, Ind.).).

1. While I havn't finished going through this book yet, it appears to be a very good resource for someone trying to get a jump on Java.
   
   While not as detailed as some of the other resources out there, there are plenty of coding examples to illustrate and prove different programming concepts. The books takes the learn by doing approach and I like that.
   
   There is one reason I gave this book 4 stars and that is spelling errors. Whiel there aren't a lot of spelling errors, there are enough for me to notice, and I'm not big on spelling. However, when you are writing/producing a book for something as syntax-specific as a programming language, you better be sure to have everything right.
   
   Overall, a great book and a good teaching/ self-learning aid.

No comments about Introduction to Programming with Java.

No comments about Java Testing and Design: From Unit Testing to Automated Web Tests.