> In May 2026, Anthropic averaged around 2,500 code changes merged per day; as of September, we merged over 30,000 per day.
> The history of our main branch alone is almost 100 GB
What value do you get from carrying around all of that history? Your code is changing so rapidly that it looks absolutely nothing like it did a year ago, so at what point are you going to want to see what it looked like back then and every single change that happened to it since? Wouldn't you benefit more from creating a tool that can semantically truncate history entries that are no longer relevant, since even with scn your history will continue to grow out of control?
Legal argument is already a strong one, but I feel that the training data in there must be invaluable. Such a mass of shipped features, regressions, refactors, complete rewrites and pivots, all with full internal history, is a goldmine. Whether archiving and switching branch might be in order, that's a fair discussion though.
I think your lawyers might have a word with you, too. Source code history is more than just a record for developers. It's also a historic record that can become relevant in legal disputes.
While true, if the 100GB of history that isn't important anymore is dragging you down, create a new repo with today's code and move from there, then archive the old history for e.g. legal reasons.
Maybe you love being the consumer of RSS feeds, but you certainly wouldn't love being the poor bastard who has to parse them.
Even though it's a simple standard that's been around for decades, there are still many sites which serve their feeds with a subtly wrong format. When something doesn't work, users come knocking on your door saying "it works in X reader but not in yours", so now you have to handle that and contribute to the ever growing list of out of spec edge cases that feed readers need to account for.
People like to hate on PHP, but PHP provides you with all the tools you need to write a fully working backend, where as JS provides you with half-assed solutions for writing frontend, which is why we have 1000 frameworks and we still can't agree on how to write frontend code. Seriously, we don't even have a convention for writing a simple reusable component with vanilla JS, everyone makes up their own thing. Web components were supposed to be that, but they're a good example of what I meant by "half-assed", because they're ugly, verbose, clunky, don't really solve the right problems, and nobody likes writing them.
I don't think PHP is any better in solving the backend, than JS is in solving frontend. On the Frontend the situation is not ideal, but we made big leaps every let's say 5 years, going from jQuery to React and from React to later generation frameworks like svelte / solid etc. Yes, the landscape is fragmented and there are maybe too many options, but you make it sound like PHP is universally used as the backend solution, while I see it being used little these days except for legacy systems from 15-20 years ago.
> you make it sound like PHP is universally used as the backend solution, while I see it being used little these days except for legacy systems from 15-20 years ago.
I never said that PHP was universally used, just that it has answers to most problems.
jQuery has become obsolete these days because the problems it solves have largely been solved by additions to JS, but the interactivity of websites has continued to increase and browsers have yet to catch up to that. Frameworks like React actively fight against the browser rather than work with it by maintaining its own DOM state and constantly creating copies of state for every re-render of a component, along with a bunch of other magic. That's a lot of unnecessary loopholes just to make up for JS's lack of features when it comes to writing reactive UI.
Because it's been trendy to introduce a new unintuitive syntax with every new CSS feature.
I am genuinely afraid for the future of CSS as it is becoming increasingly more complex, meanwhile most people haven't been able to properly utilize or understand it for the last decade even without all of that additional complexity.
Remember when we used to be called "web developers"? We then became "software engineers", but forgot the meaning of the word engineer:
> Engineering is the practice of using natural science, mathematics, and the engineering design process to solve technical problems, increase efficiency and productivity, and improve systems.
We don't increase efficiency or improve systems, we just build garbage on top of garbage. Imagine if a structural engineer did the same and built new floors on top of shaky floors. Our buildings would be collapsing on a daily basis.
I get the potential appeal in having a single language do all things, but in practice the front-end and back-end have vastly different jobs and different capabilities, so I see no issue in them being different languages and letting them utilize their strengths. Not to mention the vast amount of complexity you need to involve at some point in order to bring a language to a side it wasn't meant to be in.
I'd love to, but I don't really have a choice at the moment.
Maybe I'm just at the wrong place at the wrong time, but as a software engineer I don't feel like I'm doing any actual engineering and solving meaningful problems, just spaghetti gluing random frameworks, packages and services together. The only problems I get to solve are those caused by the quirks of all these incompatible things being forced to work together. It's draining.
This is the job most of the time, especially at large corporations. You’re mostly fixing legacy decisions and trying to patch together solutions to current problems (instead of fixing tomorrow’s problems). Hang in there.
"Hang in there" implies that the situation is going to improve. It won't. You end up ratcheting your title and pay upwards until you find yourself in the position of doing nothing useful all day for an amount of money that precludes switching to another career without a drastic pay cut. And you're probably hitting your mid-life crisis zenith right around this time too.
"Boo hoo" I know, but it is its own little Dante's Inferno.
> People have a right to build substitutes and replacements -- I believe in the "Let a hundred flowers bloom" philosopy.
It's a blessing and a curse. Look at package managers, they more or less all do the same thing, with one primary job of "go download some binary so I can run it", yet there's so many to choose from. Every time you read some Linux guide they have to list 7 different ways of installing the same package. It's stupid, probably even more so for the maintainers of those packages because they have to distribute their package 7 different ways. At least I'm glad systemd has mostly become the standard, so you don't have to also see 7 different ways of creating a service.
Usually, it's the distributions problem to package software. You as a software developer publish documentation on how to build your application and then simply wait for other people to do the packaging for you. The creation of services is the same, you can maybe create a recommendation, but the service definition is part of the package file and thus not your problem.
In practice, though, the packagers quite liked systemd, because it a) makes service definition easier than any other system, and b) it significantly increases the likelihood that the developer has already written a suitable service file (and developers will like that that is used, because it reduces the chance that a packager makes a mistake and increases their support burden).
And as an end user of multiple distros, I really appreciate it because I also have to make services on occasion and it's nice that there's one way to do it and it's pretty easy to do correctly.
Usually, this is not good enough. I as a software developer often make use of the package manager built into the language of choice and use that to distribute my software. I also commonly make use of package managers of languages that I don't use to install software.
We are overdue to package manager interop and common interfaces.
> `ctx.Value` is an `any -> any` kv store that does not come with any documentation, type checking for which key and value should be available.
On a similar note, this is also why I highly dislike struct tags. They're string magic that should be used sparingly, yet we've integrated them into data parsing, validation, type definitions and who knows what else just to avoid a bit of verbosity.
Most popular languages support annotations of one type or another, they let you do all that in a type safe way. It's Go that's decided to be different for difference sake, and produced a complete mess.
IMO Go is full of stuff like this where they do something different than most similar languages for questionable gains. `iota` instead of enums, implicit interfaces, full strings in imports (not talking about URLS here but them having string literal syntax), capitalization as visibility control come to mind immediately, and I'm sure there are others I'm forgetting. Not all of these are actively harmful, but for a language that touts "simplicity" as one of its core values, I've always found it odd how many different wheels Go felt the need to reinvent without any obvious benefit over the existing ones.
the second i tried writing go to solve a non-trivial problem the whole language collapsed in on itself. footguns upon footguns hand-waved away with "it's the go way!". i just don't understand. the "the go way" feels more like a mantra that discourages critical thinking about programming language design.
This is one of the best thing I read; I thought I was pretty good at Flexbox (and its tailwindcss building blocks), but this scratched my itch on some theoretical foundations.
> The history of our main branch alone is almost 100 GB
What value do you get from carrying around all of that history? Your code is changing so rapidly that it looks absolutely nothing like it did a year ago, so at what point are you going to want to see what it looked like back then and every single change that happened to it since? Wouldn't you benefit more from creating a tool that can semantically truncate history entries that are no longer relevant, since even with scn your history will continue to grow out of control?