ZH version is available. Content is displayed in original English for accuracy.
Advertisement
Advertisement
⚡ Community Insights
Discussion Sentiment
53% Positive
Analyzed from 2458 words in the discussion.
Trending Topics
#code#lines#engineers#more#product#software#engineer#nobody#complex#ctos
Discussion (54 Comments)Read Original on HackerNews
oh wow, what a trustworthy source of information this human written article is.
Don't want to be called? Don't make incidents. Healthy orgs, as a peer comment points out, avoid too much separation between the positions. Things like change review are supposed to avoid this, but often gets rubber-stamped for 'velocity' (into a wall).
Migrating Spring Boot apps from 3.x t 4.x is now easy given all the tooling available.
But the administrative load can't be reduced by faster code delivery and that's the new bottleneck.
Nobody wants to communicate because it is pointless to communicate: what you say will be misunderstood, it will be repeated incorrectly and attributed to you, people will play games with your messaging and with you for trying to communicate.
The management bully game activates, and they all participate in keeping the engineer down.
This is normal at every engineering organization, it is lord of the flies.
And this is how we educate people, This situation is created. All because we refuse to recognize that learning how to debate controversy and learning how to manage disagreement is completely unrecognized as a valued skill.
So we avoid controversy and any disagreement is an opportunity to bully and force one's way. Which is completely avoidable, with basic effective communications training. Debate to understand, disagree to learn.
Now they're just trying to reduce us to idiots shovelling coal (specs) into the furnace (LLMs)
There are some smaller businesses and selectively structured ones where that's not the case but for the most part organizations keep engineers from interacting with the customers enough to really know what the customers need and want.
There are some cases where a savvy engineer can say "well if I unify X then it'll be trivial to make Y self service and that'll make redundant an entire category of support tickets" or "we've been getting a lot of requests for X, maybe Y should be extensible so that those can be trivially accommodated" but by and large engineering teams are not positioned to have the knowledge to identify these things. And this is mostly an intentional organizational architecture decision.
If an LLM is trained on GPL code then that code has become an intrinsic part of the model (because if it hasn't then what was the value of training on it). So shouldn't that model now also be licensed GPL?
And how do I know the LLM output is not reproducing substantial chunks of GPL'd code, making my code GPL?
Law is probably going to take a while to catch up here.
> Language doesn’t matter anymore: Python, Go, Rust, Node. But system design hasn’t changed.
I keep seeing this claim, and it's incoherent. Programming languages are the languages we use to express system design, and just like Sapir–Whorf in natural languages they admit, emphasize, or force consideration of different concerns in the design process. If we did get to the point where those languages ‘don't matter any more’ it would just be because modern tooling allows us to express ourselves at a higher level than these languages were designed for — but then whatever higher-level language you're using to express yourself matters instead (and matters more than ever: the higher-level you go the more inaccuracies compound).
Programming languages are designed for humans, not for computers.
It being expensive to ship or maintain software still sounds like technical debt, no?
For cognitive debt, I'd expect something like context switching and reviewing large amounts of code being exhausting.
I think the part you can't easily clone will turn out to be the institutional processes that allow you to run at scale, onboard new people, deal with common requests that AI cannot on its own (e.g. legal compliance), the relationships you have with partners and vendors, the legal setups you have in place etc.
I'd assume that plenty of developers feel capable to building a better jira, and some try, and few/none succeed despite atlassian doing everything in their power to drive clients away, because cloning the project isn't the hard part with that type of product.
Classic Software Engineering stages of Specification and Verification (both Formal and Informal) take center stage with the software unit being treated as a blackbox. Developers are now "Systems Engineers" responsible for end-to-end systems delivery.
See also my previous comment here - https://news.ycombinator.com/item?id=48431591
The best case for engineering is always: nothing went horribly wrong in public.
Implicitly they've woken up to the value proposition which was latent in their tech hires: detailed knowledge of their code and systems. They've just tossed that away, and even worse they've smooged it into unfathomable information systems which probably share aspects of it with their competitors.
AI destroyed their value.
A candidate who can identify tradeoffs present in some code and make insightful comments is likely good at systems thinking. It's a highly effective way to test someone's knowledge, intelligence and taste.
It's actually brilliant because it provides the company with a way to actually improve their engineering posture since the company could land on a candidate who is more skilled than the engineers doing the interviewing. Many times in my career, I met engineers who seemed mediocre at first because they didn't know a fraction of what I knew, but I later found out they also knew a fair amount that I didn't know.
I've even had an extreme experience in the past year where a colleague seemed to struggle with basic code constructs and for the first month I was thinking to myself "this guy doesn't know how to code". He asked really basic questions and said he didn't know because his background was Python and not Typescript... But I know both of these languages and I just couldn't make sense of this explanation given the kinds of questions he asked and mistakes he made. If I had been asked to review him at the time, I would probably have given him a pretty bad review but after about 1 month and a half, this guy accelerated and literally became the most productive engineer on the team. No leetcode coding test could have predicted this.
Most leetcode tech interviews are a series of puzzles which most company insiders can solve but they never include problems that the candidate could solve but which the interviewer could not.
Leetcode interviews are horrible because they test a tiny subset of moderately difficult questions under time constraints and ignore a much larger set of problems that are much more complex. There is an incorrect assumption that someone who can solve extremely complex problems can also solve moderately complex problems under time constraints. This is absolutely not the case. It's almost mutually exclusive in fact since people who work on complex problems don't have the time or interest to practice solving simpler problems so they can never solve those fast enough to compete with fresh university grads who have been practicing those for years and don't know anything else.
On a different topic, I was sceptical of this comment:
"I honestly think you can have a fifteen thousand line PR and say, I need a human to review these three lines."
15k lines is a lot of code. I could destroy any software project, irreparably with 15k lines of code and not one engineer out of hundreds would recognize it unless they read carefully. You can absolutely destroy a codebase with 15k lines of code, without any obvious backdoors or malicious code. How would I do it? I would invent counter-productive abstractions and write a lot of unit tests for them to lock down the design... Then I would watch other engineers build on top to further lock it down... Let the flawed design accumulate debt for a few years until the entire codebase becomes slow, insecure and totally unmaintable. Nobody would ever remember that I'm the one who set the project on a bad course. Nobody ever suspects the person who invents the complex abstractions and who everyone comes to with questions... Also most engineers are afraid to ask why we need a SocketContextManager or a TaskContextSwitcherMediator or the TaskOrchestrator and TaskOrchestratorFactory that comes with it... Nobody will ask why we need 10 different Helm charts to split things up into microservices... Nobody will ask why we need 1000 top level dependencies with a total of 10k nested dependencies. Nobody will question those decisions because they're afraid they will look dumb for questioning complexity.
You cannot question system complexity without acknowledging that you find something to be complex... And this can be turned against you; "Oh so this is too complex for you?"
So my view is that every single one of these 15k lines needs thorough analysis. Each of those 15k lines represent the branches from which the next generation of twigs will sprout. If that branch isn't pointing in the right direction, better just cut it off as soon as possible before it becomes a central part of the codebase.
There could still be a lot subtly wrong, but there are going to be stress points and high leverage validation methods you can use to avoid reading the whole 15k.
But in most situations when I see a PR over a few thousand lines to an existing codebase that's highly depended upon, my stress levels tend to spike. On particularly complex projects and critical component, I'd read every single line.
Some modules I worked on, I would barely trust myself adding 100 lines to it because of how many other developers' code is depending on it. Sometimes they may be using it in ways which were not officially supported but I don't want to break backwards compatibility anyway.
So on such module, I would panic if I saw even a 1k line commit from somebody else.
15k lines is a lot. Each line comes with a probability that it introduces a bug. For a junior dev, the probability may be that 1% of lines introduce a bug... For a senior, it might be 0.1% per line and for the world's best coder, it might be 0.01%... But with 15k lines. It's highly probable that the code contains at least one bug no matter who or what wrote the code.
2 years is an era now?