Professional JavaScript for Web
Developers (Wrox Programmer to
Programmer) by Nicholas C. Zakas
Write Performant And Efficient Javascript
This eagerly anticipated update to the breakout book on JavaScript
offers you an in-depth look at the numerous advances to the techniques
and technology of the JavaScript language. Youll see why JavaScripts
popularity continues to grow while you delve through topics such as
debugging tools in Microsoft Visual Studio, FireBug, and Drosera; client-
side data storage with cookies, DOM storage, and client-side databases;
HTML 5, ECMAScript 3.1, the Selectors API; and design patterns including
creational, structural, and behavorial patterns.
Personal Review: Professional JavaScript for Web Developers
(Wrox Programmer to Programmer) by Nicholas C. Zakas

This is currently my favorite book on JavaScript.
Zakas doesn't pull any punches. It took me a while to work through some
of the chapters, primarily Chapter 5 (Reference Types), Chapter 6 (Object-
Oriented Programming) and Chapter 18 (Advanced Techniques) because
of the difficulty of the material. This is a good thing: the difficulty is due to
the sometimes non-intuituve aspects of JavaScript (i.e., function binding
and currying), not to any possible failure on the part of the author. His
command of his material is evident in his ability to explain these difficult
techniques, which can seem overwhelming at first blush. I really like that
he doesn't insult his reader's intelligence by sticking with the easier-to-
understand aspects of JavaScript but covers the most advanced
JavaScript topics thoroughly. I expect to be challenged when reading a
book on JavaScript, and taking time to work through the examples by
stepping through them in Firebug is well worth it and what I look forward to
doing. I don't like when I can read a book and not have to touch a
keyboard to understand the material.
I especially love the chapter on OO programming and how he breaks down
each OO pattern. He starts with the most basic example of inheritance
and works up to the best-case scenario, always giving the pros and cons
of each pattern along the way and when each pattern could be employed.
In doing so, he provides an invaluable service to those who want to
understand how libraries are engineered. I remember when I first was
looking at the source code for a particular library, and I was completely
baffled by what I saw. For example, I would often see this:
MyClass.superclass.constructor.call(this);
There was no explanation to what this esoteric statement was doing. Now,
after reading the book (actually, at the time it was the first edition of the
book), I understand that this is known as constructor stealing or object
masquerading, and I now know that it's used to inherit instance properties.
I had many, many moments like this, and now when I look at source code I
can intelligently follow it and understand its intent.
This book empowers the reader with new knowledge. This is especially
important when more and more I encounter front-enders who feel that
knowing jQuery is knowing JavaScript. I remember when I first began
looking at JavaScript libraries I was completely overwhelmed; from that
moment I resolved to learn the JavaScript language inside and out if I
could. Then, I'd go back to the libraries. Well, that has paid off in spades
now, and I feel completely comfortable working in any library knowing what
they're doing under the hood (and I have worked with several at different
jobs). In fact, I write my own library in my spare time, and I never could
have begun to do that or understand how to do that without books like this
one and others.

I also love how Zakas gives the back-history to all the subjects he covers.
Knowing where stuff came from is important, even if I would never use it.
For example, I never knew there were HTML methods, and if I were to
have come across them in the legacy code that I support I would've
thought that they were user-defined methods. Now I know better.
Knowledge is power.
I work on a team composed of Java developers, and this book has helped
me to better communicate with them. I love how Zakas talked about how
the Array methods can act as data structures. That's very important for a
book to cover. Giving comparisons to other languages and emphasizing
the similarities and how one language can translate to another is another
way that this book has empowered me. It's much easier for me now to
convey ideas to my teammates when I can express things like, "JavaScript
doesn't have block-level scope like you're used to, but that's what
anonymous functions are doing and that's why you see them here...", etc.
Lastly, the expanded chapter on Best Practices is invaluable. I've already
employed them in my own work and have gotten the wheels in motion to
do what I can at work (gzipping and including compression in our build
process).
If you're left a little or a lot puzzled about prototypal inheritance, closures
and OO programming in general, get a copy of this book and devote time
to it. You'll walk away completely confident that there isn't anything out
there that you can't figure out, as I did.
P.S. I suggest reading this book cover-to-cover, even if you feel like that
doesn't apply to you. Zakas is very thorough in disseminating lesser-
known aspects of both core and client-side JavaScript. In fact, there's so
much that I'm going back for a second-helping.
For More 5 Star Customer Reviews and Lowest Price:
Professional JavaScript for Web Developers (Wrox Programmer to Programmer) by
Nicholas C. Zakas 5 Star Customer Reviews and Lowest Price!