Comment by lelanthran | Hacker News Reader

Comment by lelanthran | Hacker News Reader

Parent Full thread

> I think the biggest differentiator is simply that there are people for whom the act of typing the code into the editor was the part they enjoyed, and LLMs have basically killed that, by making it woefully inefficient by comparison.

This is a very uncharitable take; I see it mostly from devs who are all-in on AI (not saying you are one), not from devs who just use AI while programming. Basically, I see it from devs who want to never touch a keyboard again.

Maybe they never liked programming in the first place, but liked managing instead, so now they can manage instead of programming.

Maybe they never liked programming, but they did like delivering; now they can work as a product manager, delivering only.

Whatever the reason, they never really liked programming[1]. My experience in programming, since the mid-90s, is that my design is refined as I type out the programs. I gain insight into the problem as I create the program. My thoughts are refined as I read what I type (and not just with programs, with prose as well).

Possibly the all-in devs never read what they typed anyway, so the act of programming never caused them to refine their ideas. Maybe they never read what they typed as they typed it in. Maybe they did, but it never triggered introspection.

Whatever the case is, it's a very uncharitable take to trivialise those engaging in more thought, due to actually writing, as simply enjoying the act of typing.

They are not. They are enjoying the iterative process of deep thinking.

TBH, maybe this is why so many of the all-in AI vibers are trying to trivialise the typing part - if they can convince themselves that typing is so trivial and bereft of thought, then they don't have to admit to themselves that they are thinking less, and the thinking they do do, is not as deep.

----------------------------------

[1] All advances in programming, such as in data structures, algorithms, languages, theory, etc came mostly from people who liked programming. As these people can not hone their skills by working at it for money in the future, who knows if we ever get any more advances.

I definitely agree with you about this for certain problems but I think for a large number of people, they are just using an ORM to bind to a form to later save back with some validation. There is not much deep thinking they need to do other than which columns to index.

> I definitely agree with you about this for certain problems but I think for a large number of people, they are just using an ORM to bind to a form to later save back with some validation. There is not much deep thinking they need to do other than which columns to index.

I dunno; unless it's an extremely trivial case (single table, no joins), they are still thinking about this: does this new form make sense as a standalone form? Does the functionality overlap with a current form (and if so, should we rather refactor the workflow than add a new step), etc.

There's also nitty-gritty stuff: should I make this a common function callable by other form-generating code, or keep it as a single-caller function?

More often, when writing code you often get a good sense of what is currently broken in the design. In greenfield, you can just go ahead and modify the design. In brownfield you are going to try to minimise the modifications in design as much as possible. This is still thought.

Fair points, good boundaries and abstractions will always offer easier, more stable extensibility.

>Whatever the reason, they never really liked programming

I agree with this, at least. Because for me the act of typing the code into the editor was never the enjoyable part. It was always just the thing you had to do before you could enjoy the creation. I wanted to build a website, not type HTML into an editor. I wanted to mod Ultima Online, not type C# into an editor. I wanted to make a PWA, not type ruby into an editor. I wanted to interface some bespoke hardware with GPIO pins, not type python into an editor. I wanted to build an ETL pipeline to make better operational decisions at work, not type code into a fucking editor.

I’m an engineer, not a typist. I get paid for my judgment and for adding value, not lines of code typed.

Actually typing the code was always just a means to an end. Can you honestly say different?

>My experience in programming, since the mid-90s, is that my design is refined as I type out the programs. I gain insight into the problem as I create the program.

> [...]

>Whatever the case is, it's a very uncharitable take to trivialise those engaging in more thought, due to actually writing, as simply enjoying the act of typing.

I don't understand the vitriol here. Are you saying you just sit down and start writing the code, without planning or designing the application you're writing beforehand? Surely not.

Nowadays before any code gets written, by me or by an agent, there ends up being several rounds of back-and-forth on the overall architecture and design of whatever is under consideration. I put thought into data structures, ownership and lifetimes, design patterns, overall project context, etc.

That is, IMHO, the hard part of software engineering. If you're a professional, that's the part that pays the bills. Once that part is done, is there any actual value to implementing a ring buffer by hand vs having the model do it? Is there materially more thought? I argue there is not.

I write the code that the models don't write well. I let the models write the code they're good at writing because I've got a thousand better uses for my time than implementing a ring buffer, or an API endpoint handler, or whatever, by hand.

>All advances in programming, such as in data structures, algorithms, languages, theory, etc came mostly from people who liked programming.

Pretty sure most of these advancements came from people who were computer scientists first and foremost. They programmed by hand because no other method existed at the time. But there's a famous quote about computer science having very little to do with writing code.

edit: lol HN's bone-headed rate limits strike again. Oh well, conversation ends here I guess. By the time the rate limit has elapsed this conversation will be ancient history.

> That is, IMHO, the hard part of software engineering. That's the part that pays the bills. Once that part is done, is there any actual value to implementing a ring buffer by hand vs having the model do it? Is there materially more thought? I argue there is not.

Nope. The hard part of software engineering is recognizing all the subtle ways in which no existing abstraction ever perfectly fits your non-trivial problem and its subproblems.

This work is never "done". I do find it amusing how every time your line of reasoning comes up, the examples are always textbook trivial problems and solutions. It's even sometimes an insistence that LLMs are "compilers" for this kind of thinking.

It's the stuff of middle manager fantasy that things are "just so" and that implementation work has less depth instead of far more. If implementation is so trivial, the world is only inching closer to demanding an explanation from your lot why you think most implementations are so bad.

To address the parent of all these replies, I agree it's a difference of personality. The "hands off" people are going extinct, and they're terrified. The future has always been about getting our hands even dirtier.

>> My experience in programming, since the mid-90s, is that my design is refined as I type out the programs. I gain insight into the problem as I create the program.

>> [...]

>> Whatever the case is, it's a very uncharitable take to trivialise those engaging in more thought, due to actually writing, as simply enjoying the act of typing.

> I don't understand the vitriol here. Are you saying you just sit down and start writing the code, without planning or designing the application you're writing beforehand?

I gotta ask?: why do you think "my design is refined" means that I start without a design? The wording is fairly clear: for a design to be refined, it means it has to exist.

(I'm also not sure that vitriol is the correct word to use here; it seems, again, like needless disparagement).

> Once that part is done, is there any actual value to implementing a ring buffer by hand vs having the model do it?

Do you have an example that isn't "I use a library to do this when writing code"? This strawman comes up again and again in these types of discussion: no, I don't write a ringbuffer, I use an existing library.

You are also glossing over which group I am describing, specifically, those who are all-in on AI development and do not read nor write code.

Reply on news.ycombinator.com