"Clean" Code, Horrible Performance

5 hours ago

Many 'clean code' rules, such as preferring polymorphism over switch statements, lead to significant performance degradation (1.5x to 15x slower).
Using a class hierarchy with virtual functions introduces indirection, pointer arrays, and hides code patterns from the compiler, causing poor optimization.
Replacing polymorphism with a switch statement on a flat struct union improved performance by 1.5x; further using a lookup table (data-driven approach) achieved 10x speedup.
Adding more properties (like corner count) to the problem widened the performance gap: clean code became 15x slower than the table-driven version.
The compiler cannot optimize code that is fragmented across translation units and behind virtual calls, limiting both manual and automatic optimization.
AVX-optimized code (which violates clean code principles) achieved 20-25x speedup over the clean code version.
Rules like 'DRY' are reasonable, but the four structural rules (polymorphism, no internal knowledge, small functions, single responsibility) are harmful to performance.
The author argues that clean code methodology can erase 12-14 years of hardware progress, and that maintainability must be weighed against such extreme performance costs.

Performance optimization requires a mindset shift and systematic approach, not just writing better code.
Avoid broad, unscientific advice like avoiding STL or exceptions; focus on project-specific profiling.
After initial easy wins, further improvements require deep analysis via call-graph profiling, not just flat profiles.

The author's code writing has shifted from 90% human-written to 90% AI-written in eight months.
The task involved optimizing a matrix-multiply kernel using Cluster Launch Control (CLC) on GPUs, where AI assisted in finding, understanding, fixing, and benchmarking code.
AI helped identify unused shared memory to fix a deadlock, and suggested multiple optimizations, leading to faster code for problematic inputs.

The cost of producing plausible code has collapsed, but broad claims about dramatic speedups, obsolete practices, or halving headcount are unproven.
Management practices should be audited based on their underlying assumptions: those resting on code cost need review; those on human coordination, trust, or verification remain valid.
Evidence of speedups is smaller than noise; honest instrumentation is needed to measure actual acceleration, not felt speed.

Pretraining runs often fail due to breaking causality (e.g., expert choice routing where token allocation depends on future tokens) and adding bias (e.g., FP16 precision issues in collectives causing large accumulated errors).
Breaking causality is problematic because it introduces information during training that is unavailable at inference, leading to model degradation; examples include Llama 4 (expert routing) and Gemini 2 Pro (token dropping).
Bias is more dangerous than variance because it compounds, as seen in an early GPT-4 training bug where FP16 rounding caused a 10x error in gradient accumulation.

Tailwind requires learning dozens of utility classes, slowing initial development.
It breaks the separation of structure and design, bloating HTML and reducing readability.
Class naming is inconsistent, causing confusion (e.g., items-center vs justify-center).

Performance optimization requires a mindset shift and systematic approach, not just writing better code.
Avoid broad, unscientific advice like avoiding STL or exceptions; focus on project-specific profiling.
After initial easy wins, further improvements require deep analysis via call-graph profiling, not just flat profiles.

The author's code writing has shifted from 90% human-written to 90% AI-written in eight months.
The task involved optimizing a matrix-multiply kernel using Cluster Launch Control (CLC) on GPUs, where AI assisted in finding, understanding, fixing, and benchmarking code.
AI helped identify unused shared memory to fix a deadlock, and suggested multiple optimizations, leading to faster code for problematic inputs.

The cost of producing plausible code has collapsed, but broad claims about dramatic speedups, obsolete practices, or halving headcount are unproven.
Management practices should be audited based on their underlying assumptions: those resting on code cost need review; those on human coordination, trust, or verification remain valid.
Evidence of speedups is smaller than noise; honest instrumentation is needed to measure actual acceleration, not felt speed.

Pretraining runs often fail due to breaking causality (e.g., expert choice routing where token allocation depends on future tokens) and adding bias (e.g., FP16 precision issues in collectives causing large accumulated errors).
Breaking causality is problematic because it introduces information during training that is unavailable at inference, leading to model degradation; examples include Llama 4 (expert routing) and Gemini 2 Pro (token dropping).
Bias is more dangerous than variance because it compounds, as seen in an early GPT-4 training bug where FP16 rounding caused a 10x error in gradient accumulation.

Tailwind requires learning dozens of utility classes, slowing initial development.
It breaks the separation of structure and design, bloating HTML and reducing readability.
Class naming is inconsistent, causing confusion (e.g., items-center vs justify-center).

Hasty Briefsbeta