Customer Reviews

HTML5: Up and Running

5 star:		(16)
4 star:		(28)
3 star:		(8)
2 star:		(5)
1 star:		(0)

 

 

I must say: I enjoyed going through this book. It is written in an opinionated and slightly irreverent style, so I found it a mildly amusing read.

That being said: why do people buy a book on HTML5? Some would like to have a good in-depth reference on the ins and outs of the new language. Well now - that's not this book. Others might be new to web development and think learning HTML5 would be a good starting point. While they are right that HTML (5 or 4) is the place to start, this book surely isn't.

There's some depth when it comes to background, but much less when it comes to HTML5 itself or how to use it. True, the <canvas> tag and geolocation are covered pretty much in detail, but the author made some hard to defend choices in spending his paper estate.

HTML5 gives us no more than a handful of new tags, still some of those (<mark> and <section>, for example) are simply mentioned once and that's that. No examples, no advise on where to use them, nothing on browser support. Yet the book takes five pages at the start to tell the story of how the img-tag came into being some 15 years ago. Again, mildly amusing, but probably not the reason you are thinking of buying this book.

Another example: there are 10 pages with a primer on audio and video codecs, plus another 19 (!) detailed pages (with lots of screen shots) on how to use a number of specific and probably soon outdated software tools to encode video for the web. All fine for those who are completely new to video encoding and believe a book on HTML5 should be the starting point for that. But when it comes to the actual <video> tag (under the aptly named heading "At Last, the Markup"), this consists of a meager 3 pages that include a statement like this:

"The <video> element has methods like play() and pause()".

Huh? "Methods like"? So which other methods are there? And how and where would I use them? Are these standardized across browsers? Where can I find more about them? Any example, maybe?

If you think these are the kind of questions a book on HTML5 should answer, you are out of luck. The above sentence is all the information on this particular topic you are going to get. Not a word about implementing these methods, or on how to style the browsers' native video controllers that come with HTML5 support. There are a good number of external references for information on things like Unicode, codecs and video containers, and some useful scripts, but not a word on how we can get the information on how to control and style the <video> tag. Maybe the logical conclusion would be: in another book on HTML5, perhaps?

In the 1970s, ABC's "Schoolhouse Rock" took the tedious process of making a law and distilled it down into a 3-minute song that many of us can at least sing the first few bars from ("I'm just a bill, yes I'm only a bill, and I'm sitting here on Capitol Hill..."). Marc Pilgrim takes a different approach with the first chapter of this book, distilling the early history of HTML into fourteen eye-glazing pages. But if you can muddle through the initial proposal and discussion of the IMG tag, you get to Pilgrim's primary take-away of the chapter: HTML is not so much a thing, but a collection of things.

This is good, because the history of HTML has not been a smooth, step-by-step process. Different releases of different browsers have adopted different features of different specs at different times. I can personally recall rejoicing, back in the 90s, when both IE and Netscape finally implemented support for HTML tables. So it's no wonder that the second chapter dives into methods for detecting whether or not a user's browser supports certain HTML5 features.

If the first chapter was boring, the second is discouraging. First he shows how to check if Canvas is even supported. But once that's determined, you have to check if all the features of Canvas are supported. Moving on to the Video tag, even when that is supported, video format support varies across browsers. Basically, in these early days of HTML 5 support, it's like touring the United States early in the 20th century. Flush toilets and electric lights took longer to come to some areas than others.

After the third chapter started breaking down some of the new tags and how they affect the DOM, my eyes were good and glazed. This book is more discussion than documentation. If it was a car repair manual, instead of merely showing you the steps for changing the oil on your Honda, it would give you the history of the internal combustion engine, then detail different kinds of lubrication systems.

In short, there's a lot of valuable information in this book. Mark Pilgrim is no slouch on technical know-how or understanding of his topic. I just find the manner of presentation to be organized in such a way that I don't feel I have quick access to the information I want or that the available path to acquiring that knowledge is optimal. It's short on lab, long on lecture, and isn't something I'd make part of my permanent library.

This book feels like it was rushed to try to be the first HTML5 book published, the others I have ordered have all been pushed back several times as the specs/APIs evolve, this book was released as-is and it sure feels it. The 'Complete Examples' throughout the book are a mess and require considerable more work to be used as complete examples, they are at best snippets which illustrate very little. Several of the topics I was most interested in reading about were dealt with sparsely (some just in a single paragraph). In short, for an O'Reilley book I am quite disappointed.

As other reviewers have noted, HTML5 is an emerging set of standards at the frontier of the web. Only the most well-heeled of developers want to work on such frontiers, but many people want to know what is coming and how to prepare for it. HTML5's advantages include plugin-free support of video, some new form elements, local storage beyond cookies, geolocation, and the new canvas element that most versions of internet explorer don't support. Someday, perhaps a decade or so in the future, these elements will be widely supported and developers won't have to write two versions of their web pages: one for html5 and one for html4. But it will take a LONG time for all of those people still running XP or Windows 2000 or older versions of the Mac to get there.

My main interest in HTML5 arises because the iPhone and iPad don't support either flash or java. Flash is often used for video, but that can be done via QuickTime and WindowsMedia and I've never needed flash for video. Flash can also produce elaborate simulations or games that interact with users and are not video based. So can Java. But both are excluded on the iOS operating system. The only alternative for web developers is the canvas element in HTML5. Pilgrim gives this important element only basic coverage: He shows how to draw a static graph (including axes and labeled points). He shows how to add images, and creates a simple mouse-driven game. But he does not show the full code for the game -- you have to go online to access that. This is the simplest form of interaction and Pilgrim does not cover anything more advanced. I have no idea if the canvas is double-buffered or if we have to do that somehow in our code, for example. Also left out is any mention of animating a canvas over time. Most of what Pilgrim does with the canvas element could be done with static gifs: The game he implements would be EASIER using html4 with tables.

Pilgrim does present a useful discussion of different video codecs in HTML5 and the challenge of working in this developing world. I have been using H.264 recently because I thought it was an open standard and is available on the iPhone and iPad. However, Pilgrim makes it clear that if I ever "go commercial" with my work, I'll have to pay some serious royalties to the patent owners for the next 20 years or so. The WebM and Theora+Ogg systems don't require any royalty payments, but neither do they work on the iPhone or iPad. (Making advanced material available on the iOS within the web is a tremendous challenge for developers these days!)

In his discussion of the new semantic tags, Pilgrim didn't bother with even a single screenshot of the resulting web page, nor did he contrast different HTML4/HTML5 alternatives. More detail is apparently available in the online version, but that presents its own set of challenges: The online edition is only free for 45 days. After that, you have to buy a subscription.

The publisher for this book is O'Reilly, one of my favorite publishers of computer books. But the cover also states "Google (tm) Press." I felt the ghostly fingers of Google (tm) running through the book. I certainly like the company, but I found the emphasis and the tone to be quite favorable to my favorite search engine -- not as unbiased and objective as I felt it should be.

In summary: The coverage of new features is thin, especially with the canvas element. Helpful illustrations are missing (though available for a short time in the online edition). Code is missing (though available free for a short time in the online edition). The alpine chamois on the cover should have been drawn in a more gaunt form and perhaps with a cast on a leg or two: HTML5 is not up and running, it is thin and limping.

§
The subject of the book is of special interest to those of us making a living from our ability to understand and implement aspects of Web technology. HTML 5 is not our present but there are plenty of very smart people working diligently to make it our future.

This "up and running" series book has lots of code samples but, really, don't pick the book up for that reason. This is a book that does the right thing -- it communicates the *context* of changing Web markup. The author concentrates on the multitude of "WHY's" behind HTML 5. It is an effective advocacy work. Intelligent advocacy is precisely what is needed at this juncture.

This book takes us through a re-examination of Web markup as we know it. We get a chance to inspect things from a different angle not quite visible in our normal work day. That is why Pilgrim's book has value way beyond the code snippets. Daily practice is yet to come. Understanding can begin right now.
§

General

The book is giving good background information in several chapters ("How Did We Get Here?", video etc.). In this sense it is not a cookbook "for dummies".

On the other hand, in other aspects it does look a bit like "for dummies". In some cases it gives an introduction but does not dive deep into details. The code examples explain basically every line of code, even if the same line (or a very similar one) appeared in the example one page before. It is good if you are just diving into a specific example without prior knowledge, however it does get a bit annoying if you are reading a whole chapter, example by example.

IMHO the book is not critical at all towards HTML5. As I read it (and I did not have any previous knowledge of HTML5), a number of serious questions arose in my mind concerning several features of HTML5. Many of these were not dealt with at all, others were mentioned in a few lines towards the end of the chapter. I would expect such a book to deal also with (potential) shortcomings of HTML5.

Recommendation

I am not a web designer/developer but rather a web/software architect, so my point of view is somewhat different than that of developers. Because of that, it's difficult for me to say if I should recommend the book to web developers. One thing I am certain of: I would not buy the print version. Besides saving the rain forest, there are two reasons for that. One is that many hyperlinks to various resources are strewn all over the book, and typing these over is a pain. The other is that as HTML5 is still work in progress, also as far as browser and tool support is concerned, it gets easily out of date. The book was written in May-June 2010, and I reviewed it in August-September. I could already find a few cases when the browser/add-on/tool referred by the author had a newer version. The author maintains a website of updates, but if you need to access the site you might as well use the eBook.

Chapter 1 How Did We Get Here?

Starts at the very beginning. The historic introduction can be for many of the young-generation developers tedious, lengthy and unnecessary, though as an old-school fellow I did find it interesting.

Chapter 2 Detecting HTML5 Features

All in all, a good introduction to HTML5 features. The most important quote of this chapter: "HTML5 is not one big thing; it is a collection of individual features".

The security question concerning local storage (same-origin restriction) - spot-on!

Webworkers, offline web application - neat features.

Chapter 3 What Does It All Mean?

Explanations are really from scratch, and even trivial HTML / javascript code is explained.

Good examination of the importance of semantic elements i.s.o. general-purpose elements such as <div id=""> (meaningless) or <... class=""> (only for rendering, but not semantic).

Chapter 4 Let's Call It a Draw(ing Surface)

Thorough explanation of basic Canvas functionality. Again, keep explaining every little detail.

Chapter 5 Video on the Web

Excellent overview of video containers, video and audio codecs.

Lengthy discussion and demo how to convert your video to all formats.

Chapter 6 You Are Here (And So Is Everybody Else)

Good chapter, good explanation of geolocation and immediately the spot-on question of geolocation and privacy.

Good explanation of geolocation API (getCurrentPosition() and watchPosition()), and of high accuracy (GPS) - pros and cons - in mobile devices.

Chapter 7 The Past, Present, and Future of Local Storage for Web Applications

This chapter can be improved.

The whole security issue is insufficiently covered. To start with, the explanation about cookies disadvantages from security point of view is lacking - it's not only an encryption issue, cookies are vulnerable for both hijacking by a 3rd party AND for manipulation by the user itself.

I miss an entire discussion of security aspects of local storage. This was touched very briefly in chapter 2 (same-origin restriction) and that's it. But how does HTML5 / browsers guarantee that one domain does not mess around with the values of another (read or write)? How do they guarantee that the user himself does not manipulate the values to get something he doesn't deserve? What should web developers be aware of? These issues are very important for every application which uses local storage. Even a game application would want to prevent the user from "promoting" themselves from level 5 to level 23 by manipulating a couple of local storage variables.

Local storage data is stored as key-value pairs of strings. This is really limiting, IMHO, especially if you want to save the whole state of a more complex application. Here I would expect a more critical view on HTML5, which standardized the key-value pairs but not a database solution. I would also like to see a more deep comparison of the other options (Web SQL database vs. Indexed DB). At least there's a good reference.

Chapter 8 Let's Take This Offline

This chapter also lacks a critical view on HTML5. I find the caching mechanism too rigid. This issue is referred to only at the end of the chapter, but IMHO is a big flaw in the caching mechanism.

The caching mechanism is "all or nothing". I.e. if a single page (referred to by the cache manifest) is modified, then one has to artificially modify the cache manifest (e.g. by editing a "version" comment line), and then ALL of the files are being redownloaded. This is an ugly workaround and it is simply stupid!

The rigid caching mechanism is actually suitable only for pure static-content websites, which change only when they are authored or edited. Of course, if you have a lot of dynamic-content pages then caching won't give you much, but imagine a situation where most of your site is static. Let's say, that only one frame in my home page should be dynamic as I want to display there my latest Twitter status; the rest of my site is all static. With HTML5, I cannot tell the app to redownload only that page. Grrrr.

I also miss here a mention of Google Gears caching mechanism for offline apps, which preceded HTML5.

Chapter 9 A Form of Madness

Here, again, the most important issue is touched only at the end of the chapter. I am talking about the validation of specific input types (e.g. email, URL, number) by the browser - currently supported only by Opera.

This is IMHO much more important for web developers than the (marginal) user experience gain with iPhone specialized "keyboards". The validation of email addresses is discussed in length, whereas that of URL is at least as complicated (see also: [...].

Chapter 10 "Distributed," "Extensibility," and Other Fancy Words

Also here I miss a shape critical look on HTML5 microdata. It looks to me as a rather bleak attempt to implement semantics into HTML. Its data model is limited to name-value pairs, and it hangs on the existing HTML DOM structure (not to mention that it requires workarounds of dummy elements such as <span>).

I know that HTML5 probably cannot support a generic <rant> element, but it does not even try. What I would ideally like to see is a mechanism which takes a well-defined semantic XML fragment (based on an XML schema), and together with some XSLT and CSS can render it as HTML.

Microdata can be nested, but it is not as nearly as semantically powerful as an XML schema. In other words, it cannot validate that Person.address is indeed of type Address. It does not have a schema, all it has is a free text description (or documentation). We cannot validate correctness of types, and we cannot enforce that a specific property has a value (or the cardinality of the values).

Annotation of HTML-invisible data with microdata (<meta> tags) is especially ugly. With an XML schema + XSLT it would have been much more natural. The schema determines the semantic data, the XSLT determines what is displayed and what not.

Microdata is comparable to Twitter annotations ([...]). Both have similar data model - type (namespace) and name-value pairs. However Twitter annotations are produced by applications and consumed by applications. Control on validation and correctness is much more centralized. HTML5 microdata is authored by millions of webmasters and consumed by either browsers or search engines. There is no control on validation, and the added value is IMHO doubtful.

"It's up to you to provide as much data as possible, as accurately as possible", says the book. But you get no tools to validate! The costs of maintaining this microdata and validating its correctness (just for the sake of search engines which do not even guarantee to display it) is way too big for organizations to invest in it. I can already vision the poor webmaster, explaining over and over again to their boss "I don't know why Google doesn't show my microdata, but it's not guaranteed that they would do so", only to find months later that they have made a mistake with some property name.

If the justification for microdata is search engines, these would have had a much easier time with parsing valid XML elements.

A technical question is what the attribute itemscope is doing and why is it needed to declare the scope of the microdata dictionary? it doesn't get any value and seems redundant; if we define itemtype for a specific element, then this can also serve as stating that the current element is the scope for that type, isn't it?

Appendix The All-in-One Almost-Alphabetical Guide to Detecting Everything

Useful, however contains elements not discussed elsewhere in the book.


Disclosure: I have received the book from the publisher for free, in exchange for reviewing it.

Not a bad book, just too little depth on HTML5 goodies like canvas, storage (client side), and geolocation. Excellent history (emails from back in the day) in the 1st couple chapters, but this is not the reason one would buy this book. HTML5 is the next step in the evolution of the web, and this book will definitely open the door to the possibilities, but not take you that much further.... I also found it repetitive at times.

I like books and don't mind paying for good content such as this, but if you feel differently, you should know is that the book is derived from its freely available HTML5 source at [...]. This is good to know (it is explained in the Preface, though some people seem to miss this) even for those of you who prefer physical media, as it is easier to explore the live examples on the web site than it is to imagine them while reading the print version.

Overall, this is a nice survey of the most popular APIs/features formalized by HTML5. As the spec for HTML5 has not been finalized yet, it would be unfair to expect a Definitive Guide for HTML5 at this stage. That is not to say that the book's discussion of HTML5 is too superficial to provide any practical information for developers -- far from it! The book is rife with code samples that can be used today in the browser(s) that support the features of HTML5 being discussed.

I am especially impressed and grateful for the detailed discussion of video on the Web. It was extremely thorough and would have been extremely painful to research on my own. This is the type of detailed knowledge and broad perspective that does not fit into a brief StackOverflow Q&A.

However, at times, some of the examples come across as repetitive because they build on top of one another very slowly (especially with the Modernizr examples in Chapter 2 and the microdata examples in Chapter 10). I suspect this is advantageous if you jump back into the middle of a chapter for reference and don't want to read the previous sections to reestablish context, but if you're reading the chapter straight through (which is reasonable as it's a fairly short book), then it feels a bit sluggish.

One pet peeve of mine is the abundant use of bit.ly URLs in the book. On one hand, it is easier to type an abbreviated URL (like those produced by bit.ly) when reading off of the print version, but on the other hand, it obfuscates the domain of the destination link, which I often use as a signal of the quality of the content. For example, is it a link to an official w3c.org site or some arbitrary rant from a blogger on blogspot.com? With a bit.ly URL, there is no way of knowing without visiting the link.

Finally, Chapter 3 contains a number of diagrams drawn using ASCII art. This gives the impression that this is a dump of a web site into book form rather than an dedicated effort at polishing something for print media.

Ironically, I was most happy with this book until I read the appendix on feature detection that uncovered a whole host of HTML5 features that I realized were not discussed elsewhere in the book! (This caused me to drop my rating from 4 stars down to 3.) At this point, I realized that I was not nearly done learning about what HTML5 has to offer. Examples of topics that are only mentioned in the appendix include command, iframe sandbox, iframe srcdoc, and Undo, to name a few. What's worse is that this list did not even include a sentence or two to explain what each of these features are, or a URL where more information could be found.

I bought this book because I needed an HTML5 introduction that doesn't try to teach me HTML basics all over again. I bought this book specifically because, let's face it, it was an O'Reilly with an animal on the cover and my desired subject in the title. That was good enough for me.

What I did miss is the "Up & Running" tag line. That meant you get a brief introduction to the new elements in HTML5, but do not expect a whole lot of details on any of these elements.

Much to my surprise, the tutorials in the book were cursory at best-- with sometimes unexplained components.

The icing on the cake is that the site referenced throughout the entire book as the download site for the sample code is DOA!!! Every reference to the site generates a 404 and a 410!!! Very VERY unlike an O'Reilly product.

I would not recommend or repurchase.

HTML5 is the latest "big deal" in web development, and for good reason. It allows us to build interactive websites without the need for add-ons like Adobe Flash. But it's also the foundation of a whole new class of deliverables like iOS apps, iTunes LP, iTunes Extras, and iAds. And while those are all Apple-related right now, there's no reason they can't be used everywhere once IE9 ships. The downside is that HTML5 is not complete, and it won't be for a long time. But what most people think of as HTML5 is actually a combination of HTML, CSS and Javascript. Right now. While you can find an endless supply of books for each, none has yet covered the new context of manipulating DOM elements (or even explaining DOM elements), the canvas, local storage and all the other new goodies.

That's where the gold rush brings us in 2010. A number of "HTML5" books were promised as early as last November, only to be delayed again and again. "HTML5: Up and Running" from O'Reilly immediately went to the top of my watch list, since I have a shelf of O'Reilly books already and it would be in good company. It too was pushed back from the original release date, but not by much, and now I have it in my grubby fingers, and it was worth the wait. Mostly.

The first chapter is quick reading, and actually pretty interesting considering it's just a history of HTML. Old emails from names like Marc Andreessen and Tim Berners-Lee arguing over the img tag, and how we ultimately ended up with the current format, are entertaining. Ok, next. Chapter 2 covers compatibility, since not all web browsers support every piece of the HTML5 moving target, and how to detect if your visitor can see what you're trying to show them. Then we get a detailed but quick run-through on canvas, 2-D drawing, video codecs, geo-location, local data storage, offline web apps and new form elements. Chapter 10 wraps things up by future-proofing HTML5 and sneaking microdata annotations into your code, and tries to lay down some standards for different types of data in a way compatible with Google's Rich Snippets. This is followed by a very handy alphabetical guide to detecting the new stuff, and a standard index.

What's not to like? Well, by the time I finish typing this sentence some of the topics in the book may have changed. Those changes are likely documented somewhere online for free. Three days ago, for example, the MPEG LA group declared that H.264 video will be royalty-free forever. That could set it up as the favored web video standard going forward. Not that this makes the nine pages on encoding Ogg Theora video a waste, but maybe more time could have been spent on interactive UI elements, animation, CSS or 3-D drawing inside the browser instead of external video generation. And when I said "quick run-through" of some elements, I meant it. The chapter on forms, for example, shows how to fall back when using the new autofocus tag, by using Javascript for older browsers. But it doesn't have any fallback example for the placeholder tag at all.

This book is a foothold, however, and a necessary step to fill the holes in one's background. Like I said, these are the first books to cover actually using HTML, CSS and Javascript together as the new trinity of web development. The diagrams and code examples for canvas, as an example, are more clear in "HTML5: Up and Running" than anything I had found previously online. I'm looking forward to the next in the series.