Skip to content

Volume ITechnology

2.4.3 — Deadlock in the Operating System ​

The photo-upload service lets people move photos between albums. Each album has its own lock (2.4.2), so two people editing two different albums never wait for each other. To move a photo, a thread locks the album it is taking the photo from, then locks the album it is putting it into, moves it, and unlocks both.

One afternoon, two people act at the same moment. Asha moves a photo from Holiday to Family. Ben moves a photo from Family to Holiday.

  1. Asha's thread locks Holiday.
  2. Ben's thread locks Family.
  3. Asha's thread tries to lock Family. Ben holds it, so Asha's thread waits.
  4. Ben's thread tries to lock Holiday. Asha holds it, so Ben's thread waits.

Each thread holds what the other needs, and each is waiting for the other to let go. Neither ever will. Both threads are stuck forever, using no CPU at all. Soon every other request that touches either album queues up behind them, and the service appears to hang.

This is a deadlock: a set of threads each waiting for something that another thread in the set holds, so none of them can ever continue. This page looks at deadlock the way an operating system does. It covers how to see one, the four conditions that must all hold for it to happen, and the four ways a system can deal with it, including the famous Banker's algorithm. The everyday deadlocks you will meet in application code, and the habits that avoid them, are in 9.5.3.

1. Seeing a deadlock: the resource-allocation graph ​

Operating-system textbooks draw deadlocks with a resource-allocation graph. There are two kinds of node and two kinds of arrow:

  • a circle for each thread, and a square for each resource, such as a lock;
  • an arrow from a resource to a thread means "this thread holds it";
  • an arrow from a thread to a resource means "this thread is waiting for it".

Here is the album deadlock drawn that way.

Asha'sthreadBen'sthreadHolidayFamilyheld bywaits forheld bywaits for
Figure 1 — The album deadlock as a graph. Solid blue arrows mean "held by". Dashed red arrows mean "waits for". Follow the arrows: Asha waits for Family, held by Ben, who waits for Holiday, held by Asha. The arrows form a closed loop.

Follow the arrows round. Asha's thread waits for Family. Family is held by Ben's thread. Ben's thread waits for Holiday. Holiday is held by Asha's thread. We are back where we started. The arrows form a cycle, and a cycle is a deadlock.

That rule is exact when each resource has a single instance, like a lock, which only one thread can hold. When a resource has several identical units, such as four thumbnail worker slots, a cycle means deadlock is possible but not certain, because another unit might be freed. Section 4 deals with that case.

2. The four conditions ​

In 1971, Edward Coffman and two colleagues showed that a deadlock can happen only if all four of these conditions hold at the same time. They are called the Coffman conditions.

ConditionMeaningIn the album example
Mutual exclusiona resource can have one holderan album lock has one holder
Hold and waita thread holds one thing while waiting for anotherholds one album, wants the other
No preemptionnothing can be taken away from a holdernobody can steal a lock
Circular waitthe waiting forms a cycleAsha → Ben → Asha

The power of this list is in the word all. Because every one of the four is needed, breaking any single one makes deadlock impossible. Every technique in section 3 works by attacking one of them.

3. Four ways to deal with deadlock ​

A system can take one of four attitudes. They range from doing nothing to doing a great deal of work in advance.

Way 1: ignore it ​

This sounds like a joke, and textbooks call it the ostrich algorithm, after the myth of the ostrich hiding its head in the sand. But it is what Linux, Windows and macOS mostly do for the locks your programs use. The reasoning is honest. Preventing or detecting every possible deadlock costs effort on every single lock operation, for every program. Deadlocks in correctly written programs are rare, and when one happens, a person can restart the stuck program. So the kernel leaves deadlock in your locks to you.

That does not mean the kernel is helpless. Linux runs a background check that notices when a thread has been stuck in the uninterruptible D state (2.2.1) for a long time, and prints a warning to the kernel log saying the task has been blocked for more than 120 seconds. It does not fix anything, but it tells you where to look.

Way 2: prevent it, by making one condition impossible ​

Here are the four conditions again, with the ways to break each one, from most to least useful in practice.

Break circular wait with a lock order. This is the technique you will use most. Decide one fixed order for all locks, and make every thread take locks only in that order. For the albums, the rule could be "always lock the album with the smaller ID first". Now Asha's thread and Ben's thread both try to lock the same album first. One of them gets it. The other waits at the first lock, while holding nothing. The cycle cannot form, because nobody holds a "later" lock while waiting for an "earlier" one.

Break hold-and-wait. Make a thread take everything it needs at once, or nothing. Or use a try-lock, which takes the lock if it is free and returns "no" at once if it is not, instead of waiting. A thread that gets the first album, fails to get the second, gives the first back, waits a random short time and tries again, never holds one lock while waiting for another. The risk is a livelock: two threads that keep backing off and retrying in step, both busy, neither making progress. The random wait makes that unlikely.

Break no-preemption. Allow the system to take a resource away. You cannot safely take a lock away from a thread halfway through changing the data it protects. But a database can do the equivalent: it cancels one of the deadlocked transactions, undoes its changes, and lets the other continue (7.4.2).

Break mutual exclusion. Make the resource shareable. Data that never changes needs no lock at all, and several threads can read it at once. Where that is possible, it removes the problem completely. Where data must change, it usually is not possible.

Way 3: avoid it, by checking every request first ​

Prevention changes the rules so deadlock can never arise. Deadlock avoidance is subtler. It keeps the normal rules, but checks every single request before granting it, and refuses to grant any request that could lead to a deadlock later, even if the resources are free right now. The classic method is the Banker's algorithm, and it gets its own section next.

Way 4: detect it and recover ​

Let deadlocks happen, but look for them regularly. To detect one, build a wait-for graph: one node per thread, and an arrow from thread A to thread B if A is waiting for something B holds. It is Figure 1 with the resource squares taken out. Then search the graph for a cycle, which a depth-first search does quickly (4.19.1). A cycle is a deadlock.

To recover, break the cycle. Choose a victim, one thread or transaction in the cycle, and cancel it, so its resources are released and the others can continue. Databases do exactly this. PostgreSQL, for instance, checks for a cycle when a transaction has been waiting for a lock for about a second, and if it finds one, it cancels one transaction with a "deadlock detected" error. The application is expected to retry it.

4. The Banker's algorithm, worked ​

Dijkstra invented this algorithm in the 1960s. Its name comes from a picture of a cautious bank. The bank has a limited amount of cash. Each customer has a credit limit, the most they might ever borrow. The bank never lends money if doing so could leave it unable to satisfy every customer's remaining needs in some order. As long as some order exists in which everyone can be paid in full, one after another, the bank is safe.

In operating-system terms, every job must declare up front the maximum of each resource it might ever need. The system then tracks three things for each job:

  • Allocation: what the job holds now.
  • Maximum: the most it declared it might ever need.
  • Need: what it might still ask for. Need = maximum − allocation.

The system is in a safe state if there is at least one order in which every job can be given its remaining need, finish, and return everything it holds. Here is the test: find a job whose need fits in what is currently free; pretend it finishes and gives back everything it holds; repeat. If every job can finish this way, the state is safe. A safe state can never deadlock, because the system can always serve the jobs in that order. An unsafe state is not yet a deadlock, but it might become one, so the algorithm refuses to enter one.

The example ​

Five thumbnail jobs, J0 to J4, share three kinds of resource. Call them A, B and C: think of A as worker slots, B as blocks of memory and C as disk channels. The machine has 10 units of A, 5 of B and 7 of C. Here is the current state.

JobHolds (A B C)Maximum (A B C)Need (A B C)
J00 1 07 5 37 4 3
J12 0 03 2 21 2 2
J23 0 29 0 26 0 0
J32 1 12 2 20 1 1
J40 0 24 3 34 3 1

The jobs hold 7 of A, 2 of B and 5 of C in total. So what is free right now is 10 − 7 = 3 of A, 5 − 2 = 3 of B and 7 − 5 = 2 of C: (3, 3, 2).

Now run the safety test by hand. "Free" grows each time a job finishes and returns what it holds.

StepFree beforeJob that fitsIts needIt returnsFree after
13 3 2J11 2 22 0 05 3 2
25 3 2J30 1 12 1 17 4 3
37 4 3J44 3 10 0 27 4 5
47 4 5J07 4 30 1 07 5 5
57 5 5J26 0 03 0 210 5 7

At step 1, J0 needs 7 of A, but only 3 are free, so it cannot be first. J1 needs (1, 2, 2), which fits inside (3, 3, 2). So J1 can be served, finish, and give back its (2, 0, 0). Every job finds a turn, and at the end everything is free again. The state is safe, with the safe order J1, J3, J4, J0, J2.

The algorithm in TypeScript ​

Here is the same test, plus the request check that uses it.

ts
// bankers.ts — would granting this request leave the system in a safe state?
type Vec = number[];                       // one number per resource kind: [A, B, C]

const fits = (a: Vec, b: Vec) => a.every((x, i) => x <= b[i]);
const add = (a: Vec, b: Vec) => a.map((x, i) => x + b[i]);
const sub = (a: Vec, b: Vec) => a.map((x, i) => x - b[i]);

function safeOrder(available: Vec, allocation: Vec[], need: Vec[]): number[] | null {
  let work = [...available];                                       // (1) what is free right now
  const done = allocation.map(() => false);
  const order: number[] = [];
  let progress = true;
  while (progress) {
    progress = false;
    for (let j = 0; j < allocation.length; j++) {
      if (!done[j] && fits(need[j], work)) {                       // (2) j can finish with what is free
        work = add(work, allocation[j]);                           // (3) …and then returns what it holds
        done[j] = true;
        order.push(j);
        progress = true;
      }
    }
  }
  return done.every(Boolean) ? order : null;                       // (4) everyone finished, or not
}

function request(job: number, ask: Vec, available: Vec, allocation: Vec[], need: Vec[]): string {
  if (!fits(ask, need[job])) return "refused: asks for more than it declared";
  if (!fits(ask, available)) return "wait: not enough free right now";
  const avail2 = sub(available, ask);                              // (5) pretend to grant it
  const alloc2 = allocation.map((a, j) => (j === job ? add(a, ask) : a));
  const need2 = need.map((n, j) => (j === job ? sub(n, ask) : n));
  const order = safeOrder(avail2, alloc2, need2);                  // (6) is the pretend world safe?
  if (!order) return "wait: granting it would be unsafe";
  available.splice(0, 3, ...avail2); allocation[job] = alloc2[job]; need[job] = need2[job];
  return `granted; a safe order is ${order.map((j) => "J" + j).join(", ")}`;
}

const maximum: Vec[]    = [[7, 5, 3], [3, 2, 2], [9, 0, 2], [2, 2, 2], [4, 3, 3]];
const allocation: Vec[] = [[0, 1, 0], [2, 0, 0], [3, 0, 2], [2, 1, 1], [0, 0, 2]];
const available: Vec    = [3, 3, 2];
const need = maximum.map((m, j) => sub(m, allocation[j]));          // (7) need = max − held

console.log("safe order now:", safeOrder(available, allocation, need)!.map((j) => "J" + j).join(", "));
console.log("J1 asks for [1,0,2]:", request(1, [1, 0, 2], available, allocation, need));
console.log("J4 asks for [3,3,0]:", request(4, [3, 3, 0], available, allocation, need));
console.log("J0 asks for [0,2,0]:", request(0, [0, 2, 0], available, allocation, need));

// Prints:
// safe order now: J1, J3, J4, J0, J2
// J1 asks for [1,0,2]: granted; a safe order is J1, J3, J4, J0, J2
// J4 asks for [3,3,0]: wait: not enough free right now
// J0 asks for [0,2,0]: wait: granting it would be unsafe
  • (7) Each job's need is its declared maximum minus what it holds, the formula from the start of this section.
  • (1) The safety test starts from what is free.
  • (2) It looks for an unfinished job whose remaining need fits inside what is free.
  • (3) If it finds one, it pretends that job runs to completion and returns everything it holds, so more becomes free. It records the job in the order.
  • (4) When no more jobs can be found, the state is safe only if every job finished.
  • (5) To decide on a request, request pretends to grant it, making a copy of the state as it would be.
  • (6) It runs the safety test on that pretend state. Only if the pretend state is safe is the request really granted.

Now read the three requests in the output.

  1. J1 asks for (1, 0, 2). It is within J1's declared need, and it fits in what is free, (3, 3, 2). After pretending to grant it, free becomes (2, 3, 0), and the safety test still finds the order J1, J3, J4, J0, J2. So it is granted.
  2. J4 asks for (3, 3, 0). After J1's grant, only (2, 3, 0) is free. There are not 3 units of A, so J4 simply has to wait.
  3. J0 asks for (0, 2, 0). That does fit: 2 units of B are free. But after pretending to grant it, free would be (2, 1, 0), and no job's remaining need fits inside that. No safe order exists. So the request is refused, even though the resources are sitting free. Granting it would not deadlock the system immediately, but it would put the system in a state from which the jobs might never all finish.

Why real kernels do not use it ​

The Banker's algorithm is elegant, and it is a staple of operating-system exams. But no general-purpose kernel uses it for ordinary locks or memory, for three reasons.

  1. Programs do not know their maximum needs in advance. Our upload service has no idea how many photos will arrive.
  2. The set of jobs is not fixed. Programs start and stop all the time, and every change means rechecking.
  3. It is slow. Every request runs a safety test over every job and every resource.

It survives in narrower places, where these conditions do hold, such as some embedded and real-time systems with a fixed set of tasks. And its central idea, never move into a state from which you cannot finish everyone, is useful far beyond operating systems.

5. What real systems actually do ​

Here is how the four ways map onto the systems you use.

SystemApproach
Your program's locks, on Linux, Windows, macOSignore; you keep a lock order
The Linux kernel's own lockslockdep finds bad lock orders during development
Databasesdetect cycles and cancel a victim transaction
Some real-time and embedded systemsavoidance, with fixed tasks and declared limits

Lockdep, mentioned in 2.4.2, is worth one more sentence. It is a prevention tool that runs while kernel developers test their code. It remembers the order in which every pair of locks has ever been taken. The first time any code takes two locks in the opposite order to an order seen before, it prints a warning, even though no deadlock happened that time. It catches the bug while it is still only a possibility.

Two related failures complete the picture, and 9.5.3 covers both. A livelock is threads that are busy but making no progress, such as two that keep backing off from each other in step. Starvation is a thread that could run but is always passed over, which 2.3.2 met in scheduling.

What the interviewer will push on ​

"What is a deadlock, and what four conditions are required?" They want the definition and all four Coffman conditions: mutual exclusion, hold and wait, no preemption and circular wait. The tell is the next sentence: "all four are needed, so breaking any one prevents deadlock". The common weak answer lists the four with nothing about how to use them.

"How do you prevent deadlock in practice?" The answer they want first is a global lock order, which breaks circular wait. Then try-locks with random backoff, which break hold-and-wait at the risk of livelock. Mention that databases instead detect and cancel a victim.

"Explain the Banker's algorithm." Know the three tables, need = maximum − allocation, the safety test, and the idea that a request is granted only if the resulting state is still safe. Be ready to work a small example by hand. The strong answer adds why real kernels do not use it: maximum needs are unknown and the set of jobs changes.

"What is the difference between a safe state and a deadlock?" An unsafe state is not yet a deadlock. It is a state from which a deadlock could happen. The Banker's algorithm refuses to enter unsafe states, even when the resources are free.

"How would you find a deadlock in a running system?" Build a wait-for graph and look for a cycle. In practice: a thread dump showing which thread holds and waits for what, database deadlock logs, or the kernel's "blocked for more than 120 seconds" warnings.

Something to volunteer that nobody asks for: operating systems mostly ignore deadlock in your locks, on purpose, because checking every lock operation would slow every program. That makes deadlock freedom your design responsibility, which is why a written lock order is a normal part of serious concurrent code.

Recall

  • A deadlock is a set of threads each waiting for something another in the set holds, so none can continue. In a resource-allocation graph, a cycle with single-instance resources is a deadlock.
  • The four Coffman conditions (mutual exclusion, hold and wait, no preemption, circular wait) must all hold; breaking any one prevents deadlock.
  • There are four approaches. Ignore it, which is what ordinary operating systems do for your locks. Prevent it, with a global lock order, or with try-lock and random backoff, which risks livelock. Avoid it, with the Banker's algorithm. Or detect a cycle in a wait-for graph and cancel a victim, which is what databases do.
  • The Banker's algorithm grants a request only if the system stays in a safe state: some order exists in which every job can get its remaining need (maximum − allocation), finish and return what it holds.
  • Real kernels do not use the Banker's algorithm, because maximum needs are unknown and jobs come and go; Linux's lockdep finds bad lock orders during development instead.

Self-test: Draw the album deadlock as a graph and point at the cycle. Which condition does a lock order break, and why does it stop the cycle? Work out what is free in the Banker's example, and which job can go first. Why was J0's request refused even though the resources were free? Why do Linux and Windows not prevent deadlocks in your program's locks?

Quiz Bank ​

FoundationalWhat is a deadlock, and what four conditions are required for it?

A deadlock is a situation in which two or more threads are each waiting for something held by another thread in the group, so none of them can ever continue. It needs all four Coffman conditions at the same time:

  1. Mutual exclusion: a resource can have only one holder.
  2. Hold and wait: a thread holds one resource while waiting for another.
  3. No preemption: a resource cannot be taken away from its holder.
  4. Circular wait: the waiting forms a cycle.

Because all four are needed, preventing any one of them makes deadlock impossible.

FoundationalWhat is the most practical way to prevent deadlock between locks?

A global lock order. Decide one fixed order for all locks, such as by ID, and make every thread take locks only in that order. Then no thread ever holds a later lock while waiting for an earlier one, so the waiting can never form a cycle, which breaks the circular-wait condition. For the album example, always locking the album with the smaller ID first means two opposite moves both wait at the same first lock, and one simply goes after the other.

AppliedWhat is the difference between a safe state, an unsafe state and a deadlock?

In the Banker's algorithm, a safe state is one in which some order exists where every job can be given its remaining need, finish and return everything it holds. A safe state can never deadlock, because the system can always serve the jobs in that order.

An unsafe state has no such order. It is not yet a deadlock, since jobs might happen to ask for less than their maximum, but it could become one. A deadlock is a state in which a cycle of jobs is already waiting forever. The Banker's algorithm refuses any request that would move the system into an unsafe state, even when the requested resources are free.

InterviewExplain the Banker's algorithm and work through whether a request should be granted.

Each job declares its maximum need of each resource. The system tracks what each job holds and its need, which is maximum minus held, plus what is free. To test safety: find a job whose need fits inside what is free, pretend it finishes and returns what it holds, add that to free, and repeat. If every job can finish, the state is safe.

For a request, there are three checks in order:

  1. If it asks for more than the job's declared need, refuse it.
  2. If it asks for more than is free, the job waits.
  3. Otherwise, pretend to grant it and run the safety test on the result. Grant it only if the result is safe. In the worked example, with (3, 3, 2) free, J1 can go first, and the safe order is J1, J3, J4, J0, J2. A later request by J0 for (0, 2, 0) fits what is free but leaves (2, 1, 0), inside which no job's need fits, so it is refused.
InterviewHow do databases handle deadlocks, and why can they do something an operating system cannot do with ordinary locks?

Databases detect deadlocks: when a transaction has waited for a lock for a while, they build a wait-for graph of transactions and search it for a cycle. If they find one, they choose a victim transaction, cancel it, undo its changes and release its locks, so the others can continue. The application receives a deadlock error and is expected to retry.

They can do this because a transaction can be undone safely: the database keeps a record of every change it made. An operating system cannot take a lock away from an ordinary thread, because the thread may be halfway through changing the data the lock protects, and there is no record that would let the kernel undo it. Databases can break the no-preemption condition; ordinary locks cannot.

StaffA team suggests adding a deadlock detector to their service that kills a thread when a lock cycle is found. Evaluate the proposal.

Detection is easy to build: record which thread holds and waits for which lock, and search for cycles periodically. Recovery is the problem. Killing or interrupting a thread that holds a lock leaves the data that lock protects in whatever half-changed state it was in, which is usually worse than the hang, because the service now keeps running on corrupt data. Unlike a database, the service has no log of changes with which to undo the victim's work.

A better plan is prevention plus visibility. Define and document a lock order, and enforce it in code, for example with a helper that always locks multiple albums sorted by ID. Use timeouts on lock acquisition in the few places where the order cannot be guaranteed, failing the request cleanly rather than killing a thread. Use detection only as a diagnostic that logs the cycle and the stacks, so the bug can be fixed. Where operations genuinely span several resources, move them into a database transaction, which has real deadlock recovery built in.

Scenario Drill ​

DrillThe photo-upload service occasionally hangs when two people move photos between the same two albums in opposite directions. Each move locks the source album and then the destination album. Explain the bug and give two fixes.

This is a textbook deadlock from inconsistent lock order. Moving from Holiday to Family locks Holiday then wants Family. Moving from Family to Holiday locks Family then wants Holiday. If the two run at the same moment, each holds one album and waits for the other: the circular wait closes, and all four Coffman conditions hold. It is rare because it needs the two moves to overlap in a tiny window.

Fix 1, a global lock order (preferred). Always lock the two albums in a fixed order whatever the direction of the move, for example the album with the smaller ID first. Both moves now try the same album first, so no cycle can form.

Fix 2, try-lock with backoff. Take the first album, then try the second with a short time limit. If it fails, release the first, wait a random moment and start again. This breaks hold-and-wait. It is more forgiving of code that cannot follow an order, but retries waste work, and without the random wait two threads could keep colliding, which is livelock.

At larger scale, store album membership in a database and do the move as one transaction (7.4.2), so the database's own deadlock detection protects it.

Next: every page in this Part has assumed that each process has its own private memory, and that two processes can never see each other's data. 2.5.1 finally explains how: virtual memory, the trick that gives every process the illusion of owning all the memory on the machine.

Combine chapters into one PDF

Pick the chapters you want. They print in the order you pick them.

Volume I — Technology
Part 0 — Retention & Notation
Part 1 — Foundations of Computation
Part 2 — Operating Systems
2.1 The Kernel
2.2 Processes
2.3 Threads & Scheduling
2.4 Concurrency Under the Hood
2.5 Memory Management
2.6 File Systems
2.7 Input/Output
2.8 Linux for Engineers
2.9 Windows & macOS in Practice
Part 3 — Languages, Compilers & Runtimes
3.6 JavaScript & V8
3.7 TypeScript
3.8 Node.js Internals
3.13 Python & CPython
3.14 FastAPI & Production Python
Part 4 — Data Structures & Algorithms
4.0 Classic Problems — Before NeetCode
4.4 Arrays & Hashing — Problems
4.5 Two Pointers
4.6 Sliding Window
4.8 Stack — Problems
4.9 Linked List — Problems
4.11 Binary Search — Problems
4.13 Trees
4.14 Tree — Problems
4.15 Trie — Problems
4.17 Heap — Problems
4.18 Backtracking — Problems
4.19 Graphs
4.20 Graph — Problems
4.21 Advanced Graph — Problems
4.23 1-D DP — Problems
4.24 2-D DP — Problems
4.26 Greedy — Problems
4.27 Interval — Problems
4.28 Math & Geometry — Problems
4.30 Bit Manipulation — Problems
Part 5 — Networking & the Web
5.3 IP
5.4 Transport
5.6 HTTP
Part 6 — Frontend Engineering
6.1 Browser Internals
6.2 HTML & CSS Mastery
6.3 JavaScript in the Browser
6.4 React, from First Component to Full Shop
6.5 Frameworks & Rendering
6.8 UI Engineering & Patterns
Part 7 — Databases & Storage
7.2 SQL Mastery
7.3 Storage Engine Internals
7.4 Transactions
7.5 NoSQL Taxonomy
7.8 Analytics & Big Data
Part 8 — Security, Identity & Cryptography
8.2 Cryptography
8.3 Protocols of Trust
8.4 Identity: AuthN & AuthZ
8.5 Application Security
8.6 Infrastructure Security
Part 9 — Software Design (LLD)
9.2 OOP Foundations
9.3 Design Principles
9.4 Design Patterns
9.5 Concurrency
9.6 API Design
9.7 LLD Interview Machines
9.9 Node/Express Production Playbook
Part 10 — Distributed Systems & HLD
10.7 Consistency & Consensus
10.8 Messaging & Microservices
10.14 Caching
Building blocks from the design seat
Part 11 — System Design Case Studies
Part 12 — AI & ML Engineering
12.1 What AI Engineering Is
12.2 The Math You Need
12.3 Classical Machine Learning
12.4 Data for ML
12.5 Deep Learning
12.6 Embeddings & Vector Search
12.7 Transformers & LLMs
12.8 Building with LLMs
12.9 Retrieval-Augmented Generation
12.10 Agents
12.11 Adapting Models
12.12 Production AI
12.13 Multimodal AI
12.14 AI Security & Governance
12.15 Case Studies & Capstone
Part 13 — Cloud, DevOps & Infrastructure
13.11 Git, from First Commit to Team Workflow
Part 14 — Containers: Docker & Kubernetes
14.1 Foundations
14.2 Docker
14.3 Kubernetes
14.4 Kubernetes on Azure
Part 15 — The Craft & Career
Nothing picked yet