[hnlmorg]

I think developers sometimes get too obsessed with code quality thinking that smarter code makes them a better developer. In fact I’ve seen developers fall into the trap of mistaking their code as the product and thus spend so much time beautifying it that that fail to ever release anything.

Then you have the other end of the spectrum where people are too focused on hacking stuff together that the end result is unmaintainable.

The reality is there needs to be a bit of both to be a good developer.

For example, if you’re building a proof of concept (POC), then it’s more important to prove the idea than it is to define the architecture. And the reason for that is because you don’t always understand how the final product (whether it’s commercial software or a FOSS library) is best architected until you’ve gone through a few drafts of the idea. So spaghetti code isn’t necessarily a bad thing.

But then when you know your idea works and you need to flesh it out into something more durable, you start to refactor the spaghetti into something more maintainable.

Fabrice mainly releases POCs while Carmack mainly releases finished products. So it’s unsurprising you’ll see a difference in the style of architecting in their code.

I used to be someone who focused on beautiful code for my POCs too. And used to fail to release any personal projects. Then one day I learned to embrace the chaos of POCs and realised that you can getting something built and tarting it up afterwards was better than failing to build anything at all.

[21asdffdsa12]

But the code quality is speed. And reach. You can not advance, unless you can read the code, you can understand the model, you can not scale beyond a certain point. The beauty of the architecture is the ability to build a spaceship compared to a train of kerosene tankers. Physically similar, but in capability radical different.

I find this very scary. Somebody unable to perceive capabilities and tech-debt. If you can not perceive that- you should not be let near executive decisions or code-base evaluation. This is literally the difference between rocket-science and exploding failed projects. Everyone can pile up explosives, not everyone can go to space today.

Its a great interview topic to filter this kind of candidate out of companies.

[hnlmorg]

> But the code quality is speed

No it’s not. Code quality is just code quality. It's a subjective measure. eg how do you define one thing is of greater "quality" than another? Is it CPU ops? Memory footprint? Code readability? And how do you measure readability? By who? What I find readable someone else might not, and visa versa.

If you’re making choices to improve development throughput then that’s fine. But so often I see developers architecting code for what they mistakenly think will improve their throughput but ultimately they spend longer on writing those abstractions than any time they have saved when using them.

XKCD parodies this problem with their pass the salt sketch: https://xkcd.com/974/

Sometimes this comes down to developer vanity, sometimes it comes down to poor alignment of goals and/or communication between the product teams and development teams. And sometimes it’s just because solving problems is fun so naturally we’ll look for problems to solve. But whatever the reasons, I’ve personally seen this happen (as well as being a victim of it myself) enough times to know it is an underestimated problem.

> I find this very scary. Somebody unable to perceive capabilities and tech-debt. If you can not perceive that- you should not be let near executive decisions or code-base evaluation.

This is a rather insulting assumption. I've been a tech lead for around 2 decades now and have worked on plenty of brownfield projects in that time. I know what tech debt looks like.

The problem with "tech debt" is it can mean anything from "this is ugly code that takes 5 minutes longer to read but it works well" to "this in a insecure/unstable pile of horse manure and customers will start to notice".

The latter is where time should be spent. The former is a vanity project that doesn't bring the business any value.

That's not to say that developers shouldn't ever spend time on the former examples of tech debt, just that it's of a lower priority than getting the project working.

[ryandrake]

This is one of the reasons I got away from writing commercial software and now only write code as a hobby.

To me, the code itself is the product. I want the code to look like a beautiful painting—the fact that it does something is secondary. I’ll sit there for hours working on things like const correctness, and making sure each class has the bare minimum amount of state/instance variables, making sure function arguments are named and ordered consistently, even though it has no effect on user-visible bugs or runtime performance. I’m the kind of person that paints the back of the cabinet. Even though no user will see it, I will know it is there.

Obviously this mentality is at odds with commercial software’s imperative to shit out barely working spaghetti code as fast and cheaply as possible, so I opted out.

[cgh]

“Paints the back of the cabinet” is a great analogy. LLM-driven production is so far away from this mindset.

[lanstin]

Have you ever done research mathematics? To me, the only difference between code and math is that the code can do things, make stuff happens in the world; outside of that, mathematics has a lot more opportunities to be beautiful (not to say that there isn't beautiful code, but the beauty is not central in the way it often is in mathematics).

[hnlmorg]

Yeah, a lot of businesses definitely do push things too far the other way and advocate releasing _anything_ regardless of how well it works.

I'm strongly against the "move fast and break things" mentality. But there is a happy middle ground between architecting works of art, and shipping urinals with faulty plumbing.

[fdsfsdsd]

Although in this case it's more like using the paint in the tin to paint the tin itself. It's useless and completely missing the point of why the paint exists in the first place.

You do you, I'm sorry if I come across rude and stupid, but I am both things. But "code is the product" is what IMO caused the downfall of this entire profession. No wonder everyone is trying to get rid of us. I wouldn't want a plumber that's obsessed with the tubes itself and not whether my house has working plumbing in a reasonable time frame and within budget.

[stouset]

Despite the gallons of ink spilled on the subject I have not worked at a single place in my 30-year career where developers sat around perfecting masterpieces.

I have worked at a never-ending list of places where people shipped the first thing that worked, built spaghetti around it, something else got built on top, and the original thing is now critical infrastructure that takes 10x longer to fix bugs or add needed features to than it would have if we’d taken 1.5x longer to ship it in the first place. I have worked at a never-ending list of places where developers beg for time to be set aside to deal with the worst parts that sap their time, energy, or will to continue working at the job. I have worked at a never-ending list of places that eventually sets aside a few days to tackle these tasks, when the engineers estimate two or three weeks. I have worked at a never-ending list of places that then uses the failure of these momentary diversions as evidence that their engineers don’t know what they’re talking about and should shut up and ship more features.

I sure wish I knew what masterpiece factories you must have spent your career working at.

[agentultra]

I feel like the navel-gazing-ivory-tower programmer is almost a straw man used by commenters and bloggers to make themselves sound pragmatic. Summoned only be be torn down. Never to be found on an existing software team.

I have come across the architecture astronaut before. But I feel like they’re the result of the culture of the ecosystem the language. The Java and C# programmers whose language requires you to juggle weak types with visibility keywords and null ability. They can be forgiven for not being able to implement a priority queue without a committee and a class hierarchy deeper than the Mariana Trench.

But the perfectionist that never ships anything useful and only ever tweaks interfaces and types? Never met one.

Most people are just trying to balance progress with practical concerns.

[qdotme]

I’ve been in this profession for two decades as well. As both things.

My take on this is that we need both, because the market is cyclical. It’s just that it’s hard to perceive any of those cycles if you (a) live them (b) are not experienced enough to introspect.

I absolutely would love an obsessed plumber (and got one!) when it comes to deciding that we’re going to do PTFE tubing in our new house. An obsessed electrician in charge to overinvest into our grid, rather than a 3-month timeframe executive. Otherwise our critical infrastructure gets myopically degraded.

I also want the “working within timeframe” outcome.

And we, as an industry, swing wildly in both direction. The Cambrian explosion of shareware was the the former. We course-corrected into cathedrals of good software (I still love Windows 2000’s stability, the pinnacle of NT line), followed by the “reasonable timeframe” 4GB Electron apps, etc.

It will swing. Every complex system from logistic equation upwards will oscillate .

[dkarl]

> The problem with "tech debt" is it can mean anything from "this is ugly code that takes 5 minutes longer to read but it works well" to "this in a insecure/unstable pile of horse manure and customers will start to notice". > > The latter is where time should be spent. The former is a vanity project that doesn't bring the business any value.

You may have worked with people whose meaning of "code quality" encompassed things that you found inconsequential and a waste of effort. They may have even told you that if you didn't care about those things, then you didn't care about code quality. But that's not true. It only meant you disagreed with them about what code quality is and how to recognize it.

You draw a distinction between aspects of code that tend to lead to better outcomes and aspects of code that don't matter. You say you know what tech debt looks like. When you look at a codebase, you have opinions on where time should be spent to improve it. "Code quality" is shorthand for the heuristics underlying those opinions.

Instead of accepting that other, possibly dumber people get to define what code quality is, own your own definition of it and use it when you communicate with other people.

[hnlmorg]

I don't think you're being very charitable in your reading of my comments. For example:

> You may have worked with people whose meaning of "code quality" encompassed things that you found inconsequential and a waste of effort. They may have even told you that if you didn't care about those things, then you didn't care about code quality. But that's not true. It only meant you disagreed with them about what code quality is and how to recognize it.

Who's these "people" you're referring to? This is an imaginary conversation you've added.

What I actually said was that there's a balance between design and output.

I did generalize that often product people will push too far towards output and often developers will push too far between design, but like all generalizations, I know there are exceptions (eg me).

But the crux of my point is that there are tradeoffs between the two, and thus times when it makes more sense to lean towards output and times when it makes more sense to focus on design.

What you've replied with isn't even remotely the same sentiment as the comment I made.

> You draw a distinction between aspects of code that tend to lead to better outcomes and aspects of code that don't matter. You say you know what tech debt looks like. When you look at a codebase, you have opinions on where time should be spent to improve it. "Code quality" is shorthand for the heuristics underlying those opinions.

No. Code quality is just a subjective term that means nothing in reality because everyone will have different goals in mind when they think about the purpose of the code.

So the underlying heuristics require far insight into project goals, deadlines, and resources than just "code quality".

> Instead of accepting that other, possibly dumber people get to define what code quality is,

The original reason I replied (albeit I did digress quite a bit) was to demonstrate that you cannot extrapolate how smart or dumb an engineer is from their "code quality" alone. So please refrain from calling people dumb in your rebuttals.

> own your own definition of it and use it when you communicate with other people.

That's literally what I've done.

---

This comment better summarizes my point: https://news.ycombinator.com/item?id=48555191

[brunooliv]

Thanks for saying this! I completely agree with everything you said!

There’s far, far too many people who confuse code quality for speed of development and start treating code quality as the product for customer base in the hundreds and active customers in the dozens and for most features to be basically unused.

The reality is that tech debt as a concept these days is hardly real: to be in debt means previous decisions or a previous implementation makes current work extremely hard or impossible, but, the truth is that the human factors such as knowing what to build, team collaboration and even speaking to customers matter far more and can get you “in debt” so so much faster than code alone. At least in your typical SaaS company.

If you ship code in a way that you let tech debt pile up to the point that customers notice it, you have an organisational problem, not code issues per se.

The fact that a lot of people don’t get this is really baffling to me.

[21asdffdsa12]

Im talking about the speed of mental model building, understanding concepts, relations and organizational concepts.

Good codebases sort of read themselves. You can guess where things are, how they are sorted and how they work, by understanding and relying on the authors ideas.

[hnlmorg]

“Good” code makes trade offs. While readability is an important constraint, it’s far from being the only constraint. And there are plenty of occasions where objectively better code is subjectively harder to read because other constraints trump human parserability, such as using CPU-friendly memory layouts, SIMD-instructions in tight mathematical loops, and so on and so forth.

Not to mention that readability is entirely dependent on the readers familiarity with particular coding styles. Eg someone unfamiliar with SQL would find ORMs easier to read, whereas I find SQL easier than ORMs. Same is true for any other paradigm, eg for functional vs imperative.

And this is why I hate when people generalise about human readability being the definition of “good code”. For one thing, there will never be a consensus on what is more readable. And external constraints might require subjectively less readable code.

[overfeed]

> But the code quality is speed. And reach. You can not advance, unless you can read the code, you can understand the model, you can not scale beyond a certain point

Other people can do the important work of investing time to understand the model and simplify the code architecture, as proven many times over by actively maintained projects pioneered by Fabrice.

To kickstart a project, you have to show people that something they assumed impossible or hard to achieve is actually possible by dropping it in front of them.

> Its a great interview topic to filter this kind of candidate out of companies.

Fabrice Bellard ships. It makes sense to filter him out if you're a bank or an org with well-established products that prefers stability over velocity. If you're a start-up or have lots of greenfield projects requiring fast experimentation loops: you need folk who can ship quickly. Most organizations have a mix of projects and need a healthy mix of engineers, or ones who can flip modes relevant to the project.

[pjmlp]

Companies outside software as a product rarely care that much about what their physical goods are processed by IT, this is how you get outsourcing and offshoring of most of their computing needs, they won't care one second to filter such candidates.

[MomsAVoxell]

“You can read the code”

.. is very, very important in the context of milliseconds, hours, days, weeks, months and years. And decades.

Today, you might say that John/Fabrice’ code is readable/unreadable, but will that also be true in 5 years time, in a different cultural/technological era?

Obviously yes in the case of these individuals - because the ecosystem their products have created is self-sustaining at a mass (consumer/social) level.

I’ve built software which has shipped and effected the lives of millions, too. Many of us have.

But I have not built a massive ecosystem by working on the right software which was adopted by millions of developers who read my code, was inspired by it, and used it for something in their own products - thus creating sub-ecosystems upon sub-ecosystems, a big sprawling tree of economy which spreads out into the mass of humanity who use technology.

In this story we have two cases of individuals who have accomplished an extraordinary reach of software, in their own uniquely flavored ways - and this demonstrates that there are no absolute requirements to strip personality from the code - as long as its damn good code in the first place.

>filter candidates out of companies

It’s a great way to decide not to work at a company which managers do not understand the importance of architecture at various scales, milliseconds, seconds, hours, days, weeks ..

[gpderetta]

great coders ship.

[jongjong]

I agree with this for complex problems which cannot be vibe coded with AI. So definitely it's an essential skill for any human engineer.

[FpUser]

>"But the code quality is speed. And reach. You can not advance, unless you can read the code"

I am not sure about "proper" definition of spaghetti code but speaking of long functions: if it is straight code that reads like a book and has no common parts to refactor for further reuse it is actually way more understandable and debuggable then mess of 3 liners spread among 20 files and 10 microservices running under k8s.

>", you can understand the model, you can not scale beyond a certain point"

The needed scaling is being determined by business needs / projection. If you implement service for some SMB that deals with few partners and limited set of business entities in database and architecture of said service addressing Google style of scalability with corresponding overheads and costs you are definitely committing a crime in relation to your client.

>"Its a great interview topic to filter this kind of candidate out of companies." -

basically making sure that instead of pragmatic engineer who can deliver functional and serviceable product to client in reasonable time with reasonable costs you will have them pay for spaceship built by architecture astronauts

[nixon_why69]

It's the opposite, better-factored code makes me, a mediocre developer, capable of making progress instead of hitting a complexity wall.

It's separate from striving for "beautiful" code, beauty within well-factored boundaries yields dimishing returns compared to just having the boundaries.

[hnlmorg]

You’re ostensibly arguing the same thing I am though. Focusing on building the thing rather than designing the code to look pretty.

[nixon_why69]

I haven't read the codebases in question but people were talking about spaghetti code, which would not be well-factored and would impede someone less talented from comprehending it or being able to change it effectively.

I guess I'm saying there are code quality concerns which do affect velocity/maintainability and then there are superficial and stylistic issues. The former aren't just about some kind of beauty standard, they're part of executing.

[hnlmorg]

The comments about Ballard's code is very subjective. But if we take their comments at face value:

> which would not be well-factored and would impede someone less talented from comprehending it or being able to change it effectively.

Except the community did comprehend it and changed it effectively. Ballard hasn't maintained ffmpeg nor qemu for 20+ years.

> I guess I'm saying there are code quality concerns which do affect velocity/maintainability and then there are superficial and stylistic issues. The former aren't just about some kind of beauty standard, they're part of executing.

Which is why I'm saying we're basically arguing the same things. For a POC you get more velocity when focusing on proving that idea. I'm not saying zero effort should be spent on architecting the code. Just that you don't always know how best to organize it until you've had several revisions so developers shouldn't get too caught up trying to intellectualize the best internal layout. That can grow once the problem is better understood.

And I made this point because I felt the comparisons of one engineers POC to another engineers commercial release was unfair. They're completely different ends of the factory.

[nixon_why69]

Ok, yeah I hear you there and agree with basically everything. I've actually made those arguments in different contexts. Thumbs up emoji.

[bitwize]

It's not about "looking pretty". Beautiful code is easy to read, comprehend, and change; it's not simply nice formatting.

[lproven]

I don't think "ostensibly" means what you think it means.

But I can't guess what you meant.

[TremendousJudge]

>For example, if you’re building a proof of concept (POC), then it’s more important to prove the idea than it is to define the architecture.

I have tried to do this for POCs (just hacking everything together), and I always get stuck very quickly. Then until I figure out some sort of architecture for what I'm supposed to be doing I can't proceed. It's like, once I have the first step (of several) of the a POC working, I literally cannot think of how to implement the second one until the first one is somewhat well organized

[bitwize]

If your code is a low-stakes one-and-done and it works in the end, messy code is forgivable. Undertale looks like Yandere Simulator inside; nobody cares.

But if your code is something that needs to be maintained over time and/or has constraints in terms of security, availability, etc., like virtually all code is, then yes: clearer, better factored, more readable code is a big part of the product because it's a massive favor both to yourself and your successors when changes have to be made and results in quicker changes, lowered costs for changes, and higher quality on metrics like security. Even if I'm writing a game—I'm auDHD, so if the initial code is garbage (and I've written a lot of garbage code) I'd be loath to touch it later. Better factored code is easier for me to revisit and improve upon with time. So I make it a point to continuously improve how I structure code from the jump to stave off it turning into an unpleasant quagmire later. This is especially important when you consider that oftentimes in business, the first draft that could possibly work goes right into production. Rewrite? What do you mean, rewrite?

Fabrice is still fucking brill though. He'll slap something together that's a holy shit idea as easily as I take a dump.

[psychoslave]

> I think developers sometimes get too obsessed with code quality thinking that smarter code makes them a better developer.

Not much about "smartness", but code can by far outlast many "product" sold on top of it, so it can make sense to polish them more than the ready to throw gift paper.

People will certainly buy nice gift paper wrapping cheap crap music toy of the day. But they will also value differently access to a beautiful handcrafted musical instrument. On the other hands, people who don’t even play any music won’t be able to assess any musical appliance.