Spotlight customer reviews:
|
Customer Rating: 
Summary: The Perfect Javascript/DOM book for beginners
Comment: When a Javascript/DOM book:
1) ..starts by introducing Javascript and it's syntax instead of jumping into DOM immediately.
2) ..Explains every single bit of code in a simple language.
3) ..uses simple and easy-to-follow code.
4) ..Starts a chapter with a very simple program and build on it as you read.
5) ..lets you put up your first useful/practical Javascript script in a few hours.
6) ..encourages you to 'understand' the code instead of 'memorizing' it
7) ..is written by Jeremy Keith
..Then you know it's worth every single cent you spend on it. I have nothing to say here except that if you're someone who knows nothing about Javascript/DOM and is willing to learn it, then you really shouldn't miss this book. But If you're an intermediate or advanced Javascript/DOM coder, then buying this book is not a good idea. It was solely made for begginers.
Customer Rating:
Summary: Very clearly written and well structured
Comment: This book is an excellent example of what computer books should be. The writing is concise and understandable. The book is structured as a series of chapters starting with the basics like Javascript syntax and history, then going on to more complex topics on utilizing the DOM. Each chapter states at the beginning what will be covered and has a brief summary at the end. The author does a great job of describing what the DOM is and isn't. The examples are clear and well explained. Then, to top it off, there is a DOM reference at the end of the book so I can quickly find and implement commands.
This book is the standard to which all other computer books should be held. Buy it. Even if you aren't interested in the topic. This guy deserves your money.
Customer Rating:
Summary: The perfect Javascript Book for today's world
Comment: I recently purchased this book to get a better grasp of using Javascript "correctly". Jeremy does an incredible job of pointing out the horrid past of Javascript and opening a path to the best practices to create unobtrusive and gracefully degrading scripts that compliment, rather than control your web pages.
His examples are well thought out, revealing techniques slowly, and returning to improve them step by step. The end result is what I would call "the perfect script", and I now am left with the task of going back and fixing all my years of mistakes!
One thing to point out. This book is not a reference manual for javascript syntax. It is exactly what the title says and I am very pleased with this book!
Customer Rating: 
Summary: Separating behavior from content: great design (code can improve)
Comment: The intent of the author is to show how JavaScript, with the DOM Api, can indeed be used in an intelligent way, debunking the myth (somehow justified by the horrific javascript code laying around) that "scripting languages" are somehow inherently inferior to compiled ones. Incidentally, this effort is similar to what Damian Conway has recently done, in a larger scale, for Perl ("Perl Best Practices").
The book is at its best when it describes how to methodically partition the design of a web page in 3 areas: the content-markup (xhtml), the presentation (css), the behavior (JavaScript, DOM). Jeremy Keith achieves this not by abruptly inflicting the reader with massive dosis of W3C standards, but rather "by evolution", taking one example (an "image gallery") coded in the traditional way, and continuously improving and refining it. Incidentally, the web pages that emerge are of a stunning beauty.
The book has its weak moments; I mention only two of them, one on the theory, the other on programming:
1) an apparent inconsistency on the properties of childNode[] array. After having repeatedly stated that this array contains ALL the children of an element node ("including the attribute nodes", see p. 67), it suddenly states (p. 70, p. 154, etc) that the text node of a paragraph node is the first and ONLY node of childNodes[]. Some tests (using elements that had attributes) confirmed that this last statement was correct. So, apparently, the childNodes[] array of an element does NOT report its attribute nodes, contradicting the first assertion.
2) the function "showPicture()", the central routine of the example that runs across all the book. All is fine, until Jeremy suddenly decides to change (ch 6, p. 106) its return to "true" when the function fails, and "false" when it succeeds. This is done in order to easily propagate the indication to the browser whether to follow the link or not, but... let me put it this way: would you write routine "start_shuttle()" to return "true" when the requested action fails, just because it makes life "easier" (?) for some intermediate caller routine? let's hope not (for the astronauts' sake).
Furthermore, as show Picture() had multiple returns inside, each one of them had to be tweaked in the "tricky" way; contrast this potential maintenance nightmare with instead returning the right value and simply switching it in the caller. The code (a la D. Conway "self-documented" way) could be:
"var followLink = ! showPicture(); return followLink".
A comment can be added to remove any residual doubt for people maintaing the code in future: "if showPic() succeds, tell browser not to follow the link, and viceversa".
I want to underline that, while the code is sometimes of poor quality, the design of the software of the examples is excellent, way above anything else that one sees for JavaScript. Separation of "behavior" from "content" was not an empty slogan; by chapter 7, the goal is reached. Not only all the JavaScript code is out of the html page, but even the elements that were not strictly "content" are out (they are now dynamically created).
And the page works without a glitch ("gracefully degraded", as Jeremy says) even if JavaScript is disabled (or if it is a robot reading it, etc). Fantastic.
I therefore reccomend this book to anyone interested to a methodic introduction to client-side programming with JavaScript and the DOM. A good Css book (like the one from Lie & Bos, to reach exactly the same objective on the presentation side) can be a great companion, on this trip to greater things (Ayax & co).
Customer Rating:
Summary: Finally, a book to teach us JavaScript DOM
Comment: There's been a lull in the past couple years with JavaScript books. Even though there are many sites that use DHTML and DOM scripting, there never was any books that really explain how to do these very useful and cool effects. Plenty of websites to download and copy code, but nothing that really explains how to do it. UNTIL NOW!!!
The moment I start reading the first chapter, I knew I would finally learn what DOM scripting really meant. I've read through many basic JavaScript books from different publishers but all of them just briefly described how the DOM worked in one brief chapter. The whole DOM Scripting book talks about it.
The first 2 chapters are a brief refresher course of the JavaScript basics, and then the 3rd chapter starts in with the DOM. After a thorough explanation of what it is and how it can be used, the next chapters go through various projects in reviewing how it can be used in real life web design.
There are eight chapters that explain and show you how DOM scripting can be used. The final chapter talks about the future of scripting and gives examples of AJAX--a great bonus!
I highly recommend this book to anybody who wants to take their JavaScript code to the next level. It's also a great book to help would-be AJAX programmers as well. Since you have to have a very good understanding of DOM to create AJAX applications.
|
|
|
