If you have some Javascript experience, have hit the cross browser issues, and now are looking for the Prototype and Scriptaculous libraries to take away some of the pain then this is a great book for you. Christophe takes you through the entirety of the API with a very readable book. When a new method is introduced short examples are given that show not only how to use the call but also provide the context of how the functionality might be used in a real world web application. Christophe often explains why a particular technique is needed and explains the cross browser issue that it works around. This book also amazingly teaches some tricky Javascript concepts extremely well. For example, this book has a section explaining binding loss in Javascript that is better than anything I have read anywhere else. Also, Christophe apparently teaches at a University and it shows in the writing style - the end of each chapter has a really nice "what we learned" summary that really wraps things up nicely - if you need quick insight into what a particular piece of the API offers I would recommend heading to these "what we learned" summaries for a quick review.

In summary I recommend this book highly for the Javascripter with a Javascript foundation looking to take things to the next level with Prototype and Scriptaculous.

I set out to read this book from start to finish to understand what the Prototype and Script.aculo.us libraries were about, but before I could I found myself needing to use them, and the book was an extremely useful resource. The book compliments the online resources nicely, explaining not just what to do, but why, and how to do things best. This book does an excellent job of straddling the line between reference and introduction. The writing style is readable enough that you can read a few chapters just to get a sense of what to do, while at the same time, terse enough that you can find what you need quickly. If you are using JavaScript, get this book to help yourself from re-inventing things.

I learn best by example, and this book has a but a precious few. Most of the book is a glorified API documentation. I was really looking for a book with a lot of ajax examples ( or even non ajax ones ) but it seems this book does not fit the bill.

I approached this book with the expectation that it would teach me in the traditional gradual fashion. You start with some accessible portion and build on the rest. Well, he just starts out of the blocks at a full dash--full complexity--and you really don't know where to begin to understand what he's showing you. So, though I'm sure I could have taken some of his examples and used them, I feel like I did not really get an understanding of the WHY you do it this or that way. So, the ironic effect is that you will benefit the most from this book if you already know how to use these libraries. If you have never used them, then you will be on your own. So, this is NOT an introductory book.
Frankly, I have a good ten years experience using JavaScript and walking the DOM. So, I know my way around client-side scripting. I just felt like the introductory chapters were missing. You're expected to jump right into the hard-core stuff with no buildup, no gradual accumulation of the basics of this library. He was trying to prove how cool the Prototype and Scriptaculous libraries were and so he skipped the actual bones of the book. He skipped to the end and omitted the buildup. Buy this book wtih that caveat, in my opinion.

'Prototype and script.aculo.us: You Never Knew JavaScript Could Do This!' is a wonderful reference for learning how to use Prototype and writing better and more powerful Javascript code. Pragmatic has a history of publishing good books that are full of stuff and not fluff and this book follows in that tradition. After reading this book you will learn more about this efficient library that makes things easier for web developers, doing things like dragging and dropping, autocomplete code, and event handling that is better than ever before!

Content is spread over 400 pages and 20 chapters. The writing is solid and right to the point.

If you are a Javascript programmer that is looking for a better way to do things, pick up this book and enjoy.

***** RECOMMENDED

I received a review copy of this book, and was able to use some of the code examples to jazz up a site I was building. The examples are very well written, and the code works. If you are into programming in javascript, this book is worth a look.

This book builds upon the existing Prototype documentation found at http://prototypejs.org/api by putting the API in context. Other than the fact it uses Ruby for the server side examples (I'm sure everyone who reads it will have a differing opinion there), I have to say it was one of the most helpful programming books I've read. The short usage examples that were neatly tucked into the text were very useful and I found myself reading it almost like a novel and able to soak everything in without needing to download or code them out.

I began using Prototype during the middle of last year when it was in version 1.5. There are many welcomed updates in v1.6 and the author does a good job of filling the reader in on the important changes.

I recommend this book to anyone who might have dabbled in Prototype and is looking to take it to the next level. I also think others like myself will benefit who have been using v1.5 and are looking for a good excuse to stay up to date with the framework.

Oh and it covers Scriptaculous too which is great because the web documentation is seriously lacking compared to Prototype and jQuery

Reading this little piece of work is a great way to very quickly learn the nuts and bolts of Prototype and Scriptaculous. This book is long on code and short on deep explanation and banter (for better or worse; hence "pragmatic programmer").

My background: I'm not a ruby programmer. I program in ASP.NET and I recently accepted a job where I needed to quickly learn prototype. When I settled on this I didn't realize that, along with choosing an intro book, I was also choosing a Prototype/Scriptaculous coding cookbook.

I couldn't tell you how many times the authors displayed a line of code and I analyzed the code for a moment then thought "A ha!" because they demonstrated a clean and concise way to do exactly what I needed to do. Segments of code that I had written that were 25 lines code be shortened to 3 or 4 due to their examples. In javascript the less code that needs to be downloaded to the client the better, so obviously any code reduction w/o affecting performance is a good thing.

My only criticism is perhaps the authors might have added a touch more coding explanations for complex code. Sometimes I would read a line of code and be totally lost as to how it functioned (which is essential if you want to reproduce said code on your own), and there would be little in way of explanation in the book. I quickly overcame this by supplementing the reading with the online documentation, which explained any prototype methods which might not have been thoroughly explained by the authors. I should probably iterate that this happened relatively few times overall.

I had heard of Prototype before, but had not begun using it until this book. I bought it after seeing the recommendation on the official Prototype site and I am glad I did. Book provided an excellent learning pace, practical examples, and an extensive resource in a very concise and easily readable way. Good buy for a developer's collection!

This book goes deep into Prototype and Scriptaculous' wonders. Follow some good code examples of draggables and slidables and other JavaScript special effects. Learn how they work and how to make them look splendid.

Following the advice in this book you'll aquire some serious JavaScript-fu, making your code clear, concise, unobtrusive, working in all browsers and achieve wonders very fast.

Overall a very handy book to have near whenever a JavaScript task comes up.

This book was a fantastic overview of all the various bits of the Prototype library. Clearly written and filled with useful examples this really helped catapult me into more professional Prototype usage.

The Pragmatic Programmer's have a solid (although short) history of turning out amazing books on the latest development technologies and techniques loooooooong before other publishers even start looking for authors on the subjects. I own about a dozen Pragprog books and have yet to be disappointed.

Just month or so before the release of this book Prototype 1.6 came out (with some major changes to Hashes and Events). I was beyond impressed with the book was updated to reflect these changes. Most publishers would have released the older version and come out with the 1.6 version of the book just in time for 1.7! This is the type of quality service you can expect from these folks.

My one major beef with the book is the topic of building custom classes. I really think this is where most developers are headed when working with unobtrusive javascript. "Classes" (really a abstraction created for programmer convenience since javascript isn't a class-based language) is the major advantage Prototype has over some other javascript libraries. Creating reusable classes for dealing with common, repeating parts of your site that you want to enhance with javascript is an excellent way to cut down on the amount of javascript you write.

Classes get only 8 pages attention, otherwise this book would have been a perfect 5.

§

The author has a fluid, confident, and even literate writing style that is rare in books of this nature. It is a loss that he did not direct more attention to the motivation behind using these two JavaScript libraries. However, if you are an experienced object-oriented programmer ready for some heads-down JavaScript syntax, this book may be for you.

If you need reasons *why* you should be using libraries instead of rolling your own and if you want to know *why* you should be sweating to learn Prototype and script.aculo.us in particular, then this book is not for you. If you like to see code in the context of real Web application situations and challenges, then this book is a heavy slog indeed.

You can't help but ask yourself these broader questions when you see the simple drag and drop example. You wonder *why* you would want 5 script files totaling 200,000 bytes to do something you could have accomplished with far less code. You wonder *why* the author gives this example which fails in such a spectacular manner in IE6.

Actually, several of the downloadable code examples failed in interesting ways in IE6 and failed in very boring ways in Opera 8 under WinXP. For most of us making a glamorous living coding Web applications, failing in IE6 is not an option. Since cross-browser coding is one of the recognized strengths of using libraries of this sort, I have to conclude that this book does not make a very good case in the end.

§