Too

There’s a famous presentation by David Beazley where he implements a WASM interpreter in Python in under an hour. Highly recommended.

Kubernetes?

Yes, it has a higher learning-curve than incrementally extending your constantly growing deploy.sh-script and there are many moments when it's complex and overkill. When you really need it though, no amount of in-house sysadmin-scripts will cover the same functionality with the same quality. The discussions about it online tend to have a very vocal majority of people from the first bucket, not yet realizing that they are slowly growing into the second.

All that said, it's by no means perfect and some critique is well-deserved, just that a lot of the hate comes from armchair-experts who compare it to running things locally on your laptop.

Very similar in fact to systemd, seen in isolation from an application-developer, it's one more thing to learn getting in your way. Seen from the complete system-administrators point of view, it's a consistent way to manage and secure your fleet.

> I doubt a lot of new code needs to be written

I bet someone could have easily said the same thing a year ago or even 5 years ago. It's easy to forget the progress and there are a lot of things happening under the hood that are not obvious to casual users. Just take a look at the git log of the git repository itself. It has a steady rate of close to 100 commits per week for the past year.

That says nothing of potential new features either. There is so much more to unlock in the VCS space, look at new tools like jj for example. Additionally, security landscape is getting more aggressive every day, keeping up with and being proactive against vulnerabilities will be needed more than today.

That's more or less what you get when enabling MFA with Authenticator on your iPhone.

Banking used to have dedicated dongles with displays before but now also changed to apps. Yubikeys don't seem to be as popular as they deserve. People simply want to carry less things around that can be lost and it's hard to beat the security/convenience ratio of Face ID.

This is cool and useful for teams with huge states and slow locks. Terraform, while great, still has lots of room for improvement.

I keep wondering though if split state files isn’t a good thing in some sense anyway. It isolates a lot of problems. Access, obviously. Another common theme is that applying tends to be a game of roulette, even if you haven’t changed anything. Cloud vendor added or renamed something in their backed. Provider update made some field deprecated. Expected state drift that wasn’t properly marked as ”ignore_changes”. Unexpected state drift by your over-excited intern. When I as an app-developer apply a simple config file change, I really don’t want to be bothered about dirty state in the networking backbone that I understand nothing about.

It’s also not entirely clear how the solution keeps track of the desired state if multiple actors are changing it at the same time. Wouldn’t one successful apply make the next person, who don’t have your local changes, revert it back on first apply? Does this expect heavy use of resource targeting?

Maintainers should understand that saying no and closing an issue is polite. Much better than ignoring, stalling conversations, demanding yak-shaving, bike-shedding or pretending that a feature request could be added if only someone else contributes it, then never accepting the PR once it arrives.

This could have been a good example, except curl is not only a CLI, it builds on top of libcurl, one of the most popular libraries for doing HTTP in C. If building a web browser, it’s one of the first candidates for a fetch engine I would reach for.

One can be gifted while still producing code that the rest of the team can read.

Shifting more of this to the compiler is logical, because import rules are defined by the language, not by the build system. In fact, today build systems function by asking the compiler to output a list of transitive includes, so it knows which files to rebuild when someone touches a header.

The readme does a really bad job of explaining this. They are also using the wrong metrics. What’s really interesting is time to incrementally recompile after changing one header file in $LARGE_PROJECT. Single file compilation sounds like an artificial measurement and isn’t exactly painful with normal clang today. Full build measurements are rather irrelevant in a project with proper incremental setup, or even ccache. Not that I would say no to faster full builds :)

The article misses that http status code is not a custom mapping, it’s a standard mapping. Using this standard, most http libraries will already be equipped with features to handle them, for example automated retries and backoffs on a 429 with Retry-After.

Replacing this standard with custom strings in the response body is terrible advice. Even if we all could have wished that http status codes should have been human readable strings rather than numbers. Augmenting the standard response with additional custom information is still something you can and should do as cherry on the top, or if you have many conditions falling under the same standard code. Like, don’t shoehorn something custom into 418 I’m a teapot just because it happened to be unused.

This. Both Typescript and Python type systems are way far ahead, with structural typing, exhaustive checks and much more.

Skipping defer ignores panics, with problems explained in the tfa.

But with SSO you can offload all the 2FA handling to the IdP.

Why isn’t Hetzner providing a managed control plane themselves? Seems like a small investment to make for the return of converting massive amounts of customers stuck on GKE/EKS/AKS. That, plus a good IAM story, and they will be seen as a full cloud solution, not just a basement of servers. They have the infrastructure, it just need to be packaged.

With an ORM your application code is your views.

You can write reusable plain functions as abstractions, returning QuerySets that allow further filters being chained onto the query, before the actual SQL is materialized and sent to the database.

The result of this doesn’t have to match the original object models you defined, it’s still possible to be flexible with group bys resulting in dictionaries.

What? Why would you want to expose a beginner to waiting 10 minutes unnecessarily. How would they even know what they did wrong or what's a reasonable time to wait, ask chatgpt "why is my git clone taking 10 minutes"?!

Is this really the best we can do in terms of user experience? No. git need to step up.

Not surprising at all. The configuration and docs for Oauth2 on Entra is an absolute cluster-f. Evidently, it’s so confusing that not even Microsoft themselves can get it right.

Their solution to this will be to add even more documentation, as if anyone had the stomach to read through the spaghetti that exist today.

Let’s say that hypothetically one were to disagree with this. What would be the best alternative format? One that has ample of tooling for editing and diffing, as though it was text, yet stores things more efficiently.

Most of the arguments presented in TFA are about openness, which can still be achieved with standard binary formats and a schema. Hence the problem left to solve is accessibility.

I’m thinking something like parquet, protobuf or sqllite. Despite their popularities, still aren’t trivial for anyone to edit.

Wow. If this is not laying the foundation for a supply chain attack I don’t know what this is.

Who maintains the VPN?

What does +75 arbitrary points mean in practice? Can we come up with units that relate to something in the real world.

What's a reasonable scenario where average citizen need to haul 10, let alone 20 tons, on such regular basis that they need to own that capability themselves? Just rent or hire help. I would imagine that to also require special driving license, even if the car technically can handle it? We are not talking about professional use here, for that, use as big of a truck as you want.

Ugh no. It was good enough for its time, but times have moved on.

The danger is that it's so easy to start and it's decent for small and simple applications. Once your jobs start growing, both in number of contributors and in workload, the problems start. DSL is difficult to debug, plugins are buggy and the brittle master node will become your most precious pet that need constant supervising to not grind the whole system to a stop. By the time you realize this you have a hard time to get out of this lockin.

Identifying such almost-duplicate code is an open opportunity for LLMs.

In other threads, the voice of HN tells us to consider equity in a startup as worthless and only ever count on base salary.

Here we instead hear that equity is as important as the air we breathe.

Yes, 200k is not life changing but at least it’s not pretending to be, like many other inflated equity schemes that never vest. It’s just an honest decent salary, better than what you can find in many places of the world.

Business opportunity: Invent a type system that prevents N+1 queries.

> 50 teams

At that scale any tool will break down without good architecture, ORM or not.

Writing is just half the job. Now try migrations, or even something as fundamental as ”find references” on a column name. No, grep is not sufficient, most tables have fields called ”id” or ”name”.

Because users don’t want to install apps that have access to gps in the background.