Tap a claim on the ring to put it at the centre.
← Hand-optimizing hot spots barely matters any more, because the…
17 connected korrents · 11 moments from 11 Jun 2021 to 26 Aug 2026.
Everything filed under software performance
software performance
Everything filed under compilers
compilers
Everything filed under Python
Python
Everything filed under developer tools
developer tools
Everything filed under benchmarks
benchmarks
Everything filed under simplicity
simplicity
Everything filed under data centers
data centers 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: Hand-optimizing hot spots barely matters any more, because the libraries are already fast and CPUs are extremely good at running bad code quickly; what is left is architecture. Hand-optimizing hot spots barely matters any more, because the libraries are already fast and CPUs are extremely good at running bad code quickly; what is left is architecture. Last stated 2 months ago
26 Aug 2026
CM
Casey Muratori — holds since 2026-08-26 — tap for who they are
Same subject: How data is laid out and how it is accessed are architectural decisions with nothing to do with hot spots, and the difference between two layouts can be enormous. — tap to centre the map on it How data is laid out and how it is accessed are architectural decisions with nothing to do with hot spots, and the difference between two layouts can be enormous. Last stated 2 months ago
26 Aug 2026
CM
Casey Muratori — holds since 2026-08-26 — tap for who they are
Same subject: "Optimize it later" would be safe advice only if every engineer already knew how to avoid the architectural mistakes that no later optimization can remove. — tap to centre the map on it "Optimize it later" would be safe advice only if every engineer already knew how to avoid the architectural mistakes that no later optimization can remove. Last stated 2 months ago
26 Aug 2026
CM
Casey Muratori — holds since 2026-08-26 — tap for who they are
Same subject: The steady stream of "we had to rewrite the whole thing because it was too slow" engineering blog posts is the proof that deferring performance to hotspot optimization does not work. — tap to centre the map on it The steady stream of "we had to rewrite the whole thing because it was too slow" engineering blog posts is the proof that deferring performance to hotspot optimization does not work. Last stated 2 months ago
26 Aug 2026
CM
Casey Muratori — holds since 2026-08-26 — tap for who they are
Same subject: Everyone on a team who makes architectural decisions must understand performance, because a codebase that can be optimized later only ends up that way on purpose. — tap to centre the map on it Everyone on a team who makes architectural decisions must understand performance, because a codebase that can be optimized later only ends up that way on purpose. Last stated 2 months ago
26 Aug 2026
CM
Casey Muratori — holds since 2026-08-26 — tap for who they are
Same subject: Criticism that a simpler, scaled-up architecture underperforms a heavily hand-optimized baseline actually demonstrates why that architecture-scaling research matters. — tap to centre the map on it Criticism that a simpler, scaled-up architecture underperforms a heavily hand-optimized baseline actually demonstrates why that architecture-scaling research matters. Last stated 5 years ago
11 Jun 2021
GW
Gwern — holds since 2021-06-11 — 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: Even at top-100 traffic levels most applications can be served by a simple monolith, and it is cheaper to build than a complex architecture. — tap to centre the map on it Even at top-100 traffic levels most applications can be served by a simple monolith, and it is cheaper to build than a complex architecture. Last stated 5 years ago
6 Apr 2022
DL
Dan Luu — holds since 2022-04-06 — tap for who they are
Same subject: Cooling adds nothing to what a data centre produces, which is why it is the first thing a good design deletes rather than optimises. — tap to centre the map on it Cooling adds nothing to what a data centre produces, which is why it is the first thing a good design deletes rather than optimises. Last stated 3 years ago
18 Apr 2024
AV
Austin Vernon — holds since 2024-04-18 — 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 good tool raises the floor of what people can build without lowering the ceiling, and almost every tool quietly lowers the ceiling. — tap to centre the map on it A good tool raises the floor of what people can build without lowering the ceiling, and almost every tool quietly lowers the ceiling. Last stated a year ago
18 Sept 2025
TL
Tobias Lütke — holds since 2025-09-18 — 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
Hand-optimizing hot spots barely matters any more, because the libraries are already fast and CPUs are extremely good at running bad code quickly; what is left is architecture.
Holds Read this korrent →
How data is laid out and how it is accessed are architectural decisions with nothing to do with hot spots, and the difference between two layouts can be enormous.
Holds
"Optimize it later" would be safe advice only if every engineer already knew how to avoid the architectural mistakes that no later optimization can remove.
Holds
The steady stream of "we had to rewrite the whole thing because it was too slow" engineering blog posts is the proof that deferring performance to hotspot optimization does not work.
Holds
Everyone on a team who makes architectural decisions must understand performance, because a codebase that can be optimized later only ends up that way on purpose.
Holds
Criticism that a simpler, scaled-up architecture underperforms a heavily hand-optimized baseline actually demonstrates why that architecture-scaling research matters.
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
Even at top-100 traffic levels most applications can be served by a simple monolith, and it is cheaper to build than a complex architecture.
Holds
Cooling adds nothing to what a data centre produces, which is why it is the first thing a good design deletes rather than optimises.
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 good tool raises the floor of what people can build without lowering the ceiling, and almost every tool quietly lowers the ceiling.
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