Right.

As an example, Klipper (for running 3d printers) can update its configuration file directly when doing certain automatic calibration processes. The z-offset for between a BLtouch bed sensor and the head, for example. If you were to save it, you might end up with something like this:

[bltouch]
z_offset: 3.020
...
#*# <---------------------- SAVE_CONFIG ---------------------->
#*# DO NOT EDIT THIS BLOCK OR BELOW. The contents are auto-generated.
#*#
[bltouch]
z_offset: 2.950

Thus overriding the value that had been set before, but now you have two entries for the same thing. (IIRC, Klipper does comment out the original value, as well.)

What I’d want is an interface where you can modify in place without these silly save blocks. For example:

let conf = get_config()
conf.set( 'bltouch.z_offset', 2.950 )
conf.add_comment_after( 'bltouch.z_offset', 'Automatically generated' )
conf.save_config()

Since we’re declaratively telling the library what to modify, it can maintain the AST of the original with whitespace and comments. Only the new value changes when it’s written out again, with a comment for that specific line.

Binary config formats, like the Windows Registry, almost have to use an interface like this. It’s their one advantage over text file configs, but it doesn’t have to be. We’re just too lazy to bother.

Is a very good idea providing much needed fixes to the JSON spec, but isn’t really what I’m getting at. Handling automatic updates in place is a software issue, and could be done on the older spec.

Benefit society, or go to support a pharmaceutical company that will in some way benefit society in exchange for making a few people rich?

No ethical consumption working conditions under capitalism.

What I’d like for a configuration language is a parser that can handle in-place editing while maintaining whitespace, comments, etc. That way, automatic updates don’t clobber stuff the user put there, or (alternatively) have sections of ### AUTOMATIC GENERATION DO NOT CHANGE###.

You need a parser that handles changes on its own while maintaining an internal representation. Something like XML DOM (though not necessarily that exact API). There’s a handful out there, but they’re not widespread, and not on every language.

The paper actually argues otherwise, though it’s not fully settled on that conclusion, either.

Not sure about GP, but that’s basically what we did under “SAFe” (Scaled Agile Framework). PI planning means taking most of a sprint to plan everything for the next quarter or so. It’s like a whole week of ticket refinement meetings. Or perhaps 3 days, but when you’ve had 3 days of ticket refinement meetings, it might as well be the whole work week for as much a stuff as you’re going to get done otherwise.

It’s as horrible as you’re thinking, and after a lot of agitating, we stopped doing that shit.

I demand an RFC making this official.

It’s a correct proof.

One way to think about this is that we represent numbers in different ways. For example, 1 can be 1.0, or a single hash mark, or a dot, or 1/1, or 10/10. All of them point to some platonic ideal world version of the concept of the number 1.

What we have here is two different representations of the same number that are in a similar representation. 1 and 0.999… both point to the same concept.

Just smart as hell. This video makes me wonder if elephants legit have a sense of humor:

https://www.youtube.com/watch?v=2VOvEFHDOaU

Animal behavior can be difficult to interpret (and even when descriptions come from experts, I often find myself asking “yeah, but how do we really know that?”), but this looks very close to being like someone who’s known for lighthearted pranks.

They have x86_64 models.

Not how it works.

“Time exists” is a positive statement. We need evidence for positive statements. There is no evidence of time until the big bang.

Maybe there were other big bangs, but we need evidence of that, and that evidence doesn’t exist.

Jyst saying “but we don’t know” isn’t a replacement for evidence.

It’s only something we can speculate about. It represents a limit to our ability to gather any evidence that might validate those speculations. We can’t say what happened before it, because time itself was one of the things that popped out of the big bang. What would “before” even mean if time didn’t exist?

Even if time and matter did exist in some sense, we can’t get any evidence for it. We can’t make any kind of useful theory about it. At best, we can make wild guesses.

We could also just say “we don’t know what it was like”. Russell’s Teapot suggests we should instead say there was nothing, because we can’t prove there was anything.

There’s almost always at least a little ASM sprinkled into any kernel, so that’s not a big deal.

OTOH, there is the factor of “you know how Chrome takes up 2GB per tab? What if that was a whole OS?”

You’re probably in a country that got a ton of allocations in the 90s. If you came from a country that was a little late to build out their infrastructure, or even tried to setup a new ISP in just about any country, you would have a much harder time.

Yes, everyone forgets them. Mostly for good reasons.

Arm is better because there are more than three companies who can design and manufacture one.

Edit: And only one of the three x86 manufacturers are worth a damn, and it ain’t Intel.

Edit2: On further checking, VIA sold its CPU design division (Centaur) to Intel in 2021. VIA now makes things like SBCs, some with Intel, some ARM. So there’s only two x86 manufacturers around anymore.

The Rust compiler tends to turn my impostor syndrome to 11. I assume she has some kind of humiliation kink and I do not consent.

JSON and XML can be “real” languages. Mostly because of people who didn’t stop to ask if they should.