speakers are up at https://t.co/Eri7HqKKdz
we are still looking for sponsors: we have multiple speakers coming from abroad this year and flying isn't cheap!
plz trick your boss into giving us money by saying our conference is very important 🥹
vibependencies
go through your dependencies, figure out which ones are deep and which are shallow
tear out the shallow ones w/just the code you need, potential big savings on transitive deps, often removes layers of unneeded abstraction for your use case, etc
it's a thing
This allegation of unauthorized access or “hacking” is factually unsupported. The actions in question were undertaken with the explicit knowledge, authorization, and consent of the relevant party. Evidence of such authorization is documented in the referenced video recording.
for anyone interested in the TRUTH, the full Pull Request and video has been posted publicly and without any admission of guilt or fault
https://t.co/4YB3r33B0Q
@htmleverything The only practical thing I have found that helps:
Time. Building up robustness with each fix creates a more solid base. Eventually you can mostly rely on your processes to alert you, and trust that if they are t alerting you it’s actually fine. Becomes more true over the years
Every time I see a team celebrating their new "shared module," I remember this lesson.
Reuse is a dangerous form of coupling.
They found the same logic in two places and did what good engineers do: put it in one place and called it a win. Clean, responsible, textbook.
Six months later, someone needs to change it.
Suddenly, a small update for one team's requirements breaks three services, blocks two releases, and triggers an emergency meeting between people who've never talked to each other before.
This is the cost nobody preaches about.
DRY is one of those principles that feels unquestionably right until you apply it across team boundaries. The moment you share a module between domains, you're not just sharing code. You're creating a dependency that nobody owns and everyone resents.
Before you reuse, ask:
Will this change often?
Does it belong to one domain?
Are the consumers truly aligned in purpose?
Will one team’s change surprise another team?
If the answer to any of these is "I'm not sure," stop. Duplicate it.
I know how that sounds. It feels lazy. It feels like the thing a junior developer does before they know better. But here's what nobody wants to say out loud: two independent implementations you control are almost always cheaper than one shared one serving masters with different goals.
Duplication is a local problem. Coupling is an organizational problem.
One of them you can fix in an afternoon. The other requires a meeting with five teams and someone's manager.
Reuse isn't free. Treat it like the trade-off it is.
For 50 years, software engineering ran on code rationing. Writing code was expensive, so we rationed it carefully through roadmaps, RFCs, prioritization meetings, and scope reviews.
This created a role: the No Engineer. No, that won't scale. No, we don't have bandwidth. No, that's out of scope. No, we need a design doc first. The No Engineer was valuable for 50 years. Every "no" saved real money. Their judgment was the rationing system.
LLMs will be the end of code rationing. Code is cheap now. And while the No Engineer is explaining why something can't be done, the Yes Engineer has already shipped three versions of it.
If you're a Yes Engineer, the next decade is yours.