erik_seaberg

Sacrificing safety might have been defensible on a 40 MHz 80386 that could barely run a C++ compiler (I think this is what I started my career on) but today we find eight-core 3.8 GHz CPUs in desktops and dual-core 1.8 GHz SiPs in wristwatches. Safety should have become table stakes a while ago; Moore's Law already paid for it.

I absolutely do rely on commit messages, and ask for good ones during code review. Everybody on call needs to know how to find root causes in "git log" at 3 AM. The source can't serve the same purpose; including the complete history of what changed when and by whom would make it unreadable (especially things that used to be there but aren't now).

You might be surprised how often a deep graph of microservices ends up rereading the same prior transactions over the course of stateful payment processing and on-demand payouts. DynamoDB can give you 2.6 million short reads of base load (1 RCU/s provisioned) for $0.12 per month, which would make a $65 alternative (2.6 * $5 + 2.6 * $20) a hard sell.

Infallible code is too rare to be worth any effort. Even math can fail (though most platforms are stuck with legacy decisions to quietly return wrong answers). And you always have to recover from a timeout due to a downstream failure in some of the cheap commodity hardware that's running your code.

(it's https://en.wikipedia.org/wiki/Eminent_domain)

Thanks, had not seen that before. It's odd that they came close to reimplementing method dispatch for builtin types, but didn't surface it for developers.

You can declare generic structs and generic functions, and get monomorphized copies (not erased to "any") of each function for all concrete types used. You can't look them up by reflection. You can't declare generic methods, and still can't overload methods by type.

So these announcements aren't binding, but a property developer wants to persuade county voters to approve an initiative to rezone the land (which I guess they had to quietly buy already?) to allow a city bringing jobs (including their solar farm) into a county with a labor surplus. Seems to make sense, but I wonder how much unused water the Sacramento River has.

Hm, I can sort of imagine a way to use lockfile names to claim a random position in a queue of pending changes, but I don't know if anyone has been worried enough to do that. In practice Pulumi seems to give up instead of retrying: https://github.com/pulumi/docs/issues/11679

I'm no expert but from a quick glance at https://www.pulumi.com/docs/concepts/state/#using-a-self-man... it looks like this might work:

  client A lists s3://bucket/prefix/.pulumi/locks/, sees nothing

  client B lists s3://bucket/prefix/.pulumi/locks/, sees nothing

  client A creates s3://bucket/prefix/.pulumi/locks/unique1.json

  client A lists s3://bucket/prefix/.pulumi/locks/, only sees unique1.json, and proceeds

  client B creates s3://bucket/prefix/.pulumi/locks/unique2.json

  client B lists s3://bucket/prefix/.pulumi/locks/ and sees both unique1.json and unique2.json

  client B assumes it lost a race, deletes s3://bucket/prefix/.pulumi/locks/unique2.json, and retries

There's another mode where both clients pessimistically retry, but fuzzing a retry delay could eventually choose a winner randomly.

https://aws.amazon.com/blogs/aws/amazon-s3-update-strong-rea... guarantees that a client's lockfile can always be seen by other clients immediately (which didn't used to be true). If every client backs off and retries after a race, is that enough?

Infra as code. Write a template for a Spanner table in your GCP account. If it doesn't already exist, OpenTofu will notice and offer to send the API call to create it.

It's like using AWS CloudFormation or GCP Deployment Manager, but supports quite a few cloud vendors with the same tools.

That's my guess.

They were talking about finally adding MIME types to Gopher+ in 2002, which I think was too late to compete with the Web. Sniffing for UCS-2 or UTF-8 or Latin-1 might have worked or might have given us more https://en.wikipedia.org/wiki/Mojibake.

It's not a programming language with semantics, but it is a https://en.wikipedia.org/wiki/Context-free_language in the sense that we have a grammar specifying which strings are valid.

A couple of earlier appearances netted some discussion:

https://news.ycombinator.com/item?id=28690798

https://news.ycombinator.com/item?id=431702

Adding a video codec sounds expensive, how many concurrent users can an app server support that way?

A cleanroom process is evidence that you reimplemented without copying, but that's not enough to avoid infringing a patent. You need to redesign to avoid doing anything they claimed, convince the patent office that they made a mistake in granting some or all of the claims, hold a war chest of patents you could counter-sue with, or YOLO: https://paulgraham.com/softwarepatents.html

That is an odd hypothesis that Sapir and Whorf were never able to prove.

Can a backend app use a single GPU (integrated or not) to support many concurrent users, so that software rendering doesn't become a bottleneck?

Yeah, I have nothing constructive to say about apps and toolkits that choose only local rendering with no hardware, but it's pretty funny to see Javascript apps beating them on performance.

A user on any X11 desktop can open a GUI from any X11 app, even one running in a datacenter. It's like a Javascript app in a browser today, but every Unix GUI app knew how to do it on late 1980s hardware, so you didn't even have to buy and admin a complete desktop computer for each user.

Windows sort of has this with RDP, but it's tied in with the app's GDI desktop, and I don't know whether it works without buying a bunch of video cards for the headless app server. NeXTSTEP had Display PostScript (remote rendering worked like printing!) but macOS lost support for it.

Wouldn't the heat pump and generator do better than burning the same fuel in a gas furnace?

If one machine can only handle a hundred transactions per second, and you might ever receive more than that, you have to spread the work across several machines, probably by assigning primary keys that aren't (mostly) sequential.

You often can't bottleneck the entire workload on the capacity of one cluster node and one storage device.

You should definitely bench your storage to confirm that it likes hotspots (some don't!)

If your team hasn't engineered in monotonically increasing distributed clocks, the results of sorting are only partly correct. I'd rather not promote an option we can't rely on.

Some of the comments were from 2-3 hours ago. I think someone bumped the story's time by resubmitting.

Market rates reached pretty unsustainable levels, so it's hard to justify complaining when competition (usually not arbitrage by resellers) brings them down. I would love to see a higher bar for quality, but I think that has to start with end users saying no.

Lombok, Error Prone, and Kotlin also have their takes on the problem.