Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
HTML5

HTML5

Up and Running: Dive into the Future of Web Development
Build richer web pages with new browser features while keeping them useful in older browsers.
by Mark Pilgrim 2010 207 pages
3.97
500+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

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.

Analysis

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.

Analysis

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.

Analysis

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.

Analysis

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.

Analysis

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.

Analysis

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.

Analysis

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.

Analysis

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.

Analysis

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.

Summary in 30 Seconds
Web standards develop through interaction between written specifications and features already in use, so compatibility shapes lasting change. Test each browser capability separately and provide a useful fallback. Semantic markup clarifies page structure for people and software. Canvas, video, location, local storage, offline caching, specialized forms, and structured data add capabilities, but each brings limits and implementation choices. Published in 2010, the examples document an earlier stage of browser support.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.97 out of 5
Average of 500+ ratings from Goodreads and Amazon.

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.

Your rating:
4.48
100 ratings
Want to read the full book?

Glossary

Retro-spec

Specification of deployed practice

A 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 group

The 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 abilities

A 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 library

An 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 sections

A 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 interface

The 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 label

A 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 storage

The 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 list

A 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 HTML

A 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 data

A 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.

About the Author

Mark Pilgrim is a software developer and author known for his work on open source projects and technical writing. He gained recognition for his book "Dive Into Python" and later wrote "HTML5: Up and Running" for O'Reilly Media. Mark Pilgrim is appreciated for his conversational and humorous writing style, making complex technical topics more accessible to readers. He has contributed to various open source projects and standards development efforts. Pilgrim's work often focuses on web technologies and programming languages. In 2011, he announced his retirement from the tech industry and removed much of his online presence, leaving behind a significant body of work that continues to be referenced by developers and tech enthusiasts.

Download PDF

To save this HTML5 summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.35 MB     Pages: 16

Download EPUB

To read this HTML5 summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.40 MB     Pages: 20
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...