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
High Performance Browser Networking

High Performance Browser Networking

What every web developer should know about networking and web performance
Make web pages feel faster by fixing the delays users actually wait on.
by Ilya Grigorik 2013 398 pages
4.51
500+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Make round trips your first performance budget, not raw megabits

Latency is waiting time. Bandwidth measures how much data a link can carry; latency measures how long a message takes to arrive. A page may transfer little data and still feel slow if it requires many client-server exchanges. Each network step adds delay, including propagation, transmission, routing, and queueing. Distance imposes a hard limit: even light traveling through fiber needs about 160 milliseconds for a theoretical round trip between New York and Sydney, before real-world detours and router delays.

Users notice quickly. The book reports that delays above roughly 100 to 200 milliseconds become perceptible, and waits near a second can interrupt a user’s attention. So assess how many exchanges an experience requires, not only how many megabytes it downloads.

Analysis

What's striking is how the book turns physics into a product design constraint. The speed-of-light limit means software teams cannot count on faster hardware or fatter links to erase every wait. This resembles queueing theory: when work depends on sequential responses, even a fast system can accumulate delay. The comparison between bandwidth and latency is especially useful because bandwidth is easier to advertise and measure, while users experience the elapsed time between actions. Still, latency is not the only metric that matters. Large media transfers, uploads, and shared links can be genuinely bandwidth-limited, so the right diagnosis begins with the request pattern and the user’s task.

Keep connections warm; a new TCP handshake can cost more than payload

Setup has a price. TCP establishes a connection through a three-way handshake before ordinary application data can flow. Then slow-start gradually increases how much data can be in transit while the sender estimates available network capacity. Both costs matter most for the short, bursty transfers common on web pages.

Reuse beats reopening. In the book’s New York to London example, a 20 KB file took 264 milliseconds over a new connection, compared with 96 milliseconds over a reused connection. The example assumes a 56-millisecond round trip and particular server settings, but the principle holds: keepalive avoids repeating connection setup and gives TCP a chance to build its sending window. Reduce unnecessary requests, enable connection reuse, and check server TCP settings before adding more parallel connections.

Analysis

Connection reuse is an example of amortization: pay a setup cost once, then spread it across multiple useful exchanges. That logic appears in databases, compilers, and transportation systems, not just networking. The book’s numerical example makes the tradeoff tangible, though its exact timings depend on the assumed route, congestion window, and server response. More connections are not automatically better. They can increase resource use and competition between TCP streams, while browser connection limits only work around HTTP/1.x constraints. The durable diagnostic question is whether setup time is being paid repeatedly for work that could share an existing connection.

Move data closer before chasing impossible speed-of-light gains

Distance is a design choice. Better fiber and faster routers can improve latency somewhat, but signals already travel through fiber at a substantial fraction of light speed. Cutting the distance between user and server is often a more practical lever. A content delivery network, or CDN, places copies of content near users; a nearby proxy can also terminate a connection even when it must fetch personalized data from the origin.

Send less, too. Removing unneeded resources, caching repeat visits, and compressing text all reduce the amount of work and data on the path. The book’s core operational logic is simple: an unrequested byte has no delivery delay, and a nearby byte completes its journey sooner. Apply these improvements to dynamic services as well as static files when architecture allows.

Analysis

This is an architectural rather than merely code-level view of performance. Geographic distribution changes the length of the communication path, while caching changes whether a request must travel at all. Those are forms of moving computation and information toward the point of use, a principle also found in distributed systems and edge computing. The tradeoff is consistency: replicas and caches can serve stale data unless invalidation and freshness rules are designed carefully. A CDN is therefore not a universal answer for every response. The book’s strongest point is that distance, cache policy, and payload size belong in the system design conversation, not just the final optimization pass.

Choose reliable TCP or lossy UDP by what the user can tolerate

TCP protects correctness. It retransmits lost data and delivers bytes in order, which suits web pages, files, and other transfers where missing or rearranged data is unacceptable. That reliability can cause head-of-line blocking: when one TCP packet is missing, later data waits until the gap is repaired. For a live voice call or a game update, a late packet can be less useful than a dropped one.

UDP trades guarantees for control. It provides no built-in retransmission, ordering, or congestion control. That can suit time-sensitive audio, video, and changing game state, but the application must handle network fairness and loss responsibly. WebRTC builds additional mechanisms above UDP. For ordinary HTTP, the book recommends tuning TCP, including adequate initial congestion windows and window scaling, rather than casually inventing a replacement transport.

Analysis

Transport choice is a decision about the meaning of failure. In a file download, a missing byte corrupts the result; in live audio, waiting for a late sample can disrupt everything that follows. This resembles real-time control systems, where an old measurement may be less valuable than a fresh imperfect one. UDP’s flexibility is not a free performance upgrade: without congestion control, one application can harm other traffic. The useful distinction is not reliable versus unreliable in the abstract, but whether correctness, ordering, or timeliness is the governing requirement. TCP remains the sensible default when the application cannot safely manage those tradeoffs itself.

Keep TLS secure while cutting repeated handshake costs

Security adds setup work. TLS provides encryption, authentication, and integrity: outsiders cannot read the protected content, clients can verify server identity, and tampering can be detected. A new TCP connection plus a full TLS handshake can require several round trips before application data begins, making setup a significant cost on distant or mobile links.

Reuse the secure relationship. The book recommends connection reuse and TLS session resumption, which let returning clients establish secure sessions with less negotiation. A nearby server or CDN can terminate TLS close to the user, then relay requests to the origin. Keep certificate chains concise and avoid unnecessary redirects. The book also emphasizes that the cryptographic computation itself need not be the dominant expense; in its cited large-scale examples, software TLS ran on ordinary server hardware with modest overhead.

Analysis

The important distinction is between the cost of cryptography and the cost of coordinating a secure connection. Public-key operations, certificate validation, and network round trips are separate parts of setup, and reducing repeated negotiation need not weaken the security guarantee. This is a useful corrective to the idea that performance and encryption are inherently opposed. At the same time, security configuration is not merely a speed knob: certificate validation, key management, and supported protocol versions determine whether protection is meaningful. The best optimization preserves those guarantees while reducing redundant work, rather than treating security checks as expendable overhead.

Batch mobile traffic; tiny requests can keep a radio burning

A small request can wake a large system. Cellular devices use radio power states managed by the network. Moving from a low-power state to an active state adds delay and energy, and the radio may remain active after a transfer while inactivity timers run. The book calls this lingering cost an energy tail.

Frequency can outweigh payload size. In a study described in the book, Pandora’s intermittent audience-measurement messages transferred only 0.2% of its data but accounted for 46% of the application’s battery consumption. Group background updates, defer nonurgent work until the radio is already active, and avoid needless keepalives. Push is not automatically efficient if it delivers frequent tiny messages. Measure the traffic pattern and send a useful batch, then let the connection go quiet.

Analysis

This is a strong example of why optimizing bytes alone misses system-level costs. The radio has a fixed activation and tail cost, so a tiny message can trigger substantial energy use. Similar fixed costs appear in disk spin-up, cloud function startup, and industrial machinery: the event of starting can matter more than the work performed afterward. The Pandora finding is memorable, but it describes a particular application and network configuration, not a universal battery ratio. The general lesson is to measure timing and state transitions as well as payload. Batching also has a product cost: users may wait longer for low-priority updates, so the schedule should reflect what actually needs to feel immediate.

Mobile latency has layers. A request may wait for the cellular radio to reconnect, then travel through the carrier’s network, and finally cross the public Internet. The book gives idle-to-active LTE radio transitions a target below 100 milliseconds, while older 3G transitions can take seconds. Coverage, congestion, and movement can change the connection during use.

Design around uncertainty. A mobile application should give immediate feedback to user input instead of making the interface wait for the network. It should also handle timeouts, retries with backoff, temporary disconnection, and deferred work. For long media streams, adaptive bitrate can respond to changing throughput. Network measurements are temporary snapshots, not promises about what the next request will experience.

Analysis

The book treats connectivity as a changing condition rather than a stable pipe, which aligns with resilient systems design. A robust interface separates acknowledgment of user intent from completion of remote work, reducing the perception of delay without pretending the operation has finished. This distinction matters for both usability and data integrity: optimistic feedback must not mislead users about irreversible actions. Adaptive media quality similarly makes performance a control problem, with the application adjusting to noisy measurements. The caution against trusting a single speed test is especially sound because mobile conditions change faster than a cached estimate can remain useful.

Treat HTTP/1.x workarounds as temporary, not universal performance laws

HTTP/1.x limits parallel work. Its response ordering and lack of multiplexing encouraged developers to open several TCP connections, split resources across domains, combine files, or embed small assets. Each workaround has costs, such as extra DNS lookups, slower cache updates, more memory use, or additional connection setup.

HTTP/2 changes the transport. The book describes HTTP/2’s binary framing, where multiple request and response streams can share one connection, with prioritization, header compression, and server push. That architecture makes many older workarounds unnecessary and can make domain sharding counterproductive. It does not remove every bottleneck: because the described protocol runs over TCP, packet loss can still block delivery across the connection. The book presents HTTP/2 as a developing standard in its 2013 context, so its implementation details reflect that period.

Analysis

The deeper lesson is that optimizations are conditional on the constraints that made them useful. Once a protocol changes, yesterday’s workaround can become today’s overhead. That is a recurring pattern in engineering, from manual memory management to database denormalization. HTTP/2 multiplexing improves application-level concurrency, but it does not make the lower transport layer immune to loss. This is why protocol upgrades should prompt measurement and re-evaluation rather than an automatic migration of every old tuning rule. The book’s historical framing is important: it captures a design transition, while readers should distinguish its 2013 draft-era descriptions from present-day implementations.

Match browser transports to message direction, payload, and delivery guarantees

The API determines the shape of communication. XMLHttpRequest, or XHR, suits conventional HTTP requests, uploads, downloads, and browser-managed caching. Server-Sent Events (SSE) provides a persistent server-to-browser stream of text events, with browser-managed parsing and reconnection. WebSocket supports persistent, bidirectional messages, including binary data, but its custom payloads do not automatically receive HTTP caching or compression services.

Choose for the actual job. SSE is a natural fit for text notifications flowing from server to client. WebSocket fits two-way interactive messaging. XHR is often preferable when ordinary request-response behavior and HTTP services matter. WebSocket applications must manage their own message conventions and watch queued data, since a large message can delay messages behind it. For all of these persistent options, intermediary timeouts and mobile battery costs still matter.

Analysis

This comparison is useful because it replaces the search for a universally superior API with a requirements-based decision. A protocol is an allocation of responsibilities: the browser may supply caching and parsing, or the application may gain flexible streaming while taking on more state management. That is the same abstraction tradeoff seen in databases and programming languages. The caution about large WebSocket messages also illustrates that low framing overhead does not guarantee low latency when queues remain ordered. The choice should account for direction, binary needs, recovery behavior, cacheability, and operational support, not merely the elegance of the JavaScript interface.

Budget signaling and relay capacity before promising peer-to-peer WebRTC

Peer-to-peer still needs infrastructure. WebRTC can carry audio, video, and application data directly between browsers, often using UDP to favor timely delivery over perfect ordering. Before that can happen, peers must exchange connection information through a signaling service and find a viable network path through NATs and firewalls.

Direct paths can fail. ICE coordinates candidate checks, STUN helps discover a public address and port, and TURN relays traffic when direct connectivity fails. The book cites a libjingle deployment where direct connections worked about 92% of the time and relays were needed about 8% of the time. That is a specific example, not a guarantee. A TURN service must handle potentially heavy media traffic. For DataChannel messages, small payloads reduce the risk that one lost packet ruins a fragmented message.

Analysis

WebRTC is a reminder that decentralizing data flow does not eliminate centralized coordination. Signaling, identity, and relay services remain necessary, much as peer-to-peer file sharing still depends on discovery mechanisms. This architecture can reduce server bandwidth for successful direct connections, but it shifts complexity toward connectivity, security, and fallback capacity. The cited success rate is informative precisely because it resists the simplistic claim that peer-to-peer means server-free. The right capacity plan considers not just typical direct calls but the cost of the fallback cases, which may concentrate traffic on relays during restrictive network conditions.

Measure user-visible milestones, not just when the spinner stops

One page has several finish lines. A browser may render useful content before every image, advertisement, or background request has completed. Conversely, a technically complete page may still be unusable if scripts or styles prevent interaction. The book therefore distinguishes page-load timing from application-specific milestones, such as first useful render or first user interaction.

Use complementary evidence. Synthetic tests provide repeatable conditions for finding regressions; real-user measurement captures actual devices, browsers, caches, and network conditions. A resource waterfall reveals DNS, connection, TLS, waiting, and download time. The book advises examining distributions such as medians and quantiles rather than relying on averages, which can conceal slow user segments. Connect these measurements to the actions and outcomes that matter for the application.

Analysis

Measurement is not a neutral final step; the chosen metric defines what a team treats as success. This connects performance engineering to Goodhart’s law: when a proxy becomes a target, optimization can improve the number while degrading the experience it was meant to represent. A spinner stopping, a response arriving, and a user completing a task are related but distinct events. Combining controlled tests with field data helps separate regressions from real-world variation. Distributional reporting is essential because a satisfactory average can coexist with a miserable long tail. The strongest measure is tied to a concrete user task and checked against the technical causes visible in the waterfall.

Analysis

The book’s most durable contribution is a way to reason across layers. Browser performance is not a front-end property in isolation: physical distance, transport behavior, radio power states, protocol framing, server capacity, and interface design combine to determine what a user experiences. The text repeatedly turns abstract mechanics into decisions, such as reusing connections, placing servers near users, batching mobile requests, and choosing transports according to message semantics.

Its organizing contrast is latency versus throughput. Bandwidth improvements help bulk transfers, but short dependent exchanges often spend more time waiting than transmitting. This insight explains why a web page with many small resources can be slower than a much larger stream, and why connection reuse, caching, and multiplexing matter. The book also makes a subtle distinction between network reliability and application usefulness: retransmission preserves correctness, yet can be harmful when a late message has lost its value.

The strongest sections combine protocol mechanics with operational consequences. The mobile chapters show that a request has an energy cost beyond its byte count. The browser API chapters make clear that convenient abstractions exchange control for built-in services such as caching, parsing, and security enforcement. WebRTC extends the same systems thinking to peer-to-peer networking, where direct paths still depend on signaling, NAT traversal, and relay fallbacks.

The book’s 2013 vantage point matters. Its HTTP/2 discussion is draft-era, and its technology figures should be read as historical observations rather than current benchmarks. The protocols and products evolve, but the reasoning method remains useful: identify where waiting occurs, distinguish setup from transfer, inspect what the application actually needs, and measure user outcomes. Its greatest value is not a timeless checklist. It is the habit of asking which layer is imposing the delay, cost, or failure mode before applying an optimization.

Summary in 30 Seconds
Web speed depends on waiting as much as data volume: each client-server exchange adds delay, and distance sets a hard limit. Reusing connections, caching, compressing, and serving content nearby reduce setup and transfer time. Mobile requests also consume radio energy, so batching background work can save battery. Choose TCP for reliable delivery and UDP when timely data matters more than perfect arrival. Measure useful rendering and interaction across real users, not just total load time.
Contains spoilers

Last updated:

Report Issue

Review Summary

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

High Performance Browser Networking is highly praised for its comprehensive coverage of web performance and networking fundamentals. Readers appreciate its in-depth explanations of protocols, wireless networks, and browser APIs. The book is considered essential reading for web developers, offering practical optimization tips and insights into the intricacies of modern web technologies. While some find certain sections challenging or slightly outdated, most reviewers commend the author's ability to explain complex concepts clearly and provide valuable performance optimization strategies for web and mobile applications.

Your rating:
4.7
308 ratings
Want to read the full book?

Glossary

Bandwidth-delay product

Data needed in flight

The product of a link’s capacity and its end-to-end delay. It estimates how much unacknowledged data must be in transit to keep the link fully utilized while acknowledgments travel back. If TCP’s effective send or receive window is too small for this product, the sender must pause and throughput falls even when the link has spare capacity.

Head-of-line blocking

Later data waits behind earlier data

A delay caused when a transport or protocol requires ordered delivery. In TCP, later bytes remain unavailable to the application until a missing earlier packet is retransmitted. In HTTP/1.x, a slow response can also hold up subsequent responses on a pipelined connection. The effect simplifies ordering for applications but can increase latency and jitter.

Radio Resource Controller (RRC)

Cellular radio state manager

The cellular network component that coordinates radio access for a device, including resource assignments and power states. When a device has been idle, the RRC may need to establish or restore a connection before data can flow. Those transitions add latency, while keeping the radio active consumes more power. Its timers also create lingering energy costs after brief transfers.

Server-Sent Events (SSE)

Server-to-browser text streaming

A browser mechanism for receiving text-based events over a long-lived HTTP response. The EventSource interface parses messages and can reconnect automatically, including reporting the last received event identifier. SSE is suited to server-to-client updates, but it is not a bidirectional transport and is not designed for efficient binary data.

Interactive Connectivity Establishment (ICE)

Finds a working peer route

A framework used by WebRTC to discover and test possible network paths between peers. It gathers local and public address candidates, checks whether candidate pairs can communicate, and can use a relay when direct connectivity fails. The browser handles much of this process, while the application supplies signaling to exchange session descriptions and candidates.

Session Traversal Utilities for NAT (STUN)

Discovers public address mappings

A protocol through which a host can learn the public IP address and port assigned to its traffic by a network address translator. A client contacts a public STUN server, which reports how the request appears from outside the private network. STUN can enable direct peer connections, but it does not work across every firewall or NAT configuration.

Traversal Using Relays around NAT (TURN)

Relays traffic between peers

A protocol that routes data through a public relay when two peers cannot communicate directly across their network boundaries. TURN improves the chance that a connection will work, including when direct UDP traffic is blocked, but it adds a network hop and requires relay capacity for the traffic being carried. It is typically a fallback rather than the preferred path.

DataChannel

Peer-to-peer application messaging

The WebRTC interface for exchanging arbitrary text or binary messages directly between peers. It uses SCTP over a secure DTLS connection and can multiplex multiple channels. Applications can choose ordered or unordered delivery and reliable or partially reliable delivery, allowing message behavior to match whether correctness or freshness matters more.

TLS session resumption

Reuses prior TLS negotiation

A TLS optimization that lets a client and server reuse parameters from an earlier secure session instead of performing the full handshake again. Resumption can reduce connection setup round trips and cryptographic work while maintaining an encrypted channel. The book describes stateful session identifiers and stateless session tickets as two ways to support it.

Request and response multiplexing

Interleaves streams on one connection

An HTTP/2 capability that divides messages into frames associated with separate streams, allowing requests and responses to make progress over a shared connection. The frames can be interleaved and reassembled at the receiving end, reducing the need for multiple TCP connections and avoiding HTTP/1.x response queueing. TCP-level blocking from packet loss can still affect the shared connection.

FAQ

What's High Performance Browser Networking about?

  • Focus on Networking Protocols: The book explores foundational networking protocols like TCP, UDP, and HTTP, which are essential for web development.
  • Performance Optimization: It emphasizes optimizing network performance to enhance user experience, offering insights on reducing latency and improving throughput.
  • Modern Web Technologies: Covers advancements like HTTP/2, WebSockets, and WebRTC, crucial for developing modern web applications.

Why should I read High Performance Browser Networking?

  • Essential for Developers: It's a must-read for web developers to understand networking behaviors and tackle complex performance issues.
  • Actionable Insights: Provides practical advice with real-world examples, making it easier to apply concepts in your applications.
  • Stay Updated: Helps you stay current with the latest practices and protocols that impact performance significantly.

What are the key takeaways of High Performance Browser Networking?

  • Latency and Bandwidth: Emphasizes the roles of latency and bandwidth in network performance, noting that latency is often the bottleneck.
  • Connection Reuse: Highlights the importance of reusing connections to minimize latency, as new connections incur a full roundtrip of latency.
  • Mobile Network Optimization: Discusses challenges and strategies for optimizing applications for mobile networks with higher latency and lower bandwidth.

What are the best quotes from High Performance Browser Networking and what do they mean?

  • "Good developers know how things work. Great developers know why things work.": Stresses understanding the principles behind technology, not just its use.
  • "Speed is a feature.": Highlights that performance is a critical aspect of web development, influencing user engagement and retention.
  • "Latency, not bandwidth, is the performance bottleneck for most websites!": Corrects the misconception that increasing bandwidth solves performance issues, emphasizing latency reduction instead.

How does High Performance Browser Networking address latency issues?

  • Identifying Latency Sources: Breaks down components like propagation, transmission, and queuing delays to help pinpoint optimization areas.
  • Practical Solutions: Suggests actions like using CDNs to serve content closer to users, offering significant performance benefits.
  • Connection Management: Emphasizes managing connections effectively with techniques like connection keep-alive and TCP Fast Open.

What are the main networking protocols discussed in High Performance Browser Networking?

  • TCP (Transmission Control Protocol): Describes TCP's role in reliable communication, including error correction and flow control.
  • UDP (User Datagram Protocol): Highlights UDP's advantages for low-latency applications like video streaming and gaming.
  • HTTP (Hypertext Transfer Protocol): Covers HTTP's evolution, including the transition to HTTP/2 and its performance improvements.

How does High Performance Browser Networking explain the impact of mobile networks on performance?

  • Unique Challenges: Outlines challenges like higher latency and variable bandwidth in mobile networks.
  • RRC State Management: Explains how Radio Resource Controller impacts latency and battery life, aiding efficient app design.
  • Optimizing for Battery Life: Discusses strategies like reducing network request frequency and leveraging WiFi to minimize battery consumption.

What is the significance of HTTP/2 in High Performance Browser Networking?

  • Multiplexing Requests: Allows multiple requests over a single connection, reducing latency and improving performance.
  • Header Compression: Efficiently compresses HTTP header fields, minimizing protocol overhead and enhancing performance.
  • Server Push: Introduces server push capabilities, allowing proactive resource sending to clients, improving load times.

What is the significance of WebSocket in High Performance Browser Networking?

  • Bidirectional Communication: Enables real-time, bidirectional communication, crucial for interactive applications like chat and live updates.
  • Low Latency: Reduces latency compared to traditional HTTP requests, ideal for immediate data exchange in gaming and finance.
  • Custom Protocols: Allows custom application protocols, providing flexibility and efficient data handling tailored to specific needs.

How does High Performance Browser Networking explain WebRTC?

  • Peer-to-Peer Communication: Describes WebRTC as enabling peer-to-peer audio, video, and data sharing, reducing latency and improving performance.
  • Complex Architecture: Outlines protocols and APIs like ICE, STUN, and TURN, essential for effective WebRTC solutions.
  • Real-Time Applications: Emphasizes WebRTC's potential for real-time applications like video conferencing and collaborative tools.

How does High Performance Browser Networking suggest optimizing for mobile networks?

  • Battery Preservation: Emphasizes strategies like minimizing network requests and optimizing data transfers to preserve battery life.
  • Adaptive Techniques: Discusses adjusting to varying network conditions to maintain responsiveness, including data quality adjustments.
  • Efficient Resource Management: Provides guidance on managing resources to reduce latency and improve performance on mobile networks.

What are the challenges of implementing HTTP/2 and WebSocket as discussed in High Performance Browser Networking?

  • Compatibility Issues: Highlights potential issues with existing infrastructure when transitioning to these protocols.
  • Performance Trade-offs: Discusses trade-offs like connection and resource management, essential for optimizing performance.
  • Operational Complexity: Notes the complexity of implementing these technologies, requiring additional configuration and monitoring.

About the Author

Ilya Grigorik is a prominent figure in web performance engineering, currently working at Google. As the co-chair of the W3C Web Performance Working group, he plays a crucial role in shaping web performance standards. Ilya Grigorik is best known for authoring "High Performance Browser Networking," published by O'Reilly. This book has become a go-to resource for developers seeking to optimize web and mobile application performance. Grigorik's expertise in networking protocols, browser technologies, and performance optimization techniques has made him a respected voice in the web development community. His work at Google and contributions to web standards continue to influence the direction of web performance engineering.

Download PDF

To save this High Performance Browser Networking summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.44 MB     Pages: 23

Download EPUB

To read this High Performance Browser Networking 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.42 MB     Pages: 29
Want to read the full book?
Follow
Listen1 mins
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
600,000+ 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...