Tap a claim on the ring to put it at the centre.
← Concurrent code only becomes faster from parallelization when the…
17 connected korrents · 14 moments from 1 Feb 2015 to 26 Aug 2026.
Everything filed under software performance
software performance
Everything filed under compilers
compilers
Everything filed under developer tools
developer tools
Everything filed under Python
Python
Everything filed under software quality
software quality
Everything filed under design
design
Everything filed under coding agents
coding agents Same subject Same subject Same subject Same subject Same subject Same subject Same subject Same subject Same subject Same subject Same subject Same subject Same subject Same subject Same subject Same subject Same subject Read this korrent: Concurrent code only becomes faster from parallelization when the underlying problem is itself intrinsically parallel. Concurrent code only becomes faster from parallelization when the underlying problem is itself intrinsically parallel. Last stated 3 years ago
4 Jan 2024
RP
Rob Pike — holds since 2024-01-04 — tap for who they are
Same subject: Concurrency is hard not because human brains cannot handle it but because nobody gets enough practice at it. — tap to centre the map on it Concurrency is hard not because human brains cannot handle it but because nobody gets enough practice at it. Last stated 3 months ago
29 Jul 2026
HW
Hillel Wayne — holds since 2026-07-29 — tap for who they are
Same subject: There is no trade-off between well-architected code and fast code: in practice, the code that is architected properly is also the code that runs quickly. — tap to centre the map on it There is no trade-off between well-architected code and fast code: in practice, the code that is architected properly is also the code that runs quickly. Last stated 2 months ago
26 Aug 2026
CM
Casey Muratori — holds since 2026-08-26 — tap for who they are
Same subject: Structured concurrency makes it easier to write correct, safe concurrent code. — tap to centre the map on it Structured concurrency makes it easier to write correct, safe concurrent code. Last stated 7 months ago
23 Mar 2026
NE
Nelson Elhage — holds since 2026-03-23 — tap for who they are
Same subject: Asynchrony should be a property of how a program is run, not a colour baked into the type of every function in the standard library. — tap to centre the map on it Asynchrony should be a property of how a program is run, not a colour baked into the type of every function in the standard library. Last stated 12 years ago
1 Feb 2015
BN
Bob Nystrom — holds since 2015-02-01 — tap for who they are
Same subject: A programming environment should provide exactly one concurrency model, since offering multiple concurrency implementations at once causes problems. — tap to centre the map on it A programming environment should provide exactly one concurrency model, since offering multiple concurrency implementations at once causes problems. Last stated 3 years ago
4 Jan 2024
RP
Rob Pike — holds since 2024-01-04 — tap for who they are
Same subject: The loop has flipped: it used to be faster to mock up software than to ship it, and now designers can work iteratively in production code. — tap to centre the map on it The loop has flipped: it used to be faster to mock up software than to ship it, and now designers can work iteratively in production code. Last stated 7 months ago
7 Apr 2026
LW
Luke Wroblewski — holds since 2026-04-07 — tap for who they are
Same subject: Concurrency is hard for novices and experts alike: even experts regularly get it wrong. — tap to centre the map on it Concurrency is hard for novices and experts alike: even experts regularly get it wrong. Last stated 5 years ago
3 Aug 2021
KV
Kenton Varda — holds since 2021-08-03 — tap for who they are
Same subject: The speed of a system is set by its longest serial dependency chain, which is a property of the architecture and cannot be parallelised away afterwards. — tap to centre the map on it The speed of a system is set by its longest serial dependency chain, which is a property of the architecture and cannot be parallelised away afterwards. Last stated 2 months ago
26 Aug 2026
CM
Casey Muratori — holds since 2026-08-26 — tap for who they are
Same subject: A compiler that also serves an IDE has to be lazy and deferred throughout — a different way of building compilers from the one the textbooks teach. — tap to centre the map on it A compiler that also serves an IDE has to be lazy and deferred throughout — a different way of building compilers from the one the textbooks teach. Last stated 5 months ago
13 May 2026
AH
Anders Hejlsberg — holds since 2026-05-13 — tap for who they are
Same subject: A developer using AI coding tools remains responsible for reviewing the code they ship. — tap to centre the map on it A developer using AI coding tools remains responsible for reviewing the code they ship. Last stated 7 months ago
10 Mar 2026
JS
Jon Seager — holds since 2026-03-10 — tap for who they are
Same subject: A people manager needs enough technical depth to follow discussions and judge debates without relying on trust, but not the deepest technical expertise on the team. — tap to centre the map on it A people manager needs enough technical depth to follow discussions and judge debates without relying on trust, but not the deepest technical expertise on the team. Last stated 2 years ago
21 Jul 2024
BK
Ben Kuhn — holds since 2024-07-21 — tap for who they are
Same subject: A compiler that names every place a change breaks turns refactoring into fixing errors until the compiler stops shouting. — tap to centre the map on it A compiler that names every place a change breaks turns refactoring into fixing errors until the compiler stops shouting. Last stated 5 months ago
20 May 2026
AR
Alice Ryhl — holds since 2026-05-20 — tap for who they are
Same subject: A programming language is not a compiler but an experience: editing, running, debugging and the runtime library all have to fit together as one cycle. — tap to centre the map on it A programming language is not a compiler but an experience: editing, running, debugging and the runtime library all have to fit together as one cycle. Last stated 5 months ago
13 May 2026
AH
Anders Hejlsberg — holds since 2026-05-13 — tap for who they are
Same subject: A speed difference between languages that share the LLVM backend measures the benchmark author, not the languages. — tap to centre the map on it A speed difference between languages that share the LLVM backend measures the benchmark author, not the languages. Last stated 2 years ago
22 Mar 2025
TH
ThePrimeagen — holds since 2025-03-22 — tap for who they are
Same subject: A language can keep changing without a Python-2-to-3 break, as long as code written under the old and the new rules can be mixed freely in one program. — tap to centre the map on it A language can keep changing without a Python-2-to-3 break, as long as code written under the old and the new rules can be mixed freely in one program. Last stated 5 months ago
20 May 2026
AR
Alice Ryhl — holds since 2026-05-20 — tap for who they are
Same subject: Python is ugly: full of superfluous instructions kept since 1987 for legacy reasons, and its __init__ offends the sensibilities to the core. — tap to centre the map on it Python is ugly: full of superfluous instructions kept since 1987 for legacy reasons, and its __init__ offends the sensibilities to the core. Last stated a year ago
12 Jul 2025
DH
David Heinemeier Hansson — holds since 2025-07-12 — tap for who they are
Same subject: Sharing code between classes via inheritance in Python tends to produce a bad experience. — tap to centre the map on it Sharing code between classes via inheritance in Python tends to produce a bad experience. Last stated 3 months ago
21 Jul 2026
JE
Julia Evans — holds since 2026-07-21 — tap for who they are
At the centre
Concurrent code only becomes faster from parallelization when the underlying problem is itself intrinsically parallel.
Holds Read this korrent →
Concurrency is hard not because human brains cannot handle it but because nobody gets enough practice at it.
Holds
There is no trade-off between well-architected code and fast code: in practice, the code that is architected properly is also the code that runs quickly.
Holds
Structured concurrency makes it easier to write correct, safe concurrent code.
Holds
Asynchrony should be a property of how a program is run, not a colour baked into the type of every function in the standard library.
Holds
A programming environment should provide exactly one concurrency model, since offering multiple concurrency implementations at once causes problems.
Holds
The loop has flipped: it used to be faster to mock up software than to ship it, and now designers can work iteratively in production code.
Holds
Concurrency is hard for novices and experts alike: even experts regularly get it wrong.
Holds
The speed of a system is set by its longest serial dependency chain, which is a property of the architecture and cannot be parallelised away afterwards.
Holds
A compiler that also serves an IDE has to be lazy and deferred throughout — a different way of building compilers from the one the textbooks teach.
Holds
A developer using AI coding tools remains responsible for reviewing the code they ship.
Holds
A people manager needs enough technical depth to follow discussions and judge debates without relying on trust, but not the deepest technical expertise on the team.
Holds
A compiler that names every place a change breaks turns refactoring into fixing errors until the compiler stops shouting.
Holds
A programming language is not a compiler but an experience: editing, running, debugging and the runtime library all have to fit together as one cycle.
Holds
A speed difference between languages that share the LLVM backend measures the benchmark author, not the languages.
Holds
A language can keep changing without a Python-2-to-3 break, as long as code written under the old and the new rules can be mixed freely in one program.
Holds
Python is ugly: full of superfluous instructions kept since 1987 for legacy reasons, and its __init__ offends the sensibilities to the core.
Holds
Sharing code between classes via inheritance in Python tends to produce a bad experience.
Holds