Item — HN Reader

When you make a function

  f(a, b, c)

It is reusable only if simply changing a, b, c is enough to give the function that you want. Options object etc _parameterise_ that function. It is useful only if the variability in reuse you desire is spanned by the parameters. This is syntactic reuse.

With LLMs, the parameterisation goes into semantic space. This makes code more reusable.

A model trained on all of GitHub can reuse all that code regardless of whether they are syntactically reusable or not. This is semantic reuse, which is naturally much broader.

1 comments

There are two important failures I see with this logic:

First, I am not arguing for reusability. Reusability is one of the most common mistakes you can make as a software engineer because you are over-generalizing what you need before you need it. Code should be written for your specific use case, and only generalized as problems appear. But if you can recognize that your specific use case fits a known problem, then you can find the best way to solve that problem, faster.

Second, when you're using an LLM to make your code more 'reusable' you are taking full responsibility for everything that LLM vomits out. You're no longer assembling a car from well known parts, taking care to tailor it to your use case as needed. You're now building everything in said car, from the tires to the engine and the rearview mirror.

Coding is a constant balance between understanding what you're solving for and what can solve it. Using LLMs takes the worst of both worlds, by offloading both your understanding of the problem and your understanding of the solution.

> Second, when you're using an LLM to make your code more 'reusable' you are taking full responsibility for everything that LLM vomits out. You're no longer assembling a car from well known parts, taking care to tailor it to your use case as needed. You're now building everything in said car, from the tires to the engine and the rearview mirror.

If you are anything above a mid level ticket taker, your responsibility exceeds what you personally write. When I was an “architect” responsible for the implementation and integration work of multiple teams at product companies - mostly startups - and now a tech lead in consulting, I’m responsible for knowing how a lot of code works that I further write and I’m the person called to carpet by the director/CTO then and the customer now.

I was responsible for what the more junior developers “vomit out”, the outside consulting company doing the Salesforce integration or god forbid for a little while the contractors in India. I no more cars about whether the LLM decided to use a for loop or while loop than I cared about the OSQL (not a typo) that the Salesforce consultants used. I care about does the resulting implementation meet the functional and non functional requirements.

On my latest two projects, I understand the customer from talking to sales before I started, I understand the business requirements from multiple calls with the customer, I understand the architecture because I designed it myself from the diagrams and 8 years of working with and (in a former life at AWS) and reviewing it with the customer.

As far as reusability? I’ve used the same base internal management web app across multiple clients.

I built it (with AI) for one client. Extracted the reusable parts and removed the client specific parts and deployed a demo internally (with AI) and modified it and added features (with AI) for another client. I haven’t done web development since 2002 seriously except a little copy paste work. I didn’t look at a line of code. I used AWS Cognito for authentication. I verified the database user permissions.

Absolutely no one in the value chain cares if the project was handcrafted or written by AI - as long as it was done on time, on budget and meets requirements.

Before the gatekeeping starts, I’ve been working for 30 years across 10 jobs and before that I was a hobbyist for a decade who started programming in 65C02 assembly in 1986.

I am not talking about using an LLM to make code reusable in the sense youre arguing.

My point is that the very act of training an LLM on any corpus of code, automatically makes all of that code reusable, in a much broader semantic way rather than through syntax. Because the LLM uses a compressed representation of all that code to generate the function you ask it to. It is like having an npm where it already has compressed the code specific to your situation (like you were saying) that you want to write.