So you’re telling me to use a tool controlled by a foreign state to generate code, execute it on my machines, and ship it to customers with zero review?

I am doing a project about elderly programmers If you are a C programmer please DM

Next question: why are you still using branches? We talked about PRs. I don't think they make sense anymore, if you rethink them from first principles. Yes, if you only use them to trigger CI, then sure, go ahead. That's a fat commit, not a PR. But for mandatory code review? Knowledge sharing? C'mon. But some of you said: "we use PRs because we use branches! I love to keep my stuff on branches." And I'm here to tell you: you don't need branches! You can just push to main. It's called trunk-based development and the idea behind it is true continuous integration: you continuously integrate your changes with the trunk, the main branch. It's been around for a while, it works. Just yesterday I talked with someone who said they've used it in an org with 400 engineers, without any issues. Ruby, the project, uses trunk-based development. The main idea is that you want to avoid long-lived branches. They're bad, because branches can diverge and merging can turn into a thing. And you don't want routine operations to become a thing. Even when I worked in teams that used PRs and branches, I considered it a smell when a branch lived for longer than a day or two. But when I shared this with others, I'd often get something back like this: "Well, good for you, but no. MY thing, what I'm working on, that can't be done on main. It needs to be on a branch! It has a database migration, it changes the underlying shape, the architecture, it refactors this and changes that. It can't go on main yet! I need to merge it all at the end." And then I'd say: "Nah, I can merge nearly anything continuously in small commits to main. You split things up. Add the column first, merge that, deploy it, now it's out, works, safe. Add the helpers first, merge them, get them out. Want to migrate from legacy pattern A to new pattern B? Don't do it all at once. Add the dependency, then migrate A to B, one by one, safe." If it can be merged in a large change, I bet it can be done in small increments that you merge to main. Yes, there are exceptions, but it's 0.5% of cases, not 50%. But there was a real problem with this approach: it was hard! There's a lot of "meta programming" you have to do: make sure this small first change compiles and runs and the tests work, merge it, get it out, monitor it; then do the next small piece, make sure that works and get it out; then maybe push some still-unused dead code, add a feature flag, add a config variable; or keep both configurations working at the same time, etc. That meant sometimes it was just easier to do it in a big fat branch. But big fat branches are risky! A system that continuously flows is safer than a system that starts and stops in spurts. But -- you guessed it -- here's the good news: Now, with agents, all of these chores are no chores at all! Agents are great at adding feature flags, they're great at splitting up code, they're great at keeping track of three changes and merging them one by one and watching them roll out. They're great at keeping two configurations working for a day. They're great at migrating one by one. In other words: it's now 10x easier to just work on main and make sure everything is continuously integrated and working. It's now easy to make sure the system constantly flows. And look, ... I'm not here to convince you to switch to trunk-based development. Just a ruse to get you to read this. (But also, hey: try it! Pushing to main is amazing.) I'm here to make you RETHINK how you develop software. Don't just use agents to replace your typing. Use agents as the magic code-writing machines they are. Everything that was hard about software development because it involved writing code -- even the meta programming -- has become easier. You can now reach for the stars! But you need to look up.

'No Way to Prevent This,' Says Only Programming Language Where This Regularly Happens

C++ can’t be fixed

F

5…

We're starting to see some agentic Rust forks (or alternative implementations) focused on iteration speed. More-so than the specific projects, I'm interested in the ideas being explored (and how they could evolve upstream), so wanted to collate a few here...

Senior dev: “your code will crash if the input file is malformed” Junior: “don’t worry, that’s impossible” Senior:

Junior: the tests didn’t compile after my changes so I passed in the data via global variables instead 😬

Everyone went from hating code they didn’t write to loving code no one wrote

Many teams SUCK at making software, and “patch everything” is so short-sighted. Vulnerabilities are a symptom of a larger problem. We’ve been getting away with a lack of engineering rigor for a long time (decades) in most industries. We’re not making resilient software. We will continue to have issues until most orgs mature how they build, no matter how many times a day you patch. It’s been a financial decision to prioritize shipping fast, over minimizing brittleness. As exploitability gets cheaper, it drives up response and maintenance costs. This may finally incentivize orgs to invest more in software resilience. And we have the tools: each dev team can now spend tokens analyzing their own code and deployment for security and availability issues. Automate testing, automate dependency upgrades, hold design review and threat modeling sessions. Slop is what you make it if you’re not investing in mature architectural decisions. And we’ll keep having trivial vulns until you do so.

Unfair comparison. Vulnerabilities decay exponentially with time. Old code contains fewer bugs than new code. Comparing the Rust code with equally old C code would be more fair.

It’s not AI, it’s skill issues

Working on a codebase full of singletons