3 comments about Foundations of Algorithms Using Java Pseudocode.

1. The authors take a more informal approach to describing algorithms, than other texts, by Knuth, Sedgewick and Aho. This may appeal to some of you, who might have been put off by the level of mathematical background required by the other books. Or by the rate of exposition of ideas within those books.
   
   The presence of problems with each chapter helps your learning. And there certainly seems to be plenty of examples. To me, it seemed like they were belabouring the point, in places. But to you, it might feel like a comfortable dialog.
   
   The usage of Java pseudocode is neither here nor there. If you are sufficiently skilled in a programming language, and it need not be Java, then you should have no problem writing out actual code to test the algorithms. In other words, don't worry if you do not know Java. Just imagine it as generic pseudocode.



2. I found the material and explanations in this book to be generally followable. I would definitely recommend it for learning the various concepts.
   
   The problem is, as a reference for how to implement certain algorithms, it falls completely flat. Simply because they wrote all their algorithms with the idea that arrays start at '1'. This is icomprehensible inasmuch as no programming language has arrays starting at 1, no budding programmer would think of an array as starting at 1, the authors would have had to test all these algorithms in languages with arrays starting at 0 and then spent way too long converting them since a good many of the algorithms in the book are completely broken when rewritten under the assumption that arrays start at 0 (the 'norm').
   
   In summary, it seems like they went out their way to create extra work for both themselves and their readers. This one little thing is honestly a huge pain.



3. The book was purchased as a classroom text. The subject matter is incredibly difficult, but the authors do their best to make it comprehensible.

5 comments about Java How to Program (4th Edition).

1. Most people who purchase Deitel books do so because it is the required course material for their CS (pick a number) class. Deitel book are needlessly saturated with filler material that do not justify their extremely high cost. You could easily save your money and learn Java by going through the Sun tutorials which are FREE, not to mention the countless online Java tutorials out there (just do a Google search "Java Tutorials"). Stay away from this book! If you have to buy it, then please save some money by purchasing a used book.



2. I learned Java solely from this book. I had learned several languages prior to turning to Java. With the help of this book, I was able to become quite proficient very quickly. It has also served as my only needed reference ever since. The intended audience seems to be the novice or even completely new programmer, so the more experienced folks may need to do a little skimming. In any case, I have and will continue to highly recommend this book.



3. You will be able to write Java prgrams, but you will not UNDERSTAND and KNOW object oriented programming language Java. Avoid Deitel's books. They simply do not know Java.



4. This book is simply amazing. I had an incredibly difficult time with the "other" book I used to attempt to learn Java for class. This book absolutely walks all over it. It teaches in a style that I easily grasp. The authors went to great lengths to specify the "why" of each new line of code, and give very detailed explanations of the methodology of programming, along with "good practices" for programming. I recommend this to ANYONE with a desire to learn their first programming language, as well as those who are looking to learn more.



5. You can see examples, the API, methods, etc, etc. Really nice book if you are begginer or advanced

5 comments about Maven: A Developer's Notebook (Developer's Notebooks).

1. This is a great book to get a quick introduction to Maven. At about 185 pages, it gets right to the point. It's written using labs and each new one builds on the previous one.
   
   I have used Ant and know how it works but was in the dark when it came to Maven. This book gave me the knowledge I needed to understand and modify an existing Maven project within the first two chapters.
   
   It's not a reference manual, and it's not one of these 500 page tomes that weighs a ton but is light on substance. There's real content in a very readable format in this book.
   
   If you are new to Maven and are scratching your head tryiing to figure out what the heck this thing is doing, read this book and you will be enlightened!



2. This book does not apply to Maven 2, the current release of Maven. May be useful concept material but because it doesn't apply to the current version of the software it is not a good "Developers Notebook". This book should be pulled from the shelves.



3. While there is nothing technically wrong about this book, Maven 2 is almost a complete re-write of Maven. This book covers all the ins and outs of using Maven (the project model, dependency resolution, directory hierarchy), but the technical details are now completely out of date.



4. The only full Maven book but falls short on being a good book. The book covers the older Maven version. I would rather wait for version 2.0 coverage than buy an out dated book.



5. This book was a complete waste of my money and my time. The code examples dont work and it focuses on outdated maven 1. Maven is now at level 2.08 and the publishers of this book should know better than to continue putting this book out for sale.

5 comments about Graphic Java 2, Volume 2, Swing (3rd Edition) (Sun Microsystems Press Java Series) (2 Book Set).

1. Mr. Geary has produced a wonderfully comprehensive guide to Java Swing, patiently explaining the advantages and disadvantages of each component, along with the theory behind Swing's framework.
   Every piece of software was written to solve a problem. If a programmer really wants to understand the limitations (i.e. how to use it effectively) of software, he/she must understand the problem it was developed to solve. Mr. Geary goes the extra step in his book to give the theory/history/reasoning behind Swing, as well as, providing examples you can actually use in your code. Congratulations on an outstanding job!!



2. This book is very comprehensive and is a must for any serious Swing developer. I have found it as a good reference for all sorts of examples and also in a method lookup like way.



3. That is all, pure java. Simple, organized, interfaced, estructured, conceptual and objective point of view of reality. Some examples, lots of them, really, some descriptions of classes, all of swing JFC, really, and that's all folks. No more, no less. But that's the best, it's a reference of swing, "thousand and more" pages reference, but clear reference. A must if you're interested in collecting java muscle books.

   Nice cover desing. Strong, doesn't break easily. Sorry ;)




4. Like a fine movie, this book is still very useful even as the language advances. A wonderful reference I still find myself reaching for it several times a week for parts of the GUI that I don't reach into that often. Considering that I use the Eclipse front-end I do all of my GUI coding by hand (that and most GUI builders put out some really terrible code), so maybe I am a bit atypical in this regard.



5. I wish I had bought this book first...I found this book to be a great read; fun, entertaining, and structered in a way that answered my questions before I could ask them. This is the only Swing reference I ever use besides web searches. If I'm picking up a new topic, my first step is to see if this author has a book!

5 comments about Practical Apache Struts 2 Web 2.0 Projects (Practical Projects).

1. Its not for beginners
   
   This book is not good for beginners. Its very hard to follow this book with so many assumptions.



2. Like others said its not for beginners. However, that doesn't make it a bad book. If you are looking for guide for going to struts 1 to 2, this book is not it. With that said, if you are a webwork developer or already have a handle on the Struts 2 basics this book does provide some nice samples. It provides a nice sampling of how to integrate with some of the plugins that have been added over the last year. (zero config, wild cards in configuration, gwt, hibernate, spring, security). You may already be an accomplished struts 2 development however, their may be some things to take away from this to add to one's cookbook.



3. I was extremely disappointed in the authors other struts 2 book; and was planning to avoid this one, but all the other stuts 2 books kept slipping their date, so I picked this one up on a whim.
   
   I'm rather surprised by the negative reviews people are giving it, as I found it a very useful book. Yes the title is a little hokey and the content only pays lip-service to Web 2.0 aspects. I have been working on my own personal projects in Struts 2 for a few months so I wasn't a complete novice coming into the book, and I lurk on both the users and developer mailing lists. I felt the material was well laid out and followed a natural progression. The book doesn't really cover MVC theory nor how it applies to any of the "Action" frameworks, so its not really a book for people with no prior experience in those areas.
   
   The other limitation I found was the book just ends. There was no real wrap up or conclusion. Basically he finishes developing the last use case of this sample application and on the facing page is the index. To me this was the only place that felt rushed.
   
   The book doesn't cover a fair bit of the annotation based configuration opposed to XML and a few of the more established plugins however that are a few places where it might not be "future-proof" given the works that's going on now merging/combining several of the convention-over-configuration plugins into a single unified one for struts 2.1



4. "Practical Apache Struts2 Web 2.0 Projects" walks you through developing an app in Struts2. It includes use cases, iterations, a build process and some unit tests.
   
   A number of other reviews correctly point out this book is not for beginners. You should be familiar with MVC before starting out. This was ok as I wasn't expecting an "intro to struts 2" book based on the title. The author includes a section on Hibernate bare essentials to get readers with different experience on the same page.
   
   I found there to be a good balance between how Struts 2.0 works and implementing common things you might actually want to do in practice. While the book does cover Web 2.0 a bit, this is more of an extra buzzword in the title. The last two chapters are really the Web 2.0 part - RSS and AJAX.
   
   The end left me a little off balance. There was a whole chapter of introduction. The end was the AJAX chapter and the immediately dumped you in the index. A bit of conclusion, or at least a blank page, would have been nice.
   
   Overall, the book was fine. It is good for a "recipes of common tasks" type book once you have read a bit about Struts 2.0.



5. The samples in the book learn you very useful information about the Struts 2. You can download the sample codes. Futhermore you are immediately able to use them in your applications. Then you feel as you are at very good point to go forward into the details of the Struts 2.

5 comments about Processing XML with Java(TM): A Guide to SAX, DOM, JDOM, JAXP, and TrAX.

1. I bought this book when it first came out. I really enjoyed reading it. The book is well written. It has a lot useful code.
   The author code that can be used in the real world of JAVA and XML. I liked the books section on JDOM. This book shows the differences between DOM and JDOM. Also, this book has a lot of information on SAX, DOM, JDOM, and it shows the differences when using each. I would recommend this book to anyone who wants to learn JAVA and XML. Make sure you are an experienced developer before purchasing this book.

   Michael




2. This is definitely a valuable resource for anybody dealing with XML and Java, written by one of the best tech writers in town. The author covers in details a huge amount of topics and API, so many that you couldn't ask for more.
   Be advised that some basic understanding of XML and intermediate Java skills are required to get the best out of this book



3. I really like reading this book. It is easy to read and understand. The author does a good job of describing the XML technologies related to JAVA. This book has a lot of code to analyze. This book is a must have for the experienced developer who wants to do JAVA with XML. I have a message for the experienced developer: THE CODE WILL CHALLENGE YOU; IT CHALLENGED ME!!!

   Michael




4. If only every technical book was written this well! Anyone who is working with Java and XML should have a copy of this book. Highly example driven with clear explanations, the author makes using XML in your Java programs a breeze. Even better, the author has a style that makes the book fun to read as you feel like you are learning all sorts of secrets from an XML insider.

   The book starts with a quick introduction to XML and then gets into how to create XML documents in your programs. The first four chapters cover everything you need to know about creating XML whether it is for XML-RPC, SOAP, or simply to store in a file. The next section covers parsing XML documents. SAX and DOM are compared and then the next eight chapters discuss these two methods of parsing documents, explaining how to use them, comparing them, and helping you determine how to decide which technique to use for which situation. The section on DOM explains not just how to parse documents using DOM but also how to create new documents. The final chapters of the book cover JDOM, XPATH, and XSLT.

   Did I mention that this book is full of examples? The author doesn't rely on simply explaining how something works or how to use a technology (even though his explanations are excellent), he has examples to demonstrate everything he discusses. Each example builds upon the previous example and makes learning the techniques easy and enjoyable.




5. great book on xml, specially on different kind of parsers, their purpose, advantages and weakness.

5 comments about Beginning Spring Framework 2.

1. It is a good book for beginners. It teaches you how to hands on code. The example is step-by-step. It answers lots question to a beginner. It is the best readable book I recommend to beginner.



2. Before reading I have made use of the Spring Framework (others did initial configuration) but never fully understood how it worked. This book helped explain features I did not fully understand and reinforced concepts I was familiar with. My current project utilizes Spring and this book jump-started our use of Ajax, DAOs, and Web Services. Easy-to-understand language and very readable.



3. This book is perfect for me. I've suffered through heavyweight J2EE projects in years past, worked extensively on Struts servlet-only apps, and spent the last year building a Ruby/Rails application. Now I gotta ramp up for a Spring project and I need a book tailored to getting me started in Spring quickly. This book does that.
   
   The focus is on getting an experienced developer up and running in Spring. I know I can backfill knowledge of Spring internals later with one of those 700 page books. I like that in addition to developing with Spring it ties in most of the nuts and bolts of project development - unit testing, build management, and Spring-specific eclipse IDE navigation.
   
   There's a couple of niggly problems getting set up with maven, a resource location, and a .jpg file, but by simply going to the book's forum on wrox I had that all resolved in less than 15 minutes.



4. I feel this book could have been good because the authors attempt a broad-sweeping introduction in a short and to-the-point manner. Sadly, however, I gave up on this book when I realized the authors/editors hadn't gone through and unit-tested each chapter's code and content for reasonable logical soundness from a pedagogical perspective. I ran into issues running simple tests because data tables were not created in the outlined setup process. More than just the issues with the code though, I felt from the onset that the authors did a poor job with the writing itself. These guys gloss over some concepts as if in haste to complete the book. The authors and editors, I feel, just did a poor job of creating an effective instructional instrument. To further its demise, the book's forum is poorly supported by the authors. There are barely any solutions to posted problems and the readers are struggling to help themselves one bug at a time with the poorly tested code and book instructions. I am of the frame of mind that learning a framework should be fun and interesting. The shoddy editorial work on this book makes learning painful and agonizingly annoying. Onto a better book for me...



5. While the book is excellent and informative, in typical wrox fashion they don't include the complete source code on their download. So I'd definitely give the book 5 stars but lacking the source code, and the fact the compilation fails in maven, has to bring the score down.

5 comments about Programming Language Processors in Java: Compilers and Interpreters.

1. The author has done a good job by presenting basic
   compiler theory and implementing a simple
   compiler using the java programming lauguage.

   Good illustration of compiler concepts.

   One of the better basic compiler books i have read
   so far.

   Next book should be "Progamming language pragmatics"
   followed by "Advanced compiler design and implementation"




2. It's a lot of work creating a textbook like this, and the authors did a great job along certain dimensions. The book is well-organized and much more accessible than many (in)famous compilers books. The copy editing is high-quality: there aren't many mistakes in the book. The book itself is beautifully bound and printed, making it a pleasure to read. There's lots of sample code. On the whole, it's not a bad effort.

   There -are- some real problems with it, though. The most obvious and central problem is that it's not a book by (or for) Java programmers. It feels very much as if the book was hastily rewritten from "Language Processors in Pascal" to "Language Processors in Java" after Java exploded in popularity, a year or two before the book was published. The mini-Triangle language is clearly a Pascal derivative, and many of the "pseudo-code" examples are really Pascal. Pascal may be a teaching language, but it looks completely alien to Java developers.

   My biggest concern, and it's what prompted me to write this review, is that the Java code is truly awful. Yes, it uses the Visitor pattern (as one reviewer pointed out) to traverse the AST during semantic analysis, which is a reasonable strategy. But the code is just plain bad, and you don't want students learning bad habits. The code is utterly non-polymorphic; it's filled with long cascaded if-statements that check whether an AST node is an instanceof this or an instanceof that. They pass and return parameters of type Object, and callers perform dangerous narrowing typecasts. They freely pass and return null values that have special semantics (i.e. "if this parameter is null, then it means we have this kind of situation; otherwise it's the other kind"). Types are represented as ints (no attempt to create typesafe enums), instance members are made public and accessed directly rather than through methods, and they use unconventional (and unexplained) 1-character variable names. I'm telling you: it's a complete disaster, and students will come away from the course writing the worst Java code you could imagine.

   Another problem: the book is written in a stilted and awkwardly formal tone - a throwback to textbooks in the 70s and 80s. The art of writing textbooks has advanced to the point where, gosh, you're supposed to be able to READ them. They're written FOR real people, BY real people. But this book reads like an actuarial report. It never says "you" and never says "we" - it's written entirely in stilted 3rd-person legalese. Not good.

   Oh, one more gripe: the authors decided mysteriously that they don't like the standard terminology that's been around for 3 decades, so they changed "semantic analysis" to "contextual analysis" and so on, and then acted as if the standard terminology is non-standard. They could have at least said up front that they preferred using their own terminology, but that it was nonstandard; instead they're trying to rewrite history. It's inexcusable, and will confuse students who head to other books after reading this one.

   Compilers are hard to write and hard to learn, and this book actually is an improvement in clarity of exposition over most of its predecessors. But it's just begging to be replaced by something better. In the meantime, I'd skip it and go straight to Programming Language Pragmatics.




3. This is really the greatest 'Compiler for Dummies' book as of today. I own and studied all books (total arround 80) about compiler constructions you can buy in the world today plus a lot of out of print titles, so I know what you can buy on the market...
   
   If you're looking for a learning-by-coding compiler book don't look futher. This is a great introbook for a Bachelor of Science of a Professional Bachelor student! If you have the money to buy only one compiler book buy this one. If you have the money to buy 2 books and you also know a bit C++, buy this one and 'Writting compilers and Interpreters' from Ronald Mak which also offers a pratical approach which is also nice for newbies but not that nice as this book.
   
   If you have finished this book and want to get more theoretical insight or you're a Computer Science M.Sc student (like me), read 'Programming Language Pragmatics' from Mr. Scott, which don't present the material on a dry manner. This book covers all aspects of compilation and language design in greater detail! Be sure you have read (or master) an intro text like 'programming language processors in java' before starting books like 'programming language pragmatics'.
   
   If you're a M.Sc. student and you're looking for a learning-by-coding book i recommend the books of Andrew Appel (Modern Compiler Implementation in Java) which covers advanced topics (optimization, register selection,etc). But beware: if you're new to compiler design forget Andrew Appels book, and buy this one because Appels would be a bit too difficult for you.
   
   Back tot the 'Programming language processors in Java' book.
   
   This is what I like and what not:
   
   PROS:
   
   * It gives some nice written theoretical introduction of the whole compilation process (e.g. what's LL and LR-parsing, how is runtime organization organized (stack, parameter passing, stackframes etc). It doesn't dive too deep, but you will be familiar with the topics. E.g. it explains how LL and LR parsing works (with some nice examples how to parse LL/LR simple English sentences), but it doesn't tell you what the advantages/disadvantages of both methods are. This is beyond the scope of this book. For these topics read later something else (e.g. 'programming language pragmiatcs')
   
   * Not all Java code is printed to fill 1000 pages. Every codesnippet is well commented, all repeatative code is left out: you can download all the Java code. So this book is not one big listing.
   
   * It gives you insight how to build a really nice Virtual Machine. The author is talking about an interpreter, but the compiler generates modern intermediate code (STORE,LOAD,CALL,JMP) and the VM execute this in a big WHILE-loop.
   
   * Some learning-by-coding compiler books (e.g. 'Building your own compiler with C++' by Jim Holmes (not recommended)) explain only a silly subset of pascal (e.g. only assignment and writeline), but this book teach you 'mini Triangle-language' which also offers arrays, functions/procedures, records (structs), and parameter passing by reference/value. It also explains you those more difficult topics like parameter by reference passing is handled by the codegenerator.
   
   * It has a nice chapter about runtime organization. This is a nice chapter for people which are new to e.g. processorarchitecture. This chapter explains you how local variables are stores (stack), how parameter passing to functions is working and how return values are passed back. Because the Interpreter (VM) which is introduced in the book, has a modern stack machine VM (STORE,LOAD,JUMP) this is an excelent way to study those VMs and code generating for a stack machine.
   
   CONS:
   
   * I agree to the customer review of Mr. Yegge of July 12, 2004 that the Java Code is not always supernice. E.g. there is often java.lang.Object parameter passing which is later dangerous narrative casted. I do NOT agree with Mr. Yegge about his remarks on the Visitor pattern. The author explains why he is using the visitor pattern: to reduce coupling between the CodeGenerator or TypeChecker and the AST. On this point I like the design of the author. The idea of using the visitor pattern is nice, but it is somewhat bad implemented with those narrative casts.
   
   Conclusion: I STRONGLY recommend this book for people who are new to compiler design.



4. Now that Eclipse has an open source (LGPL) framework for building compilers, processors, refactoring tools, code generators, and interpreters, this book is hardly relevant. Eclipse's JDT is well documented, and functionality existing for Java can be ported to other languages (and some is already abstracted to the underlying Eclipse platform). Eclipse has an AST (Abstract Syntax Tree), DOM, and all the other tools this book hacks together, except Eclipse is a huge widely supported open source project.



5. Very well organized, all source code for the compiler + Interpreter/Virtual Machine + Disassembler is available online. Good writing, good exercises (including answers to some of them), good selection of material to cover.
   
   If you want to have a good understanding of how copilers/interpreters work, and want good working source code for a demostration and to play with, then you must have this book.
   
   The fact that the implementation is in Java is another plus. Petty differences aside, Java is the most accessible language (in terms of reaching a wide audience), and for those who want to quibble over the authors' coding style: "Grow up!"
   
   For those of you trying to decide whether or not to get this book, go on, download the source, take at look at the code, run it, and if you wanna know how/why it all works, then get the book and read it. You will be glad you did.

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