(You can print this review in landscape mode, if you
want a hardcopy)
Reviewer: Mark Lamendola, author of over 6,000 articles.
Since starting with Website development in 1996, I have read many books on
Amazon. The other two are CSS3 Foundations
and HTML5 Foundations, by Ian Lunnt and Jon
book. With this background, I have some relative basis for judging the book in
addition to judging it just on its own merits.
Since the negative aspect is so small, let's just get that out of the
way. As with other technical books, this one has its share of grammatical
errors. Even so, the number of them is surprisingly small for this genre.
And they don't interfere with comprehension.
There's another negative aspect, but it's beyond the control of the
author. Let me explain it with a similar situation. I write articles about
the National Electrical Code (NEC). The current NEC runs 829 pages, not
including its index. Obviously, the typical electrician doesn't carry a copy
in his pants pocket. And the NEC is notoriously complex, difficult to
understand, and tricky to apply.
Many years ago, a colleague of mine (Fred
Hartwell) gave an excellent presentation on an NEC topic. An attendee told
Fred he hated the presentation, because it was too complicated and what Fred
needed to do was focus his efforts on getting the NEC code-making panels to
simplify the NEC. Fred responded that the application of electricity is
complicated, and addressing those complications is what makes the NEC
complicated. When Fred told me this story, I suggested we should get started
right away simplifying electricity by eliminating a dozen or so laws of
physics. Laugh, laugh....
Complication is inherent in some topics, and thus with writing about
really programming languages for Web developers. There is no way to make the
explanation simple. That said, it is possible to lay the groundwork in a way
that is simple enough for the reader to understand the basics. This is what
Duckett does in this book. If you can understand the fundamentals of
technical information presented in the book.
But that can happen only with a clear, unrushed, "start from the
beginning" explanation of these foundational concepts. And this is exactly
how Duckett begins. The Introduction is lean on text, using a summary style
to get the main points across quickly. I like the graphical organization
technique used here. It helps move the reader right along, rather than bury
you in dense prose or complex diagrams. If only authors of Calculus books
would take this approach!
And it's not just the smart use of graphics for organization that makes
this book stand out visually. I don't think words can do it justice. Not
even words like stunning or beautiful. You just have to see this book. The
graphics aren't gratuitous eye candy, either. They aren't an afterthought
slapped in there to meet the publisher's minimum graphics requirement. They
are integral to the book. Jon manages to mix graphics and text in a way that
makes less work for the reader. And they are really great graphics; the
people who created these (and their names are disclosed on the Credit page)
as masters in their respective crafts.
Chapter One follows a similar pattern of graphics used to make the
material more accessible, but with the complexity level
raised a notch (as I think it should be). But it also raises the helpfulness
of the graphical cues a notch. If you have zero programming or Web
development experience, this chapter gets you in the game. If you've got
that experience, this chapter makes for a good refresher.
instructions. Something that Jon does as he goes along is point out which
way is the preferred practice (and, usually, why). He also says you can do
this or that, but it's a bad practice because it creates this or that
problem; this is something that many coders never learn, and sloppy code is
just a disaster waiting to happen.
The next three chapters take you into a lot of jargon, and there a long
stretches where it seems that all we're doing is learning vocabulary. For
example, yada yada yada and we call that a function. Then yada yada yada and
we call that a method. Then yada yada yada and we call that an object. While
reading through this I was trying to think of how Jon
could have done this part better. This issue takes us back to my earlier point
about the NEC. Or another way of looking at it would be to imagine a medical
student taking anatomy classes and not learning the names of muscles or
other body structures. This just has to be done.
you didn't carefully read and thus understand the previous four chapters you
will get lost here. Getting to the point where you can read and apply
Chapter 6, however, is worth the effort. The payoff is you'll be able to
Web pages. Or, with practice, you can write your own from scratch.
Chapter 7 discusses JQuery. This language gets around some of the
Jon explains the what and why, using examples to help the reader
Chapter 8 is about Ajax and JSON, which might be useful for you. Ajax can
load data into part of a page without requiring a refresh; applications for
it are endless. JSON is a data format commonly used with Ajax.
The next five (and final) chapters cover what I consider advanced topics.
These include error handling, debugging, content panels (something I've
implemented using Project Seven's scripts), filtering, searching, sorting,
This book runs 622 pages (including the introduction). I doubt someone is
going to sit down with this book (or any other) and become a fully competent
best way to use this book is to start doing projects that call for something
it covers. Gee, you want an explanation box to appear when the user's mouse
is over a word (this event is called a "mouseover"). Turn to Chapter 6 and
learn how to do that.
So I see this book partly as a tutorial that gets you going, but mostly
as a reference so you can build from there. Using its index and its table of
contents, you should be able to find exactly the guidance you need to get
the job done.
I highly recommend this book for anyone wanting to go beyond basic HTML
to make Web pages more compelling. There's no such thing as a "light read"
in programming books, but Jon does an admirable job of bringing clarity to