No comments about CSS Artistry: A Web Design Master Class (includes full-color Transcending CSS book and 2 1/2-hour Inspired CSS DVD video training) (Voices That Matter).

5 comments about The Scheme Programming Language, 3rd Edition.

1. As I said in a past review to the second edition, this book is wonderful. This book has convinced me to migrate from Common Lisp to Scheme. This is a serious book for the one that really wants to learn about Scheme and require careful study and a strong motivation. Please note: if you are really interested to learn Scheme, then this book is for you; if you are not really interested and/or you like to joke, this book is absolutely not for you. The book is accurate, complete, well written and cover all you need about the modern Scheme. I use Scheme for personal study about bioinformatics. Thanks to the Autor.



2. Good book. To the point. Doesn't waste time with fluffy words. Excellent. I learned Scheme in a few days from this book. Scheme is like C on steroids. I like C, I hate C++ and Java. Calculus is entirely about functions, not objects. And I don't see people saying oh, Calculus is weak because it isn't object oriented. BLECH. Teach me to fish, don't give me one.



3. Very good book for learning. You can follow many examples with a running Scheme interpreter; I recommend it as a must.



4. I'm a fan of a lot of the popular Scheme or Scheme related books (SICP, The Little Schemer, The Seasoned Schemer). While in some sense this book takes a more pragmatic approach than the aforementioned books, it is no less valuable. I found this book helpful as a teaching aid while learning Scheme, and as a reference for my continued use of the language.
   
   Advanced topics, such as continuations and the syntax-rules and syntax-case macro systems, get good treatment from this book.
   
   Highly recommended.



5. I purchased this book specifically with a view to learning the Scheme language. The text is easy to read, is pithy and to the point, and generally makes concepts clear and easy to understand. There are however, in my opinion, some sections where the author forgets that concepts are new to the reader and the examples that are used tend to obfuscate the point being made rather than elucidating it.
   
   I have never considered myself stupid, but after my 5th reading of the introduction to continuations I was beginning to worry. A quick reading of another text on the subject cleared up my concerns almost immediately which suggests to me that the explanations are not as clear as they could be. There are some other areas of the book where this sort of assumption makes grasping a new concept more difficult than it should be.
   
   Nonetheless, I still consider this a good introduction to the Scheme language and would gladly recommend it to the aspirant Schemer.

5 comments about Python How to Program, 1/e.

1. I am a practicing mechanical engineer who's programming experience is based mainly in Fortran90. I wanted to learn Python as quickly as possible, but in a well structured manner. I tried learing Python from the book 'Learning Python', but became discouraged after a few days when the discussion became disjointed. 'Python How to Program' is an excellent book and reference for Python. It is extremely thorough covering many topics including object-oriented programming (three chapters) and web programming. This book will form the foundation of my Pyhton library. Each Python subject is introduced in a simple manner and then proceeds to a more advanced level. Many examples are presented with thorough discussions in each chapter. Detailed summaries are presented after each chapter. This is an excellent book for self-study. I have recommeded it to many of my engineering colleagues.



2. An excellent intro to Object oriented programming in general and Python in particular. A real hefty volume. Wish I could afford it.



3. I purchased Deitel & Deitel's C++ How to Program book long ago, and found it to be comprehensive and extrordinarily helpful.
   
   When I picked up Python How to Program, I expected the same incredible experience. Instead, I was sorely disappointed by their complete lack of Pythonic thinking. It seems as if they took one of their other How to Program books and ran a code converter across it to migrate it to Python. As a previous reviewer pointed out, some of the examples are horrificly implemented, a clear case of programming in Python with the "C/C++ mentality."
   
   The examples seemed fun, but no amount of fun can compensate for the fact that this book teaches you nothing about how to truely be a Python programmer. Anyone can read the lexical syntax descriptions on the python.org website and code the examples in this book. It gives me the feeling that Harvey Deitel did not learn Python for any reason other than to write an expensive book about it, and has no idea how to actually use the language.



4. Bibles, in the profane sense of the word, are huge books filled with clutter and not meaningful structure, which attempt to cover way more than they should. This is a clear example. It might be worth a quick look to a particular chapter, just to get a quick grasp of a particular area like XML, pygame, tkinter, etc. But definitely, this is not the book a beginner should use to learn the language, because as many said before, it seems to be a blind translation from their also crippled Java book. This reader, who cherished their C/C++ book couldn't be more dissappointed.



5. This book on Python is very complete and at the time it was published was better than any other book on Python. It is still an excellent book and has more information than any other Python book on the market. I have used the book as my major reference work for several years. For non-GUI programming you will find most of your questions answered in this book. The general tips on structure and theory of programming are particularly useful for people who do not have a formal education and degree in computer science.
   
   I hope the authors will come out with a new edition that heavily covers newer GUI options including wxPython.
   
   If you are new to Python this book is your best option although there have been some changes in Python since this book was published. If you are familiar with Python it can still be a valuable resource for you. If you have a formal education in computer science and also know the peculiarities of Python then perhaps several more specialized books on particular facets of the language and its uses would be more appropriate for you.
   
   GUI programming is not covered sufficiently in this book to eliminate your need for another book focused specifically on the GUI of your choice. I anxiously await the publication of the book on the wxPython GUI which has been delayed several times and is now due by March of 2006.

5 comments about Macromedia Flash MX ActionScript for and Games.

1. The examples in the book are not updated and show an older method of writing action script. While it still works, it's not the best way to learn the current methods.



2. The five stars are only for the price and quality of transaction for the distributor. The book, however, deserves 3 max. If you want to know how to create these specific games, then look no further. If you want to learn the theory behind the games so you can easily go on to create your own, buy another book. This is a good tool if you are interested in Rosenzweig's style of programming, but only that. If you wish to expand your knowledge of ActionScript on a more modular and appliable level, I would suggest Flash MX 2004 Savvy or an ActionScript Bible (for the more advanced topics).



3. This book is not very well suited for beginner actionscript programmers.The author gives two or three brush off chapters on actionscript.Then bombardes you with math.random()* this that and the other.And starts using object type programming with little explanation of whats going on behind the code.He does comment the lines but the comments faintly explain what he is doing.I would have given this book 2 stars,but because you can take these games change them around graphics,little script or whatever and "make them your own" I am giving it 3 stars.I've owned this book for over a year and after reading other books it's making more sense what he's doing now.But for someone with little experience, be prepared to get lost very quickly.



4. If you have even a little background in Actionscript or programming in general, you will find this book worthwhile. The author gives a few beginner's tips, but for the most part this is for the intermediate user looking to take the next step into Flash gaming. There are a variety of games covered and each game is included on the companion CD. The CD is probably the biggest selling point when compared to other Actionscript books as it's a huge help to see what the author is talking about on screen.



5. Even though this book was written for Actionscript 1.0, it still has plenty of life left in it. A reasonably capable Flash designer should be able to convert the script to AS 2, and probably even convert it to AS 3. If you're already a guru you may not find it as useful, but intermediate level Flashers should find plenty of inspiration. The game theory is light - just the basics - but I was more interested in the script, which it is full of. Well worth the money.

2 comments about Accelerated DOM Scripting with Ajax, APIs, and Libraries (Accelerated).

1. Accelerated DOM Scripting, Ajax, APIs, and Libraries by Jonathan Snook, Aaron Gustafson, Stuart Langridge, and Dan Webb is not just another book on DOM scripting. There are many excellent DOM scripting and JavaScript books available to us as developers. Some are thorough explanations of JavaScript with a little bit about the DOM, while others are full blown books on the subject of DOM scripting. This book takes a slightly different direction discussing DOM scripting in light of Ajax, the array of APIs available, and the many libraries available that help us rapidly develop our applications. Upon hearing of the arrival of this book, I was worried that it might be something that would be considered obsolete the week after it was published due to the rapid rate of change in libraries and APIs. After reading this book, that worry was put to rest as each of the authors did an excellent job of digging into the guts of the libraries, exposing how things are done, how you could do it yourself, and how a library could be of assistance to you.
   
   Contents
   Chapter 1 starts us off with an explanation of the state of JavaScript. JavaScript has been abused heavily in the past, and due to this abuse and its inconsistencies - many developers chose to shy away. However, this is no longer the case. Along with explaining the state of JavaScript, we get to look at ways to manage our JavaScript code as well as debug our code. This gives us the tools we need as we begin development throughout the rest of the chapters.
   
   Chapter 2 dives into HTML, CSS, and JavaScript. Often referred to as the trinity of front-end development, it is valuable for you to understand the purpose of each, and how they interact with one another. The basics of each are discussed, and then we move to the DOM and find out how we can use semantic markup and meaningful CSS to create the necessary hooks for our JavaScript to interact. Topics such as traversing, reading, and writing to the DOM, handling attributes, detecting browser support, and handling events are all discussed. This chapter builds from previous chapter, and prepares us as we move on to the following chapters.
   
   Chapter 3 tackles the sometimes tough subject of object oriented programming. Depending on your background and experience in programming, the idea of OOP may seem foreign to you. However, the author does an incredible job of highlighting the benefits, formatting, and examples throughout the entire chapter. Some of the benefits discussed are: Namespaces, closures, and encapsulation. To me, this chapter was one of the most valuable in the entire book as it helps you to understand the programming at the core of the libraries that are discussed. Knowing what is going on under the hood is extremely important as you develop and troubleshoot your code.
   
   Chapter 4 moves us to the discussion of the available libraries. As I stated earlier, I was concerned that this book would quickly become stale due to the change and development of libraries. I couldn't have been more wrong. This chapter doesn't just show you the libraries and move on. This chapter teaches you how the libraries work, how you can develop within the libraries, and explains the benefits of using libraries. It teaches you what takes place under the hood for so many different aspects. Along with teaching these things, the author gives you some tips as you are searching and selecting a JavaScript library to work with, something invaluable as there are many options to choose from.
   
   Chapter 5 moves into the world of Ajax and Data Exchange. This chapter discusses all of the nuances of Ajax. These are the important things that need to be addressed before you start implementing Ajax in your applications. Understanding the data formats that are returned. Understanding the HTTP codes. Understanding the different ActiveX Objects. Understanding how to prepare for and handle failure. All of these things are very important as you use Ajax. After you learn what is going on under the hood and how to put the pieces together, the author shows you how libraries can help you in the process.
   
   Chapter 6 discusses Animation, what most people think of when they hear Ajax. As with the previous chapter, you start off by building a simple animation object, then look to see what the libraries have to offer.
   
   Chapter 7 takes us into form validation with JavaScript. All validation should first take place on the server side, then use the client-side to enhance the user experience. The tricky part comes when you find yourself maintaining two validation codebases, one in a server-side language and one in JavaScript. This chapter brings both of these worlds together and allows you to specify your validation rules in one place, sharing your server-side code with the client-side. This makes the validation process much easier and expandable. If you ever want to add or remove validation rules, you can do it in one spot and both the server-side and client-side will follow suit. As with the previous chapters, we first build our example from scratch so we understand the core, then we see how libraries can help us in the process.
   
   Chapter 8 is a case study in building a FAQ system. This chapter walks through the process of creating a usable, accessible, and progressively enhanced FAQ system. This case study builds the semantic HTML, the necessary CSS hooks, and uses the necessary JavaScript to achieve our tasks. The process is extremely thorough as each and every piece is tackled and dissected in the building process. This case study is an excellent tutorial in using all of the building blocks we have discussed up to this point.
   
   Chapter 9 is another case study that walks us through the process of building a dynamic help system. This current example utilizes the Ruby on Rails framework to build the application. The first part of this case study spends important time in planning and preparation. This is important in any application that uses progressive enhancement. As the author points out, this chapter starts with a solid base of semantic HTML, and then builds the CSS and JavaScript on top where necessary. The planning is in place, the foundation is established, and the hooks are in place. As with the previous case study, this chapter does an excellent job of diving in and showing you all of the little details necessary to put an application together.
   
   Conclusion
   This book went beyond my initial expectations. It is geared more towards someone who already has a good understanding of HTML, CSS, and JavaScript. If you are looking for a book to teach you JavaScript, then this is not it. This book will help you take your understanding of JavaScript to the next level, and help you grasp what is going on at the core of your library of choice. This is especially important when you have to troubleshoot a piece of JavaScript, or you have to extend something to fit your needs. This book doesn't simply leave you with an explanation of libraries, but teaches you where libraries are helpful, and how you can fully understand what the libraries have to offer. JavaScript is not evil. JavaScript libraries are not evil. This book will show you how to make proper use of the tools available to you.



2. Accelerated DOM Scripting with Ajax, APIs, and Libraries - despite its lengthy title, is a succinct glimpse into the world of JavaScript programming. Primarily written by developer extraordinaire Jonathan Snook, this book also includes contributions from a veritable who's-who of the JS world: Aaron Gustafson, Stuart Langridge, and Dan Webb. They cover a myriad of topics, including object oriented programming, DOM traversal, and popular libraries:
   
   * Dojo
   * Ext
   * jQuery
   * Mootools
   * Prototype
   * Scriptaculous
   * YUI
   
   The book starts off at a reasonable pace, explaining a brief history of how JavaScript came to be, debunking some of the myths around its viability, and showing some of the differences in implementation between HTML and XHTML. Namely, the use of CDATA for inline scripts. Snook also clarifies the meaning of Ajax, which originally stood for "Asynchronous JavaScript and XML," but has since come to encompass any asynchronous browser - server interaction.
   
   Another topic covered by Snook is that of code maintainability and debugging. While JavaScript comprises one-third of the "holy trinity" (HTML, CSS, JS) of web development, the W3C only offers validation services for the first two. As one transitions from a code savvy designer who can do HTML and CSS, it can be somewhat confusing, left to one's own devices to learn JS.
   
   Luckily, there are plenty of tools available, but one has to look beyond the W3C to find them. Such helpful allies are the Firebug and Web Developer extensions for Firefox, and JSLint - an irreplaceable JS code verifier that offers a variety of strictness and integrity settings. Snook explains how to use these to your advantage, using console.log to catch errors in Firebug, and writing well structured code that passes minification and obfuscation.
   
   Snook explains the importance of taking a wholistic approach to web development, treating HTML and CSS with due respect, ensuring semantics in markup and steering clear of using JS presentational purposes that would be better handled in a stylesheet. He also explains the concepts of nodes as they appear in a page by showing them in a tree structured chart. For instance, a tag is a node, but so is the sum total of the text inside it. As a general rule of thumb, all tags are nodes, but so are their non-tag contents. This is important to remember when attempting to manipulate the DOM via cloneNode.
   
   Another tricky concept, which is handled differently depending on the browser, is event bubbling. Despite the name, this has nothing to do with socializing and everything to do with the way actions are triggered in a browser. Snook explains how this can be used to one's advantage, by assigning an event listener to a containing element, such as a UL, and when it is clicked, checking if the click originated from a particular child element, such as a link within a LI with a certain class. Now you are cooking with fire, because you can build out complex menu systems.
   
   After laying a solid foundation of teaching the fundamentals, the book moves on to the juicier parts - using libraries. Snook cautions against jumping straight into using a library without understanding the nuances of what is happening "under the hood," because if you ever need to debug at a core level, you're stuck.
   
   That being said, in chapter 5 he shows how to do some complex data exchange, mimicking a desktop environment, mentioning how this could be enhanced by Prototype, YUI or jQuery. Chapter 6 is all about doing the really cool stuff - adding visual motion to your pages. Snook shows how to achieve identical tweening effects with Scriptcaculous, jQuery and Mootools.
   
   In chapter 7, Stuart Langridge takes the helm, and explains how to write your own custom form validation. Let me just say from experience that this is typically the best way to go, because the business requirements around what constitutes a valid form entry can often get pretty hairy. For me, it is usually easier to write this by hand, with the help of a library, rather than try to find a one size fits all plugin. Langridge shows how to do this on both the server side, via PHP as well as in the browser using JS. It should be noted that whether or not you're doing client-side validation, server-side is a must-have (JS can be switched off, PHP can't).
   
   In chapter 8, Aaron Gustafson shows how to build an incredibly slick FAQ page, using JS to create an accordion style menu system. He does it in such a way that if JS is unavailable, the it reverts back to a standard page. This notion of adding functionality is called progressive enhancement whereas orchestrating an acceptably elegant fall-back scenario is termed graceful degradation.
   
   For those familiar with Ruby on Rails, chapter 9 is for you. Dan Webb goes step by step, showing how to build a dynamic Ajax drive help system. He uses Prototype for some of the heavy lifting of data processing, and his own custom extensions dubbed Low Pro to assist in making his code unobtrusive. With the core functionality in place, he uses Moo.fx to add in animations.
   
   Aside: The aforementioned Mootools is a full library which had its origins in Moo.fx. Mootools and Prototype both include core DOM functions, and can be considered mutually exclusive. However, if you want the animation style and syntax of Mootools, and area already using the base of Prototype, Moo.fx is a nice add-on. Likewise, Moo.fx and Scriptaculous are mutually exclusive.
   
   Well, that wraps up my review. Hopefully it has encouraged you to dig in further to this well written book. The people involved definitely know their stuff, and the topics covered are highly relevant to the fast pace of web development today.

5 comments about VBScript in a Nutshell, 2nd Edition.

1. I don't have this book, I've never read it. But the negative reviews for it are out of line. People have reviewed it claiming it isn't for the beginner or for learning VB Script. NO KIDDING!! It is called NUTSHELL for a reason. It is a reference book, NOT a learning book. Don't give bad reviews for a book because you were too stupid to realize you bought the wrong book. That's just as bad as buying a Java book and complaining that it doesn't have any Javascipt examples in it.



2. This is not the book to learn the basics of VBScript, but it's exactly what I needed; a good reference book. I got tired of trying to find syntax of commands and functions online. Now I have it at my fingertips.



3. This is not intended for beginners in scripting or VBScript in particular. But for anyone with even moderate programming or scripting, this may be all you'll need to become familiar with VBScript.
   
   Written in the spare, terse style of all Nutshell books, the book is very dense in terms of information. The major aspects of VBScript's versatility are explored (though there are no references to HTML Applications (HTAs)). The major functions are explained and there is a complete reference.
   
   An essential volume for anyone using VBScript.
   
   Jerry



4. This text is excellent for folks working on VBs projects. It contains good examples, great information about syntax and also warnings for "gotcha's" -- it's great!



5. I've been a big fan of the 1st edition for years and found it very helpful. I use Regular Expressions a lot in Perl and found VBScript's support for RE's a bit lacking (could not extract the submatches). I was pleasantly surprised to find that this capability was added in VBScript 5.5. I bought the 2nd edition of this book because it claimed to cover VBScript 5.6. Imagine my surprise when the SubMatches collection isn't documented at all.
   
   Overall I'm quite disappointed in the 2nd edition.

5 comments about Systems Analysis and Design with UML Version 2.0: An Object-Oriented Approach.

1. Item recived as presented



2. The UML writing style of this book is very easy to follow, and a great way to gradually introduce the whole concept of object-oriented analysis and design methodologies to the readers, especially the beginners. The authors did a great job illustrating the entire system development life cycle with a coherent and realistic example using the latest UML notations, practical methodologies, and various analytical artifacts. The only criticism I have is that sometimes the description of a particular topic spans over multiple pages without sub-leveling or sub-topics or highlights, making it very difficult for user to go back and perhaps mine certain important concepts embedded in the discussion. Perhaps more generalization relationship and diagrams can be helpful. Overall, it is a very good source of reference for object-oriented design in layman's term. I will strongly recommend it to my colleagues.



3. This book is just majorly confusing and really for the major eggheads. I'm using it because I have to for class but I'd rather go to another approach for learning this stuff. I'm using Learn to Program with C# by Smiley and it discusses some of the topics, from the early stages in the reading, as to the phases of development and because of that it helped me to understand this better. However, this stuff is really hard to grasp without the egghead mentality.



4. After reading a couple of 'classic' system analysis texts I felt I needed to read about system analysis and UML. This title had some good reviews so I purchased a copy.
   
   This book did cover both system analysis and UML, but I felt that it did not cover either well. I had a hard time engaging with the content and linking it with my existing knowledge of UML and systems analysis.
   
   If you are interested in UML and systems analysis I would recommend reading "Modern Structured Analysis" (Yourdon Press Computing Series) by Edward Yourdon, and finding a good UML 2 text (I'm lookging for one now).
   
   For the price, I was expecting a much better book.



5. The book is serivicable...professor loved certain sections but hated others. There is no perfect textbook on this topic.

5 comments about Perl by Example (4th Edition) (By Example).

1. If you are looking for a book that provides Perl script examples, then this is the book for you. Provides numerous examples of perl scripts in each section, plus then the author breaks down line by line what the script does. I use this book in conjunction with O'Reilly's Learning Perl.



2. Clealy written, and in terms I believe are easily understood by programmers.
   Also, wonderful price! (under $2.00)



3. Good straight forward examples... most show the input, the code and the output produced by the code. You need only understand the logic of programming... the book fills in the rest you need to know. I have six or seven books on Perl but always reach for this or The Little Black Book for syntax and examples. Invest in a good editor designed for Perl programming like OptiPerl [with syntax checking and debugger] and you will be well on your way!



4. I use the Perl language daily (and I love it). I own several of Ellie's books and have taken classes from her in Silicon Valley. The books are clear, the index is excellent, but the examples are too simple. Many examples use input typed in from the keyboard (instead of reading in input from a file). Business applications/corporate applications usually read in input from a file.



5. [A review of the 4th Edition, that came out in late 2007.]
   
   One way to learn is to learn by example. Quigley follows this precept in this massive book on Perl. Candidly, there are far slimmer books that describe the syntax of Perl. Typically, these have a few didactic examples. For some people, that suffices. But you might be a newbie to any type of programming. Or perhaps you want a grab bag of many example programs, to search thru in case you can find one to quickly adapt to your needs. In this case, Quigley's book might be well suited.
   
   The examples are easy to grasp. Accompanied by exhaustive supporting text. It doesn't get simpler than this. In some ways, this led to complaints in reviews of earlier editions. A few other reviewers saw the examples as perhaps too trivial. Well they are, to experienced programmers. Newcomers need more support.
   
   The book also goes into an important usage context. Where you combine Perl scripts with CGI to write dynamic web pages. But beware. The book doesn't really discuss on first principles whether you should use this Perl/CGI combination. CGI has been found to be rather cumbersome for dynamic pages. Programmers tend to favour other methods, like JSP [Java Server Pages] and ASP.

5 comments about Head Rush Ajax (Head First).

1. Some people prefer dense reference-like texts while others get droopy eyelids after just a few pages. Face it--this is complex material we are trying to learn. The O'Reilly Head First series has really figured out how to present concepts that can be difficult to understand, especially for people who are new to the field, in a way that makes it easy to learn.
   
   If you are new to Ajax or if you have some experience with it but want to fill in the gaps, this is a great book.



2. A conceptually solid intro to AJAX plagued by errors in the code samples -- see http://www.oreilly.com/catalog/headra/errata/headra.unconfirmed. Even some of the sample ajax apps running on the headfirstlabs site don't work! For instance, visit http://www.headfirstlabs.com/books/hrajax/chapter02/breakneck/pizza.html, type in a phone#, and watch as the php incorrectly dumps out all the addresses in the mock database. Did the author even bother to test out the sample apps?



3. The book is humourous and a pleasant read, and a fun way to learn Ajax in your easy chair by the fireplace.
   
   But *don't* try using it on the job.
   
   I tried building a real-world application with this as my guide - as I went through each chapter, I'd use the methods conveyed by the examples to build my own project. This went well until I got to the section on POST requests. As before, I adapted the example to my own project - and it didn't work. The problem is that the code on page 299 is flat-out wrong, and they don't tell you this until page 308 - after a several-page diversion into another subject. Then, on page 308, they finally reveal that on page 299 they had skipped an essential (but non-obvious) step.
   
   Meanwhile, I had wasted about half an hour wondering why the back-end application wasn't receiving any of the form contents, putting in javascript in the front-end to display what it was sending before it sent it, putting logging in the back end to dump the inputs to files for analysis.
   
   My copy now has "WRONG" written in one-inch letters across page 299.
   
   (I was reminded of an episode of M*A*S*H. An unexploded bomb was in the camp, and Hawkeye was trying to defuse it while Radar read him the instructions - slowly, one step at a time - from a safe distance. The instructions were something like "Cut the red wire. But if there are also two black wires, you must not cut the red wire.")
   
   Authors, I can appreciate your writing style and your general method of teaching - but please be aware that some programmers like to test our applications incrementally, and leaving a booby trap in the code just wastes our time.



4. Notice the rest of the books in this series are all "Head First ...", but this one is "Head Rush ...". It was an alright introductory book at the time it was published, but there are now better choices. I assume it has been replaced in the O'Reilly / Head-First lineup by the recent "Head First Ajax" (seriously, I'm not kidding ... this is reminiscent of them remaking The Hulk, again).
   
   Reviewing this book in a vacuum I'd say its strength is its very thorough, very tutorial, very well-illustrated coverage of the lifecycle of an XMLHttpRequest. Grokking asynchronous, callback-based programming is one of those quantum leaps in understanding ... like learning what a pointer is. So having a tutorial available is great. But I could swear that there were two chapters in a row that covered exactly the same example.
   
   And does anyone know how I'm supposed to choose amongst these titles in the same series: "Head Rush Ajax (Head First)", "Head First Ajax", "Head First Javascript"?
   
   Other worthy choices:
   - "The Book of Javascript", Thau
   - "Ajax: The Definitive Guide", Holdener
   - "Adding AJAX", Powers
   - "Building a Web Site with Ajax: Visual QuickProject Guide", Ullman
   
   Now, go build some Web 2.0 thingy that replaces the Desktop OS!



5. The teaching style is light and humorous and that's great and all (though definitely aimed heavily at 20-somethings), but when the code examples simply don't work, glib doesn't cut it any more. In a beginner's guide book the code must be solid, even more solid than a book aimed at experts, because the beginner doesn't have the knowledge base an expert would have to figure out obvious flaws. Unfortunately, what this book is presenting as valid working code contains major flaws.
   
   This is the kind of book where you start doing the exercises and think "Oh, I can get this", then you end up banging your head on your desk because it seems so easy that you should be getting it, but nothing you do works. Then you lift the code verbatim from the book (and its *known* errata) and realize it also just doesn't work. Hmmm. Then you find reviews and blog postings complaining that the code doesn't work. Then you wonder how well the people that rated the book at 4 or 5 stars know the author...
   
   In all fairness, the cute presentation does give a feel for the *conceptual* basis of the subject, but don't expect to come away from the book with anything concrete that you can set into a functional web project, unless the code has been re-written in a later edition or on the web.
   
   Hopefully Head First's other Ajax book is a lot better to make amends for this lemon, or else I may have to give up on this series. That would be a shame. I agree with the series' stated educational precepts. Learning should be engaging, thought-provoking and fun, but folks, the code needs to work(!) or else it quickly stops being fun.

5 comments about VBScript Programmer's Reference.

1. This is an outstanding book. At first I was confused by some of the older reviews, until I realized that Amazon is still selling the old 1st edition, and many folks are buying that one instead of the newer, much better Second Edition.
   
   Be sure you're buying the Second Edition! That book's ISBN is 0764559931. It's the one with the picture of three authors on the cover.



2. I bought this book, as I wanted to write some simple VBScripts to help automating some laborious manual process for my job. This book is so easy to browse through and as I already have some knowledge of VB Programming and so I can easily browse through the chapters. Even for a beginner this is a good book to start with. I could start writing the scripts I wanted for my job and I like this book so far.



3. I owned the first edition of this book, and although somewhat confusing, I was able to learn VBScript from it with some time and patience. Thus, I just expected the second edition to be an update of the first. I was very pleasantly surprised to see that the second edition had been greatly improved. There are clearer and more frequent examples, the text is an easier read, and there are frequent and illuminating illustrations.
   
   Chapter 1 covers the basics of VBScript and is also a crash course in programming basics, since the authors realize that nonprogrammers such as network administrators and web designers might need to work with VBScript. Chapter 2 talks specifically about what VBScript can and cannot do, and points out that VBScript is part of a bigger programming world - that of Visual Basic. It points out what can be done with VBScript in the world of both client-side and server-side web scripting. The next seven chapters are a detailed tutorial on all aspects of the VBScript language - data types, variables and procedures, flow control, error handling, objects, classes, and regular expressions.
   
   The application section of the book begins in Chapter 10 with client-side web scripting by showing how Internet Explorer and VBScript can be combined on the client-side to create interesting HTML pages for website visitors. The book goes as far as introducing scriptlets, behaviors, and HTML components. However, since these subjects are broad and deep the book focuses on small examples and covers only the major techniques. Internet Explorer does not allow a script to interact with the local computer unless the user explicitly sets these permissions, and by doing so, enables enormous security risks. Thus, Windows Script Host is discussed next with illustrations as to how it gives VBScript more power without the security risks. The authors show how Windows Script Host is used to provide Windows platforms with a powerful scripting platform that can be accessed from the Windows GUI and the command prompt. Next, the book explains Windows Script Components, which are XML-based files that contain script code. Within these files you can use any of several scripting languages, including VBScript. The script components are interpreted at runtime, so that they appear as compiled COM components to the calling application.
   
   The next major topic covered is remote scripting, which makes Web applications more closely resemble client/server applications developed in high level languages such as C++. Thus, remote scripting enables a client page to execute a method on an ASP page without navigating away from the current page. Server-side web scripting is the final major topic covered, showing how your applications can become very powerful and reusable modules within the enterprise. To this end, the chapter first discusses the HTTP protocol, followed by a tutorial on Active Server Pages.
   
   In summary, I highly recommend this book both as a reference and a tutorial for the VBScript language as well as a practical guide on its application.



4. I've been using this as my "go to" source for all things VBScript since the 1st edition came out - it is clear, well organized, and concise. Unlike other VBScript books (of which I have the misfortune to own several), it is focused on VBScript as a programming language. When I can pack only one source book to take with me, this is the one!



5. Like most of the reviews here, I liked this book. The information was presented well and the examples were good. Once I had read the chapters I was going to read though, the book became a bit useless. If you look something up in the index, it will send you to pages where the word happens to be used, even if it was only used in passing. It's like they used a vbscript word-search to create the index. Totally useless. The appendix that is supposed to be a reference is organized by types of things like file system objects, or WMI objects. This is great if you're browsing, but if you're actually looking for something specific, you're SOL. The appendix is not even covered in the useless index. Good read though.