necovek

Google has published a lot of open source software and a lot of research papers: I do believe they used to be very charitable even if they are less so today.

They have other issues as well, but among other things, I'd classify them as somewhat charitable too.

Can you say a US company donating to a non-profit and writing off taxes on the basis of it is donating to charity?

Would you say you could be serious in stating this?

And they want you to buildmit using their infrastructure/abstraction layer as a base, potentially vendor-locking people to Cloudflare.

Did they all not get that developers need full control of their tools?

Or they are hoping to turn this into a brave new (old) world where you are at the (bigger) mercy of proprietary vendors?

If your peak monthly cost for AWS services as a business is $100k, do you not think setting a $200k spending limit is reasonable?

Obviously, the system should provide ample time by warning in advance of reaching it (and could even offer suggestion to keep it at N times your peak from M months ago).

If as a business you set your spending limits so tight that you frequently run into them and it's not some unusual activity, the problem is not that spending limits are available :)

It is mostly about protecting from the unknown, likely unbounded attack on your infrastructure, where your spend might grow 100x: even if you can take $100k, you might not be able to take $10M in a month.

If you are actually a business, a common warning that you are near the limit should mostly resolve it. It might only be tricky because the estimated time remaining is really short if it's a huge recent spike: eg. nobody is looking forward to a notice of "you'll use up your spending limit in 4h" on the weekend.

This type of warning should give you enough time to investigate if the warning is real and adjust the spending limits.

But then again, even if you hit them and your services get paused, you'd be increasing the spending limits and restoring services after you are back at work and notice they are down, so it mostly comes down to your incident response times.

Or a German car company?

Yes, because it's their signature that actually has the weight of expertise. Similarly, their ass will be on the line if something goes wrong, not the management's.

Does not fully stop the pressure ("we'll find another licensed engineer to retain"), but at least ensures a somewhat level playing field between expertise and investors.

If you say "stop with the f-bombs" on a flight you might be in trouble only if you are misunderstood.

It's not about the word itself, it is about what it represents and the risk profile if it's true (nowhere to run to).

Maybe it's cultural or geographic, but both "chefs" and "tailors" is similarly male dominated here (Serbia in Europe). Out of all the professions you bring up, architects are actually pretty evenly split here.

Obviously, what matters is where the term was coined, but I'd certainly suspect it has nothing to do with any gender bias and is instead about parallels to civil construction: architects design, engineers make it work and possible for builders to build. If anything, with LLMs, software engineers more closely match up to construction (as engineers rarely lay a single brick).

Yes, start with a decent quality codebase and good test coverage, and LLMs cannnot mess it up for a while.

Keep going and the human engineering time to keep it in line starts growing or it starts turning those tests into a mess of test-nothing monkeypatched blur.

There was also ColdFusion iirc!

> All humans would need to do is communicate clearly what needs to be made and flag problems as they come up.

Sounds like the easiest thing in the world: I wonder why did we not think of it earlier?

I see somebody asking "where is that great software", but I think it's obvious to everyone that there is more (mostly bad) software.

Somebody posted that GitHub status summary: in ten years, they averaged 10 incidents per month — this includes the last 12 months. In the last six months, average is 22.

I've asked Codex with GPT 6 Astra to *review" a one time benchmarking script for any mistakes (built by Claude Code using Opus 5.5) and it refactored the shit out of it claiming all sorts of stuff without even asking about the context in which it was developed.

If I was to employ them to review the code without giving each the same baseline multi-page prompt, they go into endless loop of "improvement" with no end goal in sight.

More and more frequently, I instruct frontier models to stop and go back to the task at hand.

API consumers are similarly tied to the exact API contract — what you need to do to maintain backwards compatibility is introduce a different view into it (which is why I bring up /api/vX as the common pattern).

There are even richer ways to change the DB model with triggers, for instance. Really, it's only clunky because we are not used to doing it (or do not know how), but there is no technical or conceptual limitation compared to API evolution.

Indeed, I was not trying to defend SO, but their point.

Most communities like this develop some (lot of?) elitism, but if you are in the in-group — or early — it can be very rewarding.

My online hacker community time was well before SO (forums even before phpBB, IRC, mailing lists, free software on their self-hosted infra like Gnome, FreeDesktop etc), but you could see the same patterns always (even if you go through usenet group archives or BBS archives).

The beauty of online is that you could always find a community to be in-group of (sounds like a lot of that is happening on Discord these days, but I do not have an account really).

Similarly, you can see that on HN too (passing comments on "green usernames" etc), but it feels like both in-group self-moderation (with flagging and downvotes) and active moderation by dang and co at least keeps it low profile.

To be honest, LLMs already miss such nuance. Attempt to steer it through a narrow band, and it repeatedly tries to go back to the "average" (based on my experience with Claude Code with Fable, Opus 4.* and 5, Codex with GPT 5.*).

Only repeated reasserting can keep it on the path: the difference is that you can without it closing the chat on you.

Not really?

They may have cared about helping "people", but not the individual D. (from the OP) who posted a single question and needed a bit of human connection in the process.

Wouldn't that indicate an issue in your business logic attempting to do this in the first place?

Or if you are relying on DB to fail and your business side to detect and react, you'd still have that built into the business logic so you can just keep retrying the schema migration until it succeeds (if it's rare this happens).

So while I can see how this can happen, it basically is a bug and it means you are doing the migration yet the invariants are not going to be satisfied. Basically, even if it succeeds, you will have future inserts fail with unique constraint being broken.

I believe there are patterns that always work, but might not be optimal for all circumstances.

Eg. you could have a mirror table that you keep in sync with triggers without any constraints or foreign keys, do the migration on it, and then switch them around when ready.

There is really nothing specific to API layer (I am assuming you mean REST API layer) in building backwards- and forwards-compatibility compared to databases. If anything, it is less powerful.

It is pretty easy to do with databases as well, you just need to adopt the right mindset.

For instance, if you think having an "api/vX" of an endpoint is acceptable, then it must also be to create a duplicate table/relation — you'll have exactly the same challenges in maintaining consistency between the two, though RDBMS offer quite a bit of tooling built-in.

You seem to imply Google was forced to open source Android or even to give it for free: sounded like it was a purely business decision to capture more of the market.

Now that they have, they are also turning around on bits of that too.

Wow, great idea!

It's not immediately clear from the README, but is it easy to run with multiple profiles like "backwards-compatible", "revertable" (both data and schema) and "destructive" for that final clean-up in multi-staged no-downtime migrations? Basically common subsets of "safe-ness" of the schema migration queries.

I imagine it can be tuned, but I'd love this for all my projects.

And since I am currently on a project doing MS SQL (gasp), that'd be cool too ;)

I am familiar with an "is it a hot dog" app from back in the day, bit would have never made the connection :)

Someone shopping for an M3 screw would not be interested it trying out a smaller one, but research has shown that people are interested in trying on a smaller size with clothes ;)

However, clothes are nearly impossible to simultaneously standardize and commoditize: people (and their feet) come in all shapes and sizes, so different brands in particular, but also different lines of those brands, will have different proportions.

As a tall guy, I hate that clothes keep growing in width with larger sizes, but rarely grow in length (pants/trousers included), but only because you can't get things without trying them on in multiple sizes.

If you do not understand why standardized sizes are not mandated or something similar, just look at any bespoke garment creation and all the variable measures being taken for a shirt, pants or jacket — just make realistic combination of all of them in different sizes, and you are looking at ~1000 "standard sizes" or more.

Have you looked at SoCs supported by Linaro?

Linaro is (or was, back when I was involved ~10 years ago) non-profit sponsored by SoC vendors to develop, maintain and upstream SoC support for Linux, along with running a comprehensive validation lab for all the boards they support.

A list of manufacturers did change a few times, and it was half-sponsored by ARM directly.

Reminds me of the old Jenkins protocol which warned about "slaves" getting access to execute code on the "master": who's the master now? ;)

That link shows up right below the fold on Yahoo News report for me.

If someone was using RDRAND16 to seed a PRNG, choosing to omit one single value (a zero) from the return value would not significantly improve the generated values, if at all.

With enough repetitions.

With a few (say 10, so 655360 runs), you will not get a uniform distribution, and some numbers (like 0) might not appear.