<!-- mobian-agent-page publisher="dailydev" canonical="https://daily.dev/posts/textbook-review-is-parallel-programming-hard-and-if-so-what-can-you-do-about-it--zkm3hvgre" -->

---
title: Textbook review: Is Parallel Programming Hard, And, If...
description: A personal review of the free online textbook 'Is Parallel Programming Hard, And, If So, What Can You Do About It?' by Paul E. McKenney, creator of the Linux...
canonical: https://daily.dev/posts/textbook-review-is-parallel-programming-hard-and-if-so-what-can-you-do-about-it--zkm3hvgre
twitter:card: summary_large_image
twitter:site: @dailydotdev
og:type: website
og:site_name: daily.dev
og:title: Textbook review: Is Parallel Programming Hard, And, If So, What Can You Do About It? | daily.dev
og:description: A personal review of the free online textbook 'Is Parallel Programming Hard, And, If So, What Can You Do About It?' by Paul E. McKenney, creator of the Linux...
og:url: https://daily.dev/posts/textbook-review-is-parallel-programming-hard-and-if-so-what-can-you-do-about-it--zkm3hvgre
og:image: https://api.daily.dev/og/posts/zKm3hVGRE.png
og:image:alt: Textbook review: Is Parallel Programming Hard, And, If So, What Can You Do About It?
og:image:width: 1200
og:image:height: 630
og:locale: en
---

> ## Documentation Index
> Fetch the complete documentation index at: https://daily.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Textbook review: Is Parallel Programming Hard, And, If So, What Can You Do About It?

**[Lobsters](https://daily.dev/sources/lobsters)** · 9 min read · 1 upvotes · 0 comments

## Summary

A personal review of the free online textbook 'Is Parallel Programming Hard, And, If So, What Can You Do About It?' by Paul E. McKenney, creator of the Linux kernel's RCU mechanism. The author, a TLA⁺ and distributed systems specialist looking to deepen concurrency knowledge, describes reading the book on a vacation e-reader, praises chapters on CPU cache behavior (MESI protocol), compiler and hardware memory reordering shenanigans, and the counting chapter's exploration of per-thread statistical counters and false sharing. Criticisms include excessive internal hyperlinks disrupting e-reader navigation, a Linux-kernel-centric focus that shortchanges C11/C++11 atomics and std::memory_order, and lock-free programming coverage arriving too late (chapter 14) for the reader's interests. Overall verdict is positive despite only reading the first five chapters in depth, crediting the book with sparking a strong interest in parallel programming minutiae.

## Full article

daily.dev links to this article rather than hosting it. Read it at the original source: <https://ahelwer.ca/post/2026-09-21-concurrency-textbook>

## Questions this post answers

### What is the MESI protocol and why does it matter for understanding CPU cache coherence in concurrent programming?

MESI is a cache coherence protocol explaining how CPU cores mediate concurrent reads and writes to memory. Under MESI, an x86 CPU core writes only to its own cache and must hold exclusive ownership of a cacheline before writing to any address within it; if another core wants to write the same address, it must wait for exclusive ownership to transfer, so literally concurrent writes to the same location never actually happen, though torn writes are possible when data spans multiple cachelines.

_Developers untangling CPU cache behavior in concurrent code can find deeper explainers like this curated on daily.dev._

### Where does the Is Parallel Programming Hard textbook by Paul McKenney cover lock-free programming and memory ordering?

Lock-free programming is not covered in depth until chapter 14, Advanced Synchronization, and memory ordering is addressed in chapter 15. The book's earlier chapters focus heavily on Linux-kernel-specific concurrency tools and mutex/counter-based patterns, meaning readers primarily interested in lock-free data structures may need to wait until quite late in the text or supplement with other sources.

_Anyone comparing concurrency textbooks for lock-free coverage can track similar deep-dive reviews on daily.dev._

### Why does the Is Parallel Programming Hard textbook give only brief coverage of C11 and C++11 atomic operations like std::memory_order?

The textbook is written from a strongly Linux-kernel-centric perspective, so C11 and C++11 atomics such as std::memory_order receive only short paragraphs in sections 4.2.6 and 4.2.7, leaving readers with just a vague understanding that macros like ACCESS_ONCE() and WRITE_ONCE() work by casting values to volatile pointers to deter compiler optimizations, rather than a full formal treatment.

_Engineers working through modern C++ atomics and memory ordering can keep learning resources like this handy on daily.dev._

## Similar posts on daily.dev

- [The Zen of Parallel Programming](https://daily.dev/posts/the-zen-of-parallel-programming-mkfemzvuo) · Hacker News · 2 upvotes · 1 comments
- [The Staggering Complexity And Subtlety Of Concurrency](https://daily.dev/posts/the-staggering-complexity-and-subtlety-of-concurrency-e4mpqhp2q) · Hackaday · 1 upvotes · 0 comments

---

Tags: [#linux](https://daily.dev/tags/linux), [#hardware](https://daily.dev/tags/hardware)

[View this post on daily.dev](https://daily.dev/posts/textbook-review-is-parallel-programming-hard-and-if-so-what-can-you-do-about-it--zkm3hvgre)

```json
{"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]}
{"@context":"https://schema.org","@type":"TechArticle","headline":"Textbook review: Is Parallel Programming Hard, And, If So, What Can You Do About It?","url":"https://daily.dev/posts/textbook-review-is-parallel-programming-hard-and-if-so-what-can-you-do-about-it--zkm3hvgre","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/textbook-review-is-parallel-programming-hard-and-if-so-what-can-you-do-about-it--zkm3hvgre"},"datePublished":"2026-09-21T19:59:30.976Z","dateModified":"2026-09-21T20:00:17.698Z","description":"A personal review of the free online textbook 'Is Parallel Programming Hard, And, If So, What Can You Do About It?' by Paul E. McKenney, creator of the Linux...","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/826709f342dc00cd7516904cd54e2c8e?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/826709f342dc00cd7516904cd54e2c8e?_a=AQAEuop","isAccessibleForFree":true,"articleSection":"Lobsters","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Lobsters","logo":"https://media.daily.dev/image/upload/s--tl8v_Fku--/f_auto,t_logo/v1698841318/logos/lobste.jpg","url":"https://daily.dev/sources/lobsters"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/textbook-review-is-parallel-programming-hard-and-if-so-what-can-you-do-about-it--zkm3hvgre","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":1},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":"linux,hardware","timeRequired":"PT9M"}
{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Lobsters","item":"https://daily.dev/sources/lobsters"},{"@type":"ListItem","position":3,"name":"Textbook review: Is Parallel Programming Hard, And, If So, What Can You Do About It?"}]}
{"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/textbook-review-is-parallel-programming-hard-and-if-so-what-can-you-do-about-it--zkm3hvgre#faq","mainEntity":[{"@type":"Question","name":"What is the MESI protocol and why does it matter for understanding CPU cache coherence in concurrent programming?","acceptedAnswer":{"@type":"Answer","text":"MESI is a cache coherence protocol explaining how CPU cores mediate concurrent reads and writes to memory. Under MESI, an x86 CPU core writes only to its own cache and must hold exclusive ownership of a cacheline before writing to any address within it; if another core wants to write the same address, it must wait for exclusive ownership to transfer, so literally concurrent writes to the same location never actually happen, though torn writes are possible when data spans multiple cachelines. Developers untangling CPU cache behavior in concurrent code can find deeper explainers like this curated on daily.dev."}},{"@type":"Question","name":"Where does the Is Parallel Programming Hard textbook by Paul McKenney cover lock-free programming and memory ordering?","acceptedAnswer":{"@type":"Answer","text":"Lock-free programming is not covered in depth until chapter 14, Advanced Synchronization, and memory ordering is addressed in chapter 15. The book's earlier chapters focus heavily on Linux-kernel-specific concurrency tools and mutex/counter-based patterns, meaning readers primarily interested in lock-free data structures may need to wait until quite late in the text or supplement with other sources. Anyone comparing concurrency textbooks for lock-free coverage can track similar deep-dive reviews on daily.dev."}},{"@type":"Question","name":"Why does the Is Parallel Programming Hard textbook give only brief coverage of C11 and C++11 atomic operations like std::memory_order?","acceptedAnswer":{"@type":"Answer","text":"The textbook is written from a strongly Linux-kernel-centric perspective, so C11 and C++11 atomics such as std::memory_order receive only short paragraphs in sections 4.2.6 and 4.2.7, leaving readers with just a vague understanding that macros like ACCESS_ONCE() and WRITE_ONCE() work by casting values to volatile pointers to deter compiler optimizations, rather than a full formal treatment. Engineers working through modern C++ atomics and memory ordering can keep learning resources like this handy on daily.dev."}}]}
```

