Key Takeaways
Treat web standards as working agreements, not blueprints written in isolation.
Code and standards shaped each other. In 1993, browser maker Marc Andreessen proposed and shipped the `<img>` element before standards groups had settled how images should work. Other developers favored broader embedding systems, but the deployed tag became the starting point. Its early design left problems, including missing text alternatives, for later work to address. The episode captures HTML's recurring pattern: implementations reveal what authors need, and standards document successful practice while trying to improve it.
Compatibility beat clean breaks. The book traces how XHTML's strict XML error handling struggled against a Web full of pages that browsers had long rendered despite mistakes. The independent WHAT Working Group focused on evolving HTML without abandoning existing content, and the W3C eventually joined that effort. HTML5 emerged from that convergence.
What's striking is that standards here function less like architectural master plans and more like shared agreements negotiated among builders, users, and institutions. This resembles language evolution: common usage often settles conventions before authorities codify them. The approach preserves a vast body of working content and gives implementers evidence to test against. Its cost is path dependence. Once a rough solution becomes ubiquitous, redesign grows expensive, and compatibility can preserve flaws alongside useful behavior. The practical lesson is not simply to ship first, but to keep deployed experience inside the standards conversation.
Test the browser capability you need, then provide a graceful fallback.
HTML5 is a collection of features. A browser may support video but not a particular video format, or canvas drawing but not canvas text. The book therefore argues against asking whether a browser supports HTML5 as a whole. Instead, test the specific capability the page depends on. JavaScript can check for a property on `window`, `navigator`, or a newly created element, or set an input type and see whether the browser retains it.
Make the fallback useful. Modernizr bundles many such checks into Boolean flags. If canvas is unavailable, a page can offer an alternative; if a new input type is unknown, older browsers generally treat it as an ordinary text field. That lets developers adopt features without making the entire page depend on the newest browser.
This is a form of capability negotiation: systems cooperate by describing what they can do, rather than relying on assumptions about their identity. The same principle appears in network protocols and distributed software, where explicit checks are more robust than guessing a machine's version. A subtle limitation remains: detecting that a method exists does not prove that it behaves correctly in every circumstance. Good testing therefore checks the actual function needed, while the fallback preserves the task's purpose rather than merely preventing an error.
Mark up the role of content, not merely its appearance.
Semantic elements explain structure. HTML5 adds elements such as `<article>`, `<nav>`, `<header>`, and `<footer>` to identify what parts of a page are for. A navigation list wrapped in `<nav>` gives assistive technology a meaningful landmark, unlike a generic `<div>` whose ID merely names it for styling. `<time>` can pair readable dates with machine-readable timestamps, and sectioning elements help organize headings into a document outline.
Meaning can simplify markup. The book also demonstrates a shorter HTML5 doctype and a compact character-encoding declaration, while emphasizing that every page should declare its encoding. Older Internet Explorer versions needed a JavaScript workaround to recognize some new elements, a reminder that semantic benefits depended on browser support in the book's 2010 setting.
Semantic markup is a compact form of information architecture. It gives browsers, assistive technologies, and other tools clues about how content relates, much as labeled fields make a database more useful than an undifferentiated text file. The accessibility gain is real, but it is not automatic: a <nav> landmark cannot rescue confusing link labels, and headings still need a coherent hierarchy. Structure should describe the content's actual role, not be added as decorative vocabulary. The strongest implementation combines meaningful HTML with thoughtful content and appropriate testing.
Use canvas when a page needs images drawn from live data.
Canvas turns JavaScript into a drawing tool. The `<canvas>` element creates a rectangular bitmap surface. A script obtains its two-dimensional drawing context, then uses methods for shapes, lines, text, gradients, and images. Paths can be assembled before being drawn, much like sketching before tracing a final line. Coordinates start at the canvas's upper-left corner, with horizontal values increasing rightward and vertical values increasing downward.
A game makes the idea concrete. The book builds a solitaire version of Halma on a 9-by-9 board with nine pieces. JavaScript draws the board and pieces, translates mouse clicks into board positions, and redraws the image after moves. Canvas is valuable when graphics change with application data, not simply because it can reproduce an image that ordinary HTML already displays.
Canvas illustrates a broader design tradeoff between procedural control and semantic structure. A drawing API can generate a complex visualization from changing state, which is useful for games, charts, and interactive diagrams. But the pixels inside the canvas are not individually meaningful to a screen reader in the way ordinary text and HTML elements can be. The book's Halma example shows how easily an entire interface can be drawn; that power makes it especially important to preserve equivalent information and controls outside the bitmap.
Ship video as a compatibility bundle, not a single magic file.
A video file has several layers. Its container packages audio and video tracks; codecs determine how those tracks are compressed and decoded. In the book's 2010 browser landscape, no single combination played everywhere. A broadly compatible page might offer Ogg with Theora and Vorbis, MP4 with H.264 and AAC, and WebM with VP8 and Vorbis, letting the browser select a supported source.
Markup and servers both matter. The `<video>` element can provide controls and multiple `<source>` entries, with type information that helps browsers avoid downloading formats they cannot play. Older browsers could receive a plug-in-based fallback. The web server also had to label each file with the correct MIME type; correct HTML alone could not fix a mismatched HTTP content type.
The video chapter reveals that a media standard is also an ecosystem of licensing, hardware, software, and distribution choices. A file format is not a neutral wrapper if some codecs require patent licenses or are absent from devices. Multiple encodings impose real storage and production costs, yet they reduce the risk of excluding viewers. The same compatibility logic applies to media quality beyond playback: a robust publishing plan should consider captions, controls, and bandwidth, not just whether a decoder can open the file.
Ask permission before location, and request only the precision the task needs.
Location is optional and asynchronous. The Geolocation API asks the browser to seek the user's position, then delivers results through a callback. The user can refuse, and network problems, unavailable positioning signals, or time limits can also prevent a result. The returned coordinates may include an accuracy estimate, while altitude, heading, and speed are not guaranteed.
Accuracy has a cost. A nearby-business search may work with a rough estimate, while turn-by-turn directions need greater precision. Mobile devices can estimate location using nearby cellular towers or use GPS for a more exact fix that may take longer and consume more power. The API offers options for accuracy, timeouts, and accepting a recently cached position, as well as a watch function for updates as a user moves.
The book treats consent as a necessary boundary, not a technical inconvenience. That distinction matters because location data can reveal routines and associations, not just a point on a map. Requesting lower precision when it suffices also limits needless exposure and can make an application faster and less power-hungry. Permission alone, however, does not guarantee users understand what follows. Clear explanations of purpose, retention, and sharing are part of trustworthy interaction, even when the API itself supplies a consent prompt.
Keep client data local, but design offline behavior deliberately.
Browser storage avoids cookie overhead. Cookies travel with web requests and hold only small amounts of data. HTML5 Storage instead offers named key-value pairs kept in the browser, where JavaScript can retrieve them without sending them to the server automatically. The book describes a 5 MB default quota per origin in its 2010 landscape. Values are stored as strings, so applications must convert numbers and Boolean values when restoring them. A Halma game uses this storage to remember its board and move count after the page closes.
Offline access needs a plan. A cache manifest lists files for local use and can distinguish cached resources, online-only requests, and fallback content. In the book's model, one failed resource can derail an update, and changed files require a changed manifest. Offline availability does not itself synchronize user-created data with a server.
The chapter separates two ideas often blurred together: keeping data in the browser and making an application function without a network. That distinction mirrors resilient systems design, where cached inputs are only one part of continuity; state changes, conflict resolution, and later synchronization require their own rules. The manifest's sensitivity to small changes also illustrates cache invalidation's persistent difficulty. Local storage improves responsiveness and avoids transmitting every value, but it is not a secure vault or a substitute for carefully planned data lifecycle behavior.
Use specialized form controls to improve input without breaking old browsers.
Describe the data being requested. HTML5 adds types such as email, URL, number, range, date, time, and search. Browsers may render them with a calendar, slider, or numeric keyboard, while older browsers generally treat an unfamiliar type as plain text. Attributes such as minimum, maximum, and step can constrain numeric inputs. Placeholder text can offer a hint, and autofocus can direct attention to a field.
Native behavior can replace fragile scripts. The iPhone example shows how an email field can bring up a keyboard with convenient punctuation keys. Opera's browser could validate some email, URL, and number inputs even when scripting was disabled. These features do not make server-side checks unnecessary, but they let authors improve the form while retaining a usable basic experience on older browsers.
Specialized controls are a small example of progressive enhancement with unusually direct human benefits: less typing, fewer format mistakes, and better input methods on constrained devices. They also move some responsibility from custom scripts into browser behavior, where consistency can improve. Yet a native control's appearance and validation differ across platforms, and users may need more than one way to correct an error. Semantic input types help browsers assist; they do not remove the need for clear labels, accessible instructions, and server-side validation.
Add machine-readable meaning to visible data, but do not expect search engines to obey.
Microdata annotates existing HTML. It adds properties from a named vocabulary to elements already present in a page. A Person vocabulary might identify a name, photo, and links; an Event vocabulary can describe dates, a venue, and a location. The `itemscope` and `itemtype` attributes establish the item and its vocabulary, while `itemprop` marks individual values. Related items, such as an address nested within a person or event, can have their own scope.
The markup can help machines interpret a page. Search engines may use structured details to enrich a result, such as showing an event's date or a review's rating. The book stresses that search engines decide whether and how to display such data. Microdata works best when it clarifies visible information, rather than hiding facts that readers cannot see.
Microdata is a bridge between human presentation and machine interpretation. Its most durable design principle is to attach structure to information already present, which reduces the chance that a machine-only version drifts away from what readers see. That is a data-governance issue as much as a markup issue: annotations need maintenance when the underlying content changes. Search-result enrichment remains a discretionary use, not a guaranteed reward. Structured data improves interpretability, but the publisher cannot dictate how a downstream platform ranks or displays it.
Analysis
This is both a technical introduction and an argument about how the Web changes. Its organizing story is the tension between specifications and implementations: HTML5 did not arrive as a pristine replacement designed in isolation, but as an incremental response to deployed browsers, authors, and applications. That history explains the book's practical emphasis on backward compatibility, feature detection, and fallbacks. The standard is presented as a living contract whose rules must account for a vast inheritance of pages.
The chapters then move from page structure to capabilities: semantic elements, canvas, video, geolocation, storage, offline behavior, forms, and microdata. The examples give the abstractions working bodies. A Halma game demonstrates drawing and local persistence; a video player exposes the hidden negotiations among codecs, containers, server configuration, and licensing; a profile page shows how machine-readable facts can be layered onto ordinary HTML.
The book's lasting contribution is less a catalog of APIs than a method for making web features adoptable. Test what the browser can actually do, preserve a useful baseline, and make meaning explicit where machines and people need it. The caution is temporal. Published in 2010, the compatibility tables, recommended fallbacks, and emerging technologies describe a particular moment, not a current implementation guide. In particular, examples tied to plug-ins, experimental codecs, and the application cache should be read historically. Their value lies in showing why compatibility is architectural, not in prescribing today's exact tools.
The deeper lesson is that a web standard succeeds through a combination of technical merit and social coordination. An elegant design with no implementations can lose to a less elegant feature that people already use. Conversely, shipping code creates obligations: security, accessibility, and backward compatibility become costs carried by later generations. HTML5's story is therefore neither a simple victory of pragmatism nor a warning against standards. It is a case study in the difficult work of improving a system without making its existing users pay the full price of change.
Review Summary
HTML5: Up and Running receives mostly positive reviews, with readers praising its conversational tone and comprehensive coverage of HTML5 features. Many appreciate the historical context provided and find the book accessible for intermediate web developers. Some criticize the uneven depth of topics and outdated information due to the rapid evolution of web standards. Readers value the practical examples, browser compatibility discussions, and explanations of new HTML5 elements. While some find certain sections overly detailed, most consider it a useful resource for understanding HTML5's capabilities and implementation.
Glossary
Retro-spec
Specification of deployed practiceA specification written partly to formalize features that browsers and authors already use. The book describes several HTML versions as retro-specs: they captured established behavior while also trying to guide future development. This approach can make a standard more compatible with real pages, though it may also preserve decisions that were never ideal.
WHAT Working Group
Open HTML development groupThe Web Hypertext Applications Technology Working Group, an open collaboration involving browser makers and other interested parties. It pursued practical extensions to HTML while maintaining backward compatibility, and documented browser parsing behavior that had previously been implemented without a single formal account. Its work gained momentum before the W3C resumed incremental HTML development.
Feature detection
Testing individual browser abilitiesA technique for checking whether a browser supports a specific capability, rather than inferring support from its name or version. A script might test for a method on a canvas element or see whether an input retains a requested type. The result lets a page use a feature where available and provide an alternative where it is not.
Modernizr
Browser capability detection libraryAn open-source JavaScript library described in the book that checks support for many HTML5 and CSS features and exposes the results as Boolean properties. Developers can use those properties to decide whether to rely on a feature or supply a fallback. The book's specific version and feature list reflect its 2010 publication context.
Document outline
Hierarchical map of page sectionsA representation of a page's organization through its headings and sectioning elements. In the book's account of HTML5, elements such as articles and navigation sections can establish outline sections, allowing each section to have its own heading. Outlines can help readers and assistive technologies understand and navigate a page's structure.
Canvas API
JavaScript drawing interfaceThe methods and properties used to draw within an HTML <canvas> element. Its two-dimensional context supports operations such as filling rectangles, building paths, drawing text and images, and creating gradients. The canvas stores a bitmap rather than a semantic tree of its internal shapes, so meaningful alternatives may be needed for users who cannot perceive the rendered image.
MIME type
Resource format labelA label, commonly sent in an HTTP Content-Type header, that tells a browser what kind of resource a server is providing. The book emphasizes that correct video playback depends not only on source markup but also on the server identifying media files appropriately. MIME types also matter to the book's discussion of how browsers interpret HTML and XHTML.
HTML5 Storage
Persistent browser key-value storageThe book's name for browser-side storage standardized separately as Web Storage. JavaScript saves values under named keys, and those values persist across page visits without being sent with every HTTP request as cookies are. Stored values are strings, and access is restricted by origin. The book describes a typical 5 MB quota in its 2010 context.
Cache manifest
Offline resource listA text file that, in the book's offline application model, identifies resources a browser should cache for use without a network connection. It can also describe resources that must remain online and fallback content for unavailable pages. The manifest must be served with an appropriate content type, and changes to it signal that cached resources should be updated.
Microdata
Custom properties embedded in HTMLA way to add machine-readable name and value properties from a vocabulary to elements already present in an HTML page. An item scope identifies a subject and vocabulary, while item properties label values such as a person's name, an event date, or a business address. Search engines and other tools may use the annotations, but their display is not guaranteed.
Same-origin restriction
Separation between sites' stored dataA browser security rule described in relation to HTML5 Storage. A website can read and modify its own stored values, but it cannot use the storage interface to access values belonging to another site. The rule separates data by origin, though it does not protect a user's data from someone with access to the user's computer.
Download PDF
Download EPUB
.epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.