Industrial-Sized Deals Books Gift Guide Books Gift Guide Shop Men's Athletic Shoes Learn more nav_sap_SWP_6M_fly_beacon Indie for the Holidays egg_2015 Fire TV Stick Beauty Deals Gifts Under $50 Amazon Gift Card Offer minions minions minions  Amazon Echo Starting at $84.99 Kindle Black Friday Deals Shop Now HTL

Your rating(Clear)Rate this item

There was a problem filtering reviews right now. Please try again later.

17 of 17 people found the following review helpful
on October 30, 2006
"ppk on JavaScript" fills an interesting void with the focus of today's JavaScript books. Most books either focus on "JavaScript in 21 Days", "JavaScript - Complete Reference" or "AJAX". This book covers techniques for creating clean and accessible JavaScript functionality.

The book's stated audience is someone who knows at least some JavaScript - a beginning level or up. Basically, you should feel comfortable reading and understanding code. I think the book might be a little overwhelming for a beginner to understand. A beginner could read it twice - once right away and once after reading another JavaScript book.

The author views JavaScript as a technique to add usability. He shows how to create "unobtrusive" JavaScript. In other words, the JavaScript stays out of the HTML page and the page works without JavaScript, albeit with less functionality.

Eight case studies (real life examples) are used throughout the book. The author points out why he selected certain techniques. He also notes bugs and where he would have done things differently. I particularly liked the emphasis on separation of concerns.

Keyboard users are also discussed from an accessibility point of view in several chapters. In other chapters, only users without JavaScript enabled were discussed. I would have liked a little more consistency with how accessibility was treated.

Overall, the book was very good. The tips were useful and I enjoyed the emphasis on design. And AJAX is discussed from the point of view of how it was used before it was called AJAX.
0CommentWas this review helpful to you?YesNoReport abuse
20 of 21 people found the following review helpful
on October 12, 2006
It's funny, from looking at the title of the book, "PPK on JavaScript", you would never know it is one of the most interesting and informative JavaScript books on the market. PPK - Peter-Paul Koch is a well-known JavaScript and web developer from the Netherlands. His website [...] has pretty much been the defacto standard resource for all browser and JavaScript issues for the past few years. If there was something you wanted to know about JavaScript or some browser bug or issue you would go to his website or email him. He probably is not known unless you read some of the well-known development blog sites. He does not do public speaking at web conferences (unlike Jeremy Keith), but maybe after this book he will. And yes, most people it seems just call him PPK, not Peter so I guess that is one of the reason of the book title.

Anyways, on to the book review...Since I have most of the latest JavaScript books that have been published the past year, I was hoping this would be a little different, which it was. The skill level for this book is probably leaning towards the intermediate side since many of the code-snippets that PPK talks about use DOM syntax. Though that is not to say that if you're a beginner you shouldn't buy this book, but you will need to fast-forward to the middle of the book (Chapter 5), which he gives a great background of the Core concepts of the JavaScript language.

So basically the book is split into 3 sections (or how I see them separated). The first 4 chapters goes into high-level topics that are great for the basic DOM scripting who knows the basics of using the DOM but needs more instruction with usability, accessibility, standards and how the different layers (structure, content and presentation) work. These 4 chapters are the best in my opinion because most of these topics would require you to search endless articles on the web to find them. Apart from a few pages in the 5th edition of JavaScript: The Definitive Guide, I have not seen this in any other book. Chapter 5: The Core; covers all basics of the language to get anybody up to speed or use as a reference. The rest of the book covers topics such as the BOM (Browser Object Model), Events, DOM (Document Object Model), and CSS modification. The included source examples are the real gem of the book since it is real JavaScript applications that were used in real clients, not just little code examples that cannot be used in the real environment.

So if you need another JavaScript book and not sure what to get, or you have bought Jeremy Keith's excellent book (DOM Scripting: Web Design with JavaScript) and want to learn more about the DOM and accessibility or you are a newbie and want to learn the latest JavaScript standards and practices from a real developer, then this is the book for you. Go out and get it now!
0CommentWas this review helpful to you?YesNoReport abuse
4 of 4 people found the following review helpful
on March 26, 2008
I bought this book because I was familiar with the author and his website, quirksmode. I figured this guy was a master of JavaScript and a book written from him would be a solid resource to learn from.

Well, I was half-right. Early on in the book he presents a script and says that you should know what it does before reading his book. Well, I knew what it was, but it's not the truth. This book is all about technique and execution. He shows innovative and great ways to implement code, but you have to know how to write javascript first. If you're not an experienced programmer or are unfamiliar with javascript, you may want to consider this book...after you've gotten a proven beginner's manual and gone through that first. Head First Javascript or Javascript in 21 days are good examples.
0CommentWas this review helpful to you?YesNoReport abuse
7 of 9 people found the following review helpful
on August 1, 2007
PPK on JavaScript by Peter-Paul Koch might just be the most thorough JavaScript book I have read. Through the use of eight real-world example scripts, PPK walks us through JavaScript from the very beginning. Over the years JavaScript has had its ups and downs. This is mainly due to the flux of poorly optimized scripts that are scattered around the Internet. So how do you know what source to trust? What are some best practices for JavaScript? How can you utilize JavaScript to add enhancements to your site without breaking in the browser? How can you create scripts that will enhance the user experience and not hurt it? All of these topics and more are discussed in this book.

Throughout the ten chapters and 499 pages of this book, there is very little that isn't covered on the topic. Let's take a look at the organization and flow of the book:

This chapter paints the big picture for us. There is no jumping into scripts or coding in the first few chapters. Here we get an overview of some important aspects of JavaScript. One of the most important aspects is the coverage of the history of JavaScript. Though some might find this to be boring, I believe it to be invaluable. Understanding the history of JavaScript gives you a better idea of how it has formed into the language it is today. This is one of the most valuable parts of the book. It sets a solid foundation for everything else that is covered.

Along with understanding the history, it is good to see where JavaScript fits into the big picture of web development. Here we take an in-depth look at HTML, CSS, and JavaScript. There are many distinctions to be made here as each could potentially mix with the other. It is important to keep a clean separation of your structure (HTML), presentation (CSS), and your behavior (JavaScript). At some points the line may become blurry on mixing the two, which is why each aspect is discussed in detail. These include separation of presentation and structure, separation of behavior and structure, and separation of behavior and presentation.

Not every user or device has JavaScript enabled. Moving forward we look at the impact on accessibility and how it affects things such as no mouse, screen readers, and usability. These are all important pieces that must be addressed as we begin adding advanced functionality to our website.

Lastly we are introduced to the eight example scripts that we will encounter: Textarea MaxLength, Usable Forms, Form Validation, Dropdown Menu, Edit Style Sheet, Sandwich Picker, XMLHTTP Speed Meter, and Site Survey.

This chapter provides a little more context and history into the different browser families. We look not only at browsers but other devices such as mobile phones and screen readers. We look at each of these and are then shown some of the incompatibilities that they suffer. We address the problems and look to build solutions to patch the holes. Next we look at solving problems by using two different techniques: object detection and browser detection. Object detection works by checking if the methods you are using are supported before you use them. Browser detection tries to detect the current User Agent and then build from there. Browser detection has many flaws associated with it. One specifically is browser spoofing where you can send a different User Agent string to the server, lying to the application about the available technology. There are correct uses, but this should mostly be avoided.

If you have been developing JavaScript for a while then you are probably used to using the alert method to help in the debugging process. Here were are introduced to debugging, figuring out some of the cryptic messages returned by the browser, and how we can deal with browser bugs.

Planning is important for all projects. Here we are introduced to preparing our application for enhancements. This involves having the proper placements of hooks. Hooks are found by using an ID, class, custom attributes (not a widely accepted solution), and name/value pairs.

Once we have our hooks in place, we have to get access to them to make our modifications. Having access is only part of the process. We also have to learn how to generate content when necessary and understanding the relationships inside of the DOM. We get a brief primer on setting up our script tag and how we can utilize multiple scripts if necessary.

Our hooks are in place, and we know where we want to apply our effects. How and when should they fire? We stop to take a look at the initialization of scripts and the load event. This method has its pitfalls, which are discussed and alternate solutions are addressed. We take a look back to the example scripts for some more insight and real-world use cases.

Everything we have done to this point hinges on our ability to actually program the functionality we are trying to achieve. This section walks through the basics of programming in JavaScript. We look at statements, comments, code blocks, operators, values, and case sensitivity. Next we look at the six different data types that are available to us, and how JavaScript handles conversion and concatenation. We look at ways to explicitly convert our data types when necessary. After looking at the data types we look at some of the common operators. These are inherent to every programming language, so there isn't much new in this area. We've looked at the constructs, now we move to discussing variables: proper naming, the var keyword, and variable scope. This is very important to grasp as we move forward and create our own functions to achieve our tasks. Next we look at working with numbers, strings, and booleans inside of our scripts. We have a good foundation, now we move to control structures such as if, switch, for, while, do/while, break and continue, and try/catch. The next few sections focus on defining and working with custom functions, creating and defining objects and their methods and properties, and finally dealing with arrays. The section on arrays is especially helpful as it discussed how you can loop over them and how you can add, delete, and locate specific sections inside of an array.

This section looks at the Browser Object Model and the window object. We take a look at the global window object and its impact on creating new pages and cross communication between windows. We then look at navigation within the window and the location and history. We learn how to manipulate the geometry of the window, and how to retrieve information about the current window dimensions.

The chapter rounds off with discussion of some miscellaneous functions such as alert, confirm, prompt and timeouts and intervals. We take a closer look at some of the available methods for the document object. Finally, we take a look at working with cookies and utilizing/managing them within our application.

This is probably one of the most important sections of this book. This section gives a thorough look at all of the available events. The chapter first starts by looking at some compatibilities and how to resolve them case by case. We take an in-depth look at all of the available events at our disposal and how they work. We look at event registration and the best way to handle it. The rest of this chapter discusses event bubbling and capturing and the browser support related to each, the event object and its properties available to us, targeting your elements, and then implementing some of our new-found knowledge in the example scripts. Sometimes grasping events and event registration can be tough, but this chapter makes it easy through illustration and the example scripts.

We have come a long way to this point. We have set our foundation, looked at the core of JavaScript, examined the browser window and its properties, and learned how to set our events in motion. Now it is time to look at the Document Object Model. The DOM holds all of the information inside of our pages. It is comprised of all elements and attributes and their relationship to one another. They are commonly referred to as nodes that build the family tree. Understanding of this structure is what gives us the power to build elements and insert them or delete them. We have full control over our internal structure.

However, it is never that easy. Traversing the DOM can sometimes be painful, especially when you see some of the differences between browsers. We take a look at how to find our nodes, how we can retrieve information about those nodes, and how we can change our document tree through appending, inserting, removing, and replacing. We are also introduced to creating elements and creating text nodes, and then how we can achieve some of the above tasks.

This chapter rounds off with the always heated discussion of the use of innerHTML, finding attributes and setting their values, dealing with text nodes - even empty text nodes that sometimes cause confusion, understanding and traversing the nodeLists, and dealing with forms and the Level 0 DOM. All of these pieces help us put together the big puzzle as we are using JavaScript to manipulate our pages.

CSS Modification
Earlier we discussed the aspect of keeping your presentation separate from your behavior. This chapter discusses best practices for working between the two. We learn how to get style information from our elements, and then how we can add classes dynamically. We take a brief look at the possibility of changing the entire stylesheet via JavaScript. While this is a nice introduction, I think it would require a specific project.

The last parts of this chapter look at some examples of keeping the clean separation, but applying some visual enhancements. We work through some examples of toggling display of elements, animating elements, and changing the dimensions and position of elements.

Data Retrieval
This chapter is all about AJAX. We look at the XMLHttpRequest object and how to make it work cross browser through some conditional checks. Once we have sent the request, we need to know how to handle the response. We look at the different statuses and response codes that we will be dealing with and how to set callback functions to handle the response. We look at the available return formats such as XML, HTML, JSON, and CSV. The final part to this chapter looks at the impact that AJAX has on accessibility.

This review alone does not do this book justice. This book thoroughly discussed each and every aspect to JavaScript, from its history to looking to its future. The example scripts helped to grasp the different concepts, but the real meat of the book was in the specific coverage of each aspect. There are many books about specific aspects of JavaScript, but this book combines them all into one resource. If you are just getting your feet wet in JavaScript, then this book is the perfect book to help take you to the next level.
0CommentWas this review helpful to you?YesNoReport abuse
3 of 3 people found the following review helpful
on August 28, 2007
Javascript has been around for a while but it is still going places. ppk on Javascript sorts through all the fluff to deliver rock solid information. The author is using a very clear language to express his deep experience in this field.

Javascript is moving fast and the book does not cover some of the recent advances like the rise of Ajax, ActionScript, Tamarin. It is still a must read for any serious (javascript) programmer.
0CommentWas this review helpful to you?YesNoReport abuse
3 of 3 people found the following review helpful
on December 31, 2006
Found a lot of interesting bits and pieces in this book that complement or reference the author's excellent [...] web site. Wouldn't recommend this book as a general tutorial or reference, but for filling gaps with important but little known facts. The author puts a lot of emphasis on doing things "the right way", but he always remains pragmatic (e.g. by not refusing to use the "innerHTML" property).
0CommentWas this review helpful to you?YesNoReport abuse
2 of 2 people found the following review helpful
on February 17, 2008
This book talks about scripting the DOM. Everything is clearly exposed : the history that make browsers like they are and not better, the tree behind an HTML document and the nodes behind tags and attributes, how to use css properties for the best, and how to manage events and their properties in all browsers, and of course the core of the javascript language.
There is nothing about objects and all other OOP stuff, so I think this book is very well suited for beginners. But specialist will also find a lot of interesting things.
One more advantage, the presentation and layout are really more pleasant than what is generally found in this category's books.
0CommentWas this review helpful to you?YesNoReport abuse
17 of 24 people found the following review helpful
on January 19, 2007
I've been happily using ppk's website, quirksmode, for years. So when I saw his first book advertised on Amazon, I immediately pre-ordered it and waited anxiously for it to arrive. After reading through most it, I was really disappointed in its lack of more advanced topics.

Mr. Koch admits that the book doesn't cover every topic and is meant to address the real-world situations we web developers encounter. The problem is that, for JavaScript vets like me, I wanted this book to give me a deeper understanding of how using objects and, say, prototyping, could streamline the time it takes for me to write good, reusable code for my various projects. Sadly, none of these topics were covered. For a long book like this, it seems there was ample room to have covered these topics in some depth.

I would have given this book 2 stars, but ppk's writing style is very clear and understandable. Mr. Koch is a good teacher and shows a solid understanding of the concepts he's covered. Beginner and intermediate JavaScripters will find this book to be a nice reference with plenty of reusable code. For the more advanced, I imagine you'll discover the book's lack of depth as I have.
0CommentWas this review helpful to you?YesNoReport abuse
2 of 2 people found the following review helpful
on December 26, 2009
Good book for JavaScript beginners, mainly for web designers how are learning JavaScript.

Advantages: Author is well-known expert on differences between web browsers and a lot of them are described in the book. It also covers web accessibility.

Drawbacks: The book doesn't describe object-oriented programming (because author doesn't like it) neither any JavaScript framework.
0CommentWas this review helpful to you?YesNoReport abuse
1 of 1 people found the following review helpful
on July 7, 2013
Since this was written circa 2007, I expected it to be a bit outdated, and it is. HOWEVER, it is one of the easiest-to-understand manuals on Javascript that I have read. Very clear explanations, the logic is very linear, and the examples are very illustrative. I'm traditionally an artist learning Javascript, and was unsure about the logic behind the code. This explains a lot of it and gives you some great ground to stand on.
0CommentWas this review helpful to you?YesNoReport abuse
Customers who viewed this also viewed
JavaScript: The Good Parts
JavaScript: The Good Parts by Douglas Crockford (Paperback - May 2008)


Send us feedback

How can we make Amazon Customer Reviews better for you?
Let us know here.