5 comments about Java Enterprise in a Nutshell (In a Nutshell (O'Reilly)).

1. Java Enterprise in a Nutshell tries to do the impossible - fit Enterprise Java into a nutshell. I don't think it matters how big of a nutshell you have, it would be a truly impossible task. Farley and Crawford, though, do a nice job shoe-horning as much Enterprise Java as they can into an 800+ page book. They go over many topics including all the J2EE standards like EJBs and JSPs to open source tools like JUnit, Cactus, and Hibernate. The book goes into enough detail to get more than just the gist of the subjects, but not so much detail to overwhelm someone looking for information on a particular topic. The book also has relevant code sections for the various topics outlining how that technology might be used. Overall, a compact, clear, well written reference.



2. Jim Farley and William Crawford's Java Enterprise In A Nutshell: A Practical Guide packs in tutorials on a number of enterprise Java tools, offering new material covering Xdoclet and Java 5.0 Annotations, JavaServer Faces, and the Hibernate API. Also included are open source testing and build tools, tips on writing SOAP-based web services, J2EE security issues and operations, and much more. Serious Java developers will want this as an essential desk reference.



3. Do you have all of the tools you need to build enterprise-class applications? If you don't, then this book is for you! Authors Jim Farley, William Crawford, Prakash Malani, Justin Gehtland and John G Norman, have done an outstanding job of writing the third edition of a book that provides a pragmatic introduction to the latest release of Java 2 Enterprise Edition (J2EE).
   
   Farley, Crawford, Malani, Gehtland and Norman, begin by presenting the general model that J2EE supports for assembling components and resources into full services or applications and how they are deployed to their runtime environments. Then, the authors demonstrate the basic techniques that are used to write servlets using the Sevlet API, including some common web development tasks such as cookie manipulation and session tracking. Next, they look at JSP from a Java programmer's perspective as opposed to that of a web site designer. The authors then provide a whirlwind introduction to programming with JavaServer Faces. They continue by providing a basic introduction to Enterprise JavaBeans. Then, the authors take a quick look at Sun's Java API for XML Processing (JAXP) Version 1.2, which provides a standardized approach to processing XML files in Java. Next, they focus on the JDBC 3.0 API, which includes a modest yet variable set of new features. The authors then provide an overview of transport and application security as well as defining the important concepts of authentication and authorization. They continue by focusing on developing, deploying, and using web services in your enterprise applications. They also examine the Java Remote Method Invocation (RMI) API--Java's native scheme for creating and using remote objects. Then, the authors look at an overview of the CORBA architecture and how it allows you to create, export, access, and manage remote objects. Finally, they give a brief overview of transaction terminology, including ACID properties and transaction isolation levels as well as the concepts of local and distributed transactions.
   
   This most excellent book provides concise, fast paced tutorials on a broad range of enterprise Java tools and APIs. More importantly, this book is both a practical guide and quick reference for Java programmers who are writing enterprise applications.



4. I'm very happy, i have got "java in a nutshell" too and I was very satisfied of my purchase, the book is simple and written very well, a "must" for a Java programmer.



5. Warning to all buyers, the 3rd edition of this book does not include the J2EE library reference. While I realize this information is available online, having a printed form of library references is the primary reason I buy the "in a nutshell" series. Included in this book is a very general overview of various enterprise technologies, which unlike the very useful language reference include in other "in a nutshell" books, seems too broad and shallow to be useful. Any developer serious about working in JSP, for example, would be better served buying a book on JSP. Admittedly I just received this book so I can provide a cursory commentary on the usefulness of the material, but the lack of library details alone would have made me not purchase it if I was browsing in a store.

5 comments about JavaScript & DHTML Cookbook.

1. I still have the first edition of this book but other than perhaps missing the chapters on ajax it's not outdated at all. This book has saved my life several times already. Almost every time I am looking to solve a tricky problem in javascript, I find that this book contains a well explained chapter with the exact solution that I was looking for. The authors often make a point of going through multiple iterations of a solution, to demonstrate what needs to be modified to support certain browsers, and at the same time ensure that the reader actually understands the code too.
   
   This is a great book for experienced javascript developers who want to save time by using tried and tested code to solve common problems, but at the same time understand that code too.



2. I wouldn't buy this book if you are going for aesthetics for you website. I wouldn't buy it if you are a heavy programmer either. Its a good "middle" book for just general roll overs, browser detections, and other javascript functions for form validation. Its a little small.



3. I really like this book. The format of each technique demonstrated is
   
   Problem- Solution- Discussion
   
   The nice thing is that you can get a quick explanation from the solution, and a more in depth response in the discussion. The author presents complete code which is easily built upon and customized.
   
   I knew a bit of Javascript when I started, but I think this would be an excellent book even for a complete beginner.



4. Like most web developers, I typically will reach for one of the many JS libraries when it comes time to add client-side enhancements to my web applications. This is usually the obvious choice for the sake of saving time on projects, and keeping costs down... but quite often, many libraries are simply overkill for a simple little js/dhtml enhancement.
   
   As such, that is what lead me to this book. I was hoping the cookbook format would give me some fresh ideas on doing some simple js/dhtml work and it most definitively delivered.
   
   Perhaps the most valuable parts of this book for me were the aspects of working on the DOM. Additionally, I always enjoy reading different techniques for dealing with client-side form validation.
   
   To me the coverage on loading dynamic data/ajax was good, but I still think that when entering into that realm of JS, it is usually time to deploy one of the libraries I mentioned earlier.
   
   All in all this has become a valuable resource that I often refer to during my daily work.



5. The book doesn't go in-depth in it's explainations. It is written more for the seasoned script writer and not the beginner. I found it very confusing and not enough detail to be of any use to me. I preferred "Javascript, Demystified".

3 comments about Practical JRuby on Rails Web 2.0 Projects: Bringing Ruby on Rails to Java (Expert's Voice in Java).

1. Over the past several months I have spent a lot of time searching the internet for information on JRuby, specifically looking for ways to have Ruby on Rails host Ruby powered applets. I thought I been fairly successful at gathering information until I read this book, and realized how much information I had missed. If you are working on building a production quality application or just want to learn what you can do with the current state of JRuby on Rails, try this book. It will help get you on track right away while avoiding many of the 'gotchas' that come with using Rails on JRuby.
   
   You will need to have a good understanding of Ruby, and prior experience with Rails would be very good too. I did encounter a few issues where a few commands listed in the book did not work, but JRuby and Rails being actively under development make problems like that unavoidable.
   
   This book would make a good companion for the Pragmatic Programmer's Pickaxe book as well as their Agile Development with Rails book. The projects in this book are definitely more fun than the store in the Agile Rails book.
   Agile Web Development with Rails, 2nd Edition
   Programming Ruby: The Pragmatic Programmers' Guide, Second Edition
   
   Finally, remember that one of the best ways to support open source projects like JRuby is to buy the book (written by a core developer of the project).



2. I am not in this book's target audience. Whereas the book is aimed at experienced java developers who are just getting started with rails and want to take advantage of JRuby, I've rarely touched Java but have lots of ruby and rails experience and am interested in JRuby mainly to see where I might be able to take advantage of java libraries, or ship my ruby apps into new contexts. In that respect, the book was helpful but there's probably space for a companion volume for people like me.
   
   The book takes a measured pace, introducing Rails early on and then building in different components from the Java world as it works through four different projects. Use of JDBC within a rails app, calling ruby code from Java, deployment strategies, packaging a Rails app as a .jar that can be dropped into an application server, and making use of java for interfacing with SOAP web services are all covered.
   
   Readers will probably need to spend some time experimenting with each feature to really get comfortable with them, but the book works well to get you started and point in the right direction. The introduction to Ruby and Rails is a case in point, as Ola dives right in to his examples after a brief lead-in. That may work well for experienced developers who will enjoy exploring the accompanying code, but it is worth being aware of.
   
   It did feel like there were some missed opportunities later in the book, particularly in the final project, to introduce more of Rails' "RESTful" features since that example really invited that style of design, and it would have been interesting to have some discussion of the pros and cons of treating the libraries built to interface with external services as models within a rails app, making the interface more transparent.
   
   I'm also not quite sure where the "Web 2.0 Projects" line in the title comes from. The final project interfaces with amazon web services, which I suppose might get thrown onto the "web 2.0" bandwagon, but don't go into the book expecting a series of stereotypical "web 2.0" projects. It's an introduction to JRuby on Rails for Java developers, whatever approach to the web they may be taking.
   
   JRuby is a really exciting technology that promises to help developers take another step towards picking technology based on their projects, not just the platforms their organisations may have standardised on over the past decades. If you're a java developer wanting to learn how to make use of JRuby and looking for some help to get up and running, this book is likely to give you just that.
   
   Disclaimer: I was sent a copy of this book for review by the publisher.



3. Have you had any experience with Ruby or Rails? If you have, then this book is definitely for you. Author Ola Bini, has done an outstanding job of writing a book about four technologies: Ruby, Rails, JRuby and Java.
   
   Bini, begins by giving you information about the technologies covered, why they should interest you, and an overview of the book. Then, the author shows you how to install everything you need for the rest of the book, including all RubyGems you'll be using. Next, he describes what parts it contains and things that are good to know when doing Rails development. The author also introduces many of the more practical details of Rails in the process. He continues by looking at the databases that JRuby on Rails supports. Then, the author focuses exclusively on the syntax and usage of JRuby's Java integration features. Next, he shows you how create most of the Rails code needed for the CMS application, but stubs out all rendering functionality. The author continues by showing you how to complete the CMS application by adding all the rendering functionality and also taking a look at a few alternative approaches. Then, he shows you how to use JRuby from inside a J2EE Enterprise Bean, implementing the functionality of this bean in Ruby. Next, the author also details deployment options for a JRuby on Rails application, how regular Rails deployment usually works, and how to make the situation much better with JRuby. The author also looks at the options available to consume web services with JRuby, and implements a library to search for books at [...]. He continues by showing you how to create two different libraries for JMS interaction. Finally, the author shows you how to contribute to JRuby or its surrounding projects.
   
   This most excellent book can offer you many possibilities if you use JRuby on Rails. It will help you create your first application with JRuby on Rails, and get it into production.

5 comments about Beginning Cryptography with Java.

1. Cryptography is still a delicate issue with a lot of people. There are those, especially in certain law enforcement agencies, who believe that access to stong encryption should not be allowed in the hands of the general public. Indeed, there are export regulations that define encryption technology as munitions. ==At the other end of the scale, there is the simple fact that without secure data transmission, web based electronic commerce would simply be impossible.
   
   This book is on the use of standard Java encryption libraries. This book is written for people who are Java developers and are trying to make use of cryptography in their applications. It presumes that you are familiar with the Java language, but it does not assume you have any familiarity with the encryption APIs. The book covers the recent updates in the security APIs with J2SE 5.0.
   
   This book is very good from the programming point of view, it does not have a lot of history or the background technology of how encryption is done.



2. Whether it is complete or not (of course, it is not), I would challenge anyone to point at a single alternative book covering Java cryptography at a greater level of details. The style is clear, coverage of ASN.1 is very helpful, and selection of BouncyCastle open source cryptoprovider is the most natural one. Lots more of details and code samples can be found in Bouncy Castle javadocs, but to navigate them without conceptual understanding of Java security in general and BouncyCastle implementation in particular, gained from the book like this one, would be a nightmare.
   
   "Inside Java 2 Platform Security: Architecture, API Design, and Implementation (2nd Edition)" would be another book to recommend, for general overview of Java Security Platform, and, also, to make sense of Java Cryptography Extension (JCE) APIs standardizing access to cryptoproviders' (such as BouncyCastle) libraries. But, of course, the two books have very little overlap.



3. This book does a good introduction but the book needs an update to J2SE 5.x security updates. I like Core Security Patterns by Steel, Nagappan, Lai covers a lot more details on Java security apis than this book.



4. By anyone's measure, cryptography is a dry and dusty subject but Hook has made it a pleasure to read this book both by trying to keep the tone light and having such a deep and thorough understanding of the topic that the discussion is effortless. While he moves through the subject matter briskly, his mastery of the area means that it's elegantly structured and easy to follow.
   
   All the Wrox books seem to follow a pretty rigid format and I felt sometimes that had the author been given a little more flexibility there, it could have flowed more easily. That said, the consistent organisation of the book makes it easier to use as a reference.



5. This book is the best choice if you need to initiate in the use of java crypto API (as its title claims) and it informs extensively about Bouncy Castle crypto API (which I also recommend).
   
   Definitely a good book.

5 comments about Dojo: Using the Dojo JavaScript Library to Build Ajax Applications (Developer's Library).

1. I was a little disappointed in this book, but before I go on to the reasons let me explain what I am looking for. I am not new to programming, web development, or writing fairly complicated applications with Javascript. I am already fairly familiar with toolkit such as Ext and Dojo before the version jump. I was hoping this book would be a good reference and guide to working with the features of Dojo. I am not as interested in "dojoifying" web pages as I am in creating Javascript applications that heavily integrate with Dojo. This book may be decent for a web developer that wants an introduction to adding Dojo to web pages, but for a software engineer that wants to really get in depth in Dojo this book seems fairly week to me.
   
   The book has 316 pages and is broken down into 3 sections.
   
   Section I is called "Dojo a Tutorial." This walks the reader through a standard web form implemented without Dojo and then the process of switching to Dojo Widgets and simple client/server communication. (63 pages)
   
   Section II is "Dojo Widgets." This section is a decent reference to many widgets including the layout widgets which get their own chapter. It includes HTML Markup Examples and Javascript constructor examples. I really like these, but they usually seem to be very basic. It also has nice pictures of many of the widgets and layouts to help you understand what they are. I like this section, but unfortunately it is limited to the core features of each widget. The examples are pretty bare, and many of the non-essential features are left out. I do see this being one of the more useful parts of the book, but I really wish there was more depth to it. (121 pages)
   
   Section III is "Dojo in Detail."
   This contains a lot more of the meat of the book, but everything remains pretty lightweight. Some examples and references are given to the Dojo API and various helper function included in Dojo. There is some talk of JSON, event handling, XMLHttpRequests, and testing. This is all good stuff, but it really lacks depth. Everything just seems to brush against the surface. It still is essential and will help someone get started, but I don't think it will take you very far beyond that. (112 pages)
   
   
   I have only had this book a few days now. I am really glad that books on Dojo are starting to come out. I haven't yet received any of the other new Dojo books, so I can't compare them. This book is alright for getting started and for a light reference to common features. My big complaint is the lack of depth.
   
   I wish there were more examples and more details of the features and internals of Dojo. A chapters on making your own widgets instead of a 3/4 page mostly irrelevant section would have been nice. More details on customizing and overriding Dojo's CSS to make your application look the way you want it to would have been great. I think Dojo's grid feature deserves a chapter since it is something that so many applications can take advantage of. There are many things of this sort that the book either left out or just lightly touched.
   
   Overall I'm giving this 2 stars. It's alright, but it's not what I need. I don't think this book contains nearly enough depth to help people far along into building Ajax Applications. It is a good intro and a reference to basic features. It can be helpful to a web developer looking to add some Dojo functionality to a site. For the serious user though this book really doesn't have enough content to take you very far into using Dojo.



2. This book provides a good introduction to Dojo. It answers these questions:
   1. What is Dojo?
   2. What can Dojo do for me?
   3. How can I start using Dojo right now?
   
   You've probably created at least a few (if not many) web forms to gather input from your users and thought "Shouldn't there be an easier way to (insert your complaint here)?" The author goes through a list of these common gripes and shows how you can tackle each one with Dojo. In the beginning, he highlights a few key areas - such as form widgets, validating fields, and form submission. Once you begin to grasp the power and usefulness of Dojo, he goes through a deeper look into all the widgets (form, layout, and specialized) and the base Dojo libraries (string utilities, AJAX utilities, event handling, etc.)
   
   This book is not a complete reference to all things Dojo, but it does a great job of focusing on the common and most used features to get you started. This approach allows you to wade into the Dojo pool at your own pace rather than diving into the deep end and getting quickly overwhelmed by the total package that Dojo offers.



3. "Dojo: Using the Dojo JavaScript Library to Build Ajax Application" is a book for developers. You should know JavaScript and HTML well before starting. There are three main sections of the book which were so different to the point where I thought I was reading three separate books.
   
   The first part rips apart an HTML form then shows how to use Dojo to improve it. I liked the attention to accessibility along with error handling and validation. Dojo was introduced in pieces through example. Except for a couple overly long examples, such as a full page of the HTML source for the 50 states, this section was good. Things build up slowly and clearly so long as you are willing to suspect disbelief about how Dojo works.
   
   The second part introduces Dojo widgets with a picture, API description and examples. Except for the picture, it seemed very similar to the API. This part of the book didn't add much value for me as I can look at the API and examples online.
   
   The third part gets good again. It goes into the details of how Dojo works and some more advanced concepts. It also goes into history and the problems Dojo solves. It was nice having this later in the book so the beginning could be more substantial. I did like how the author went from high level to low level - both with the three parts and even within part three itself. Some pieces stayed a bit to high level such as the AOP and object discussion chapters.
   
   Overall, I was mixed between the three books. The first and third were good and the second I wouldn't pay for.



4. The book is a good book on getting you stated in Dojo and the examples are good. The book though seems a bit rushed to market there is errors in the code everywhere I seen typos to just completly wrong code in the book. I would have rated this higher but the errors are a problem if you try and follow the code in the book. My suggestion is you need to download the code from the authors website. Follow that code instead. I have read the other dojo books and they have a simular problem. Dojo is very powerful and there just isn't very many people to review the books for mistakes. If you looking for documentaion on Dojo and you do a lot of server side programming then it is worth buying this book as it was meant for you..



5. This is a very good introduction to Dojo. If you have not used any other Ajax toolkit, and you want to learn Dojo, then this is the book for you. At the moment, this is the easiest to understand tutorial of Dojo. Unfortunately, it does not tackle DojoX very much, which contains some modules that are very useful, like the Grid. Anyway, the perfect companion to this book, like other Dojo books, is the Book of Dojo, found in Dojo's website.

5 comments about Building Web Services with Java: Making Sense of XML, SOAP, WSDL, and UDDI (2nd Edition) (Developer's Library).

1. I am still wondering why the authors don't provide all the code, since the book describes an application and that should have been tested and the code is there. Just a few wsdl files don't help very much.



2. The writers either do not understand the topics, or they want to confuse the readers intentionally. You will find their writing style extremly annoying. They use the Skatestown(??) example to mislead the readers whenever they need to explain something. I dont know how such a bad written book can make it out to the book stores. If you buy this book, it will be the biggest waste of money.



3. This book has helped me immensely in implementing some really intense production quality data interchange across systems using web services.
   
   This book will quickly help you understand the entire XML stack of technologies that you will need for Web Services.
   
   The authors have uniquely enabled the readers to develop an understanding of the underlying technologies that make up the web services. Certainly expect to put in some effort in understanding the content.



4. The problem with Learning Web Services is just one - there is too much happening..the technology has grappled everyone's attention and a lot of Organizations are on it..
   A beginner to web services just doesn't know where to look..strong foundations give 'empire estates', this book does just that
   The primer on XML was one of the best i ever read anywhere and i am a big fan of Dr.Google, the clarity of the authors on WSDL Element model is very informative. All in all - if you need a book to trace Web Service concepts and build your foundations - i would strongly refer this book.
   
   If you are looking for a quick reference/book to get started in implementation you should look elsewhere..Sam's 'Teach Yourself Web Services in 24 Hours' is a good choice..but then i believe that this book is definitely worth a reference because it goes a distance conceptually.
   Kudos to the authors



5. Without a doubt one of the worst computer books I have ever bought. The intent of buying a book about programming is to actually learn programming. I have fought the XML section until I have a screaming headache with very little accomplished. So far I have found it impossible to get the so-called examples to run. The source code is not available from the publisher in spite of what others may tell you. Yes, there is a file to be downloaded. However, it has almost none of the source code in it. For example, it only contains the source code for one .jsp file for the entire 2nd chapter. The writing style is practically incomprehensible, jumping around all over the place without ever finishing anything. There are nine authors listed on the cover. Perhaps that is why this book is such a clusterf#@k. How did this thing get to a 2nd printing? STAY AWAY FROM THIS BOOK. I cannot stress that enough.

5 comments about Algorithms in Java, Parts 1-4 (3rd Edition) (Algorithms in Java).

1. This is an excellent book. Robert does a great job leading you through the fundamentals of algorithms and algorithm analysis. The visualizations are very well done. In particular the sort algorithm coverage is very well illustrated and described.
   
   The best parts of the book are sorting and searching. A wide variety of algorithms are explained and demonstrated in detail. The code is solid and the writing is very good.
   
   This is the set of Java algorithms books.



2. I have the dubious distinction of having taken a class that used this book as it's central text. The illustrations are great. The explanations of algorithms and general algorithm design concepts are clear. The code, however, is neigh unreadable in a lot of places.
   
   This was a huge problem for me, as I had a lot of difficulty seeing a clear mapping from the concepts explained to the code examples. Sedgwick's code examples often build on previous ones to the degree that they are not understandable on their own (this is especially true with the graph algorithms in part 5). If you try to use this book as a reference you will find yourself digging much harder than you would like in order to understand code samples that are actually quite simple. You could see how this might make a programming based course difficult.



3. Another reviewer gave this book a one star rating citing that the book falls short on practical examples.
   
   In light of that, I'm concerned that other readers might overlook what, in my opinion, may be one of the most comprehensive and well written introductions to graph theory and graph algorithms that there is, and certainly one of the best that I have personally come across thus far.
   
   Recently I took on a project wherein I needed to solve a shortest path problem for a particular kind of graph. I am not a specialist in graph theory and needed practical information that I could utilize immediately. For me, this book fit the bill and was a godsend.
   
   It is true that I already had a practical real world application in mind before I even knew of this book but this book has exceeded both my needs and expectations.
   
   It is easy for me to understand how you may not initially see the practical value of the information being presented, if the sole reason you're studying this book is simply because it is a part of your college curriculum. I think, however, that that does not lessen the value of the book, especially for those of us who do have practical applications for the material.
   
   If you are looking for an informational resource for a real-world problem related to graph theory, you would do well to consider this book.
   
   The book does actually open by citing several practical examples of areas where these algorithms can be applied, although, perhaps the reader who assigned the one star rating may have appreciated and benefited from a case study.



4. I give this book 5 stars for everything but the Java code, and 2 stars for the Java -- 4 as a weighted average.
   
   Regarding the code, the authors flout standard Java conventions, which makes reading the Java code tedious for anybody with a lot of Java experience.
   
   Things like uppercase fields and parameter names are only minor annoyances, to be sure, but so is ReAdInG TeXt LiKe ThIs AlSo JuSt A mInOr AnNoYaNcE, and there is no reason to not write code using the conventions of the language you're writing in rather than the conventions of the language your book was first written in or your own arbitrary conventions.
   
   Having said that, I have no other gripes, and the book has much else to commend it.
   
   The prose is very clear and exact. Whenever I found some description or definition confusing, a careful re-reading and consideration of every word included always cleared up my misunderstanding. This is not one of those books with sloppy definitions that confuse you if you really try to understand why every word in a definition is included.
   
   The typesetting and typography is very well done: the pages are easy to read, with good contrast, and there are large margins for writing notes, summaries, and the like. There are many very helpful diagrams that illustrate pictorially the data structures and algorithms under discussion. Lastly, the exercises are at just about the right level for the intended audience.
   
   In summary, if the CJava code were replaced with pseudo-code or idiomatic Java, I would give this my highest recommendation, and even with the many C-isms, I still very much enjoyed and benefitted from reading it.



5. [...]I have at least half of both volumes, and it really seems to me that there are real problems here with the exposition. Let me see if I can elaborate.
   
   Here is an actual sentence from the book-
   
   We construct a symbol table that is made up of an ordered array of keys, except that we keep in that array not the key, but an index into the text string that points to the first character of the key.
   
   Consider that there are two possible conflicting meanings of the sentence fragment :
   
   ...an index into the text string that points to the first character of the key.
   
   In the first meaning, there is an index that points to the first character of a string which string has the property that it, in its turn "points to the first character of the key". (a String is engaged in pointing and so in the index.)
   
   In the second meaning, there is an index that points (into) a text string and in fact that index points into the FIRST CHARACTER of that text string, and that first character the index is pointing to, well, that is the also first character of the key. (only the index is pointing; the string pointeth not.)
   
   OK so how do you describe what's missing here? At least the disambiguating use of commas, at least. It's as though he likes to write in subordinate clauses, but thinks it's economical to leave out the punctuation (which, it is true, there are no hard and fast rules for).
   
   So it's just sentence after sentence after sentence like that. Sometimes you can understand what he's saying. Other times, really you just can't. IF each sentence has 2 (or more!) possible interpretations, and each sentence depends on your understanding the last (as is the case- he never says the same thing in two different ways), then you get this ambiguity growing at the alarming rate of x^2, an observation the author might enjoy.
   
   As the other reviewers said, the code is a C programmers attempt to write in Java. This never goes well.....
   
   
   But the fact remains it is still the most accessible and thorough coverage of some of its subjects. So what are you going to do?
   
   I don't get the impression he is deliberately bartering in obscuratism, it's just that this book suffers (and so will you) from a lack of editing, a lack of reviewing and feedback by genuine, unaided learners etc. etc.
   
   You might want to check other people's lists for alternatives. Or not. Perhaps that passage was perfectly clear to you.
   
   

5 comments about Assembly Language and Computer Architecture Using C++ and Java.

1. I rank this book at the same level as the Patterson/Hennessy book on computer organization. P/H is more advanced on the hardware side (perhaps too advanced for a first course in this area) but much weaker on the software side. Reis' book is better for a first course. The software that comes with the book is well designed and works well. It allows you to work with the computer at both the machine and micro levels. I've been using the Linux version. Versions are also available for DOS, Windows, Sun Sparc, and Macintosh OS X.



2. This book is the best book I've seen in assembly language/architecture. It's very clear, thorough, and concrete. It is really superb in how it teaches system concepts. And it shows how C++ and Java works, in addition to how computers work. It has a great chapter on the JVM. It also covers the SPARC and the Pentium. By means of the included software, the reader can design, implement, and test new architectures.



3. This is one of the greatest books about assembly you can buy...
   
   I will tell you why:
   
   The most of the books (e.g. 'Assembly Language Master Class' of Wrox) which you can buy about assembly are about topics like 'how to paint a bitmap on the screen', 'how to write to a file', 'how to read a character from the keyboard', and so on.
   
   This is nice if you only want to know some little tricks and learn (nearly) nothing about assembly.
   
   If you want to learn something about assembly buy this book! This book covers nearly everything you can imagine in depth.
   
   The nice thing is that is starts like a typical B.Sc computer science computersystem/architecture class: what are numbers, what's hex, what's binary. What about negative numbers? This is a really nice book for someone without formal CS education which want to jump to that level (and beyond).
   
   It covers number theory (hex/bin/etc), Logic units and ALU, etc. etc. This book covers really everything: Virtual Memory, OO programming in Assembly (yeah read it right), different processor architectures, instruction sets, codegenerating by compilers, writting an assembler (yeah cool! 'an' not 'in') etc. etc.
   
   So: if you are looking for a tips and tricks book look somewhere else. This book starts pretty easy, so a lot of people can read this text, but after you finished this 800 page pounder you will have more insight in low level programming than a typical B.Sc/M.Sc in Computer Science (like me).



4. This is probably one of the best computer architecture books I have ever read. The thing I like about this book is that Reis does not fall into the same trap as other authors and fills the first seven chapters of the book with lessons on what binary and hex is and how to convert between the two. I have always hated when technical authors begin an advanced technical book with freshmen level topics such as number systems. Real does not repeat this typical mistake. He actually teaches advanced topics such as how the JVM actually works, or how to write a simple compiler by using simple examples and that one can build on. He is obviously very knowledgeable, but uses non technical language in order to reach you. Kudos for a job well done Mr. Reis.



5. I really have nothing to add to the other reviews of this book. I've never learned as much from one single book as I have reading this one. Love it!

3 comments about Java Programming: Complete Concepts and Techniques, Third Edition (Shelly Cashman Series).

1. This book is good for beginning programmers or for those who wanted to learn Java. The book is very detailed about the methodology of programming and such. However, as you continue along in the book (about chapter 3) you start finding more and more code errors in the examples you are working with. It makes it really hard to learn if the examples are wrong. Also, the Author doesn't follow his own rules in his consistancy of variable naming. I wouldn't buy this book if you are trying to learn the most current version of java and techniques. I would buy it if you are interested in learning the fundamentals of programming.



2. While I haven't yet read this book (for class), it should be noted that the (at this time) only review must be referring to a previous edition because the current edition is from late 2005, while his post is from 2002. I assume this new edition is updated.



3. I used this text for my first programming class. It jams a lot into 8 chapters (really 7 as the first doesn't hit you with much). I would prefer a little more of a chapter spread. In fact I would say this is a lousy intro to programming book. Now that I have been through a higher level programming class I am going back to this book and finding it more useful. The programming examples are quite complicated and makes a few assumptions on your level of understanding. The programming examples do not have errors as stated in a previous review, but when you are first learning you make typos and don't know what to look for to correct them. I like to type in all the examples for practice but after an hour of compiling and getting nowhere it would be nice to have downloadable files (Instructors can get them). Overall I would say by the time you can understand this book... you don't really need it for the price.

5 comments about JUnit Recipes: Practical Methods for Programmer Testing.

1. This review also appears on StickyMinds at http://www.stickyminds.com/s.asp?F=S767_BOOK_4
   
   JUnit Recipes is a comprehensive tome of practical methods and techniques for the opensource JUnit tool to develop automated unit-tests for Java/J2EE applications. The book is split into four parts: Building Blocks, Testing J2EE, Additional JUnit Techniques, and Appendices. The Building Blocks cover the basics of using JUnit to create basic tests, organize and manage test suites and test data, running JUnit tests and reporting the results. It even includes a section on troubleshooting. Testing J2EE covers XML, JDBC, EJB, web components (including JSPs), and J2EE applications. Additional techniques include testing some well known design patterns, using JUnit add-ons and JUnit libraries (like GSBase). The Appendices include complete solutions (including code of course), some short and sweet essays on testing, and a modest recommended reading list.
   
   The organization of the book flows very logically and the writing style is very clear and easy to follow. Along the way many insights into important design principles and testing techniques are revealed: the reader will learn about the "Hollywood principle", the Open-Closed principle, design patterns, POJOs, Mock Objects, Private and Parameterized Test-Cases, Abstract Test-Cases, Self-Shunts, and Spys. The book's coverage is very comprehensive and touches on many other popular Java/Enterprise projects and frameworks such as Struts, JBOSS, Prevayler, XDoclet, Tomcat, XPath, XMLUnit, HTTPUnit, Ant, Jakarta, and others.
   
   Even though JUnit is often associated with "Agile" development and much of the wisdom apparent in the book applies to agile Java development, the book is useful to any Java developer on any Java project (agile or otherwise). The book also goes into considerable detail, with working code examples, to spell out exactly how to perform and apply the techniques it describes.
   
   The book's primary audience is Java developers. Java Tester's will still find some good nuggets of information but it's quite clear that Java programmers and developers are the target audience. This isn't some high-level theoretical book mostly of concepts and ideas. This is an imminently pragmatic guide that not only conveys a great deal of highly practical wisdom but also clearly and comprehensively walks you through the explanations and the code to accomplish and apply the techniques it describes. The book is also not a "How To" for coming up-to-speed on setting up and running JUnit.
   
   Another book from the same publisher, "JUnit in Action" is a great overview on learning more about the basics of running and using JUnit and on using JUnit to tackle a number of basic challenges with unit-testing Java and J2EE code. JUnit Recipes has some overlapping material but pretty much "picks up" where "JUnit in Action" leaves off, and JUnit Recipes goes into much more breadth and depth of coverage of JUnit methods, practices and techniques and use with other Java projects and frameworks.
   
   I would say JUnit Recipes should probably be required reading for anyone attempting to use Java, J2EE and JUnit in the real-world.



2. This isn't necessarily the best introduction for absolute beginners (I would recommend /Pragmatic Unit Testing/ for that), but it is required reading for server-side Java, as most other reviewers have pointed out. But it's more than that--it's one of those rare computer books that transcends its subject matter. Why? Because it can make you a better programmer. While some of the credit can rightly be given to unit testing and Test-Driven Development in general, Rainsberger's book makes you /see/ better ways to write and refactor your code. The breadth and depth of examples is astonishing--he convincingly shatters "but it's too hard to test that" arguments with well-researched, non-trivial examples. In fact, I'd say that this is almost a better J2EE tutorial than most books about J2EE proper.
   
   I'm withholding a star for one reason: the book doesn't cover GUI testing tools like Jemmy, JFCUnit, or Abbot/Costello. These JUnit extensions are ripe for a book with this depth; it's just too bad that this couldn't be that book. Other than that, I find that I turn to Rainsberger's book far more often than any other testing book or online reference.



3. Rainsberger does a very good job of detailing the techniques to unit test difficult code; including xml, ejb, servlets, jsps etc.



4. This is a great book. It is directed at users of JUnit, the Java unit testing framework. But in my mind the book gives sound advice for solving your programming problems in general, not just for Java or JUnit testing. It stresses the importance of unit testing, programming to interfaces instead of implementations and just simple common sense. The author is clearly passionate about his field and extremely experiences. The combination of enthusiasm and experience comes through on every page.



5. This is a readable, practical, and deep book. It's one of those books which teaches or refreshes Java and OO theory and practice as you read. I am also reading it for pleasure!