There are intelligence briefs that we get from Israel, and the money we give them tends to boomerang right back into the US military-industrial complex.

OTOH, Israel collapses in a week without US support. Maybe politicians should realize this and use it to tell Israel to knock it the fuck off.

When do politicians realize that Israel needs the US a whole lot more than the US needs Israel?

Remember when everyone was praising Bolton for going against Trump? This is why you don’t simp too hard for people who have already shown who they are but happen to do one good thing.

Next: Liz Cheney.

I think there’s a way to reconcile it, but it requires people to behave themselves. It can still be under a CC license, but also behind a pay link for the author. Yes, we could get it from somewhere for free, but that takes more effort and we’re not supporting the original creator.

This is basically mutual aid applied to non-physical goods. We know you still need to make a living in capitalism, and we’ll agree to exchange useful things for money under that system until we have a better one.

There’s also an argument similar to the one for streaming services (the one the services themselves have forgotten in the last few years). Yes, we can pirate it, but that takes effort, the sites involved have all sorts of shady advertisements and try to infect your computer with Windows XP viruses, and we can get all we want and more for ten bucks a month.

Given Putin’s theory that nations comprise a set of territory they’ve historically held–Ukraine and Alaska being “rightfully” Russia’s–he surely wouldn’t object to China taking this part, right? And Kaliningrad goes back to Germany? He’ll be good with all that, right?

It’s a shipping lane, so no.

Inflation is a basket of goods. Yes, you can pick out specific things that are rising faster than overall inflation, but people don’t buy just those.

There have been alternative means of measuring inflation, such as the old Billion Prices Project (stopped in 2016) or the Penn State ACY index:

https://sites.psu.edu/inflation/

In practice, they tend to track CPI fairly close.

There’s downsides to the companies, though. Interviewing new candidates takes money, and takes time away from people already on the team. If everyone is switching jobs to get a higher salary, then companies aren’t saving anything in the long run. They also have a major knowledge base walking out the door, and that’s hard to quantify.

It’s a false savings.

If I were to steel man this, it’d be cross-pollination. Old employees get set in their ways and tend to put up with the problems. They’ve simply integrated ways to work around problems in their workflow. New people bring in new ideas, and also point out how broken certain things are and then agitate for change.

This, I think, doesn’t totally sink the idea of the “company man” who sticks around for decades. It means there should be a healthy mix.

I keep waiting for someone to come up with some kind of explanation for this that even sorta makes sense. No, as far as I can tell, companies just work this way.

It’s a historical quirk of the industry. This stuff came around before Open Source Software and the OSI definition was ever a thing.

10BASE5 ethernet was an open standard from the IEEE. If you were implementing it, you were almost certainly an engineer at a hardware manufacturing company that made NICs or hubs or something. If it was $1,000 to purchase the standard, that’s OK, your company buys that as the cost of entering the market. This stuff was well out of reach of amateurs at the time, anyway.

It wasn’t like, say, DECnet, which began as a DEC project for use only in their own systems (but later did open up).

And then you have things like “The Open Group”, which controls X11 and the Unix trademark. They are not particularly open by today’s standards, but they were at the time.

The tooling around it needs to be brought up to snuff. It seems like it hasn’t evolved much in the last 20+ years.

I had a small team make an attempt to use it at work. Our conclusion was that it was too clunky. Email plugins would fool you into thinking it was encrypted when it wasn’t. When it did encrypt, the result wasn’t consistently readable by plugins on the receiving end. The most consistent method was to write a plaintext doc, encrypt it, and attach the encrypted version to the email. Also, key servers are setup by amateurs who maintain them in their spare time, and aren’t very reliable.

One of the more useful things we could do is have developers sign their git commits. GitHub can verify the signature using a similar setup to SSH keys.

It’s also possible to use TLS in a web of trust way, but the tooling around it doesn’t make it easy.

I hate grammers in anything that don’t support trailing commas. It’s even worse when it’s supported in some contexts and not others. Like lists are OK, but not function parameters.

I setup my opnsense firewall for IPv6 recently with Spectrum as an ISP. I followed this howto from The Other Site:

https://www.reddit.com/r/OPNsenseFirewall/comments/xmurda/psa_howto_ipv6_on_spectrum_formerly_twc_time/

Even as someone who has a background in networking, I’d have no idea how to figure some of that stuff out on my own (besides reading a whole lot and trying shit that will probably break my network for a weekend). And whatever else you might say about Spectrum, they have one of the saner ways to implement it; no 6to4 or PPPoEv6 or any of that nonsense.

I did set the config for a /54, but Spectrum still gave me a /64. Which you can’t subnet in IPv6. Boo.

Oh, and I’m not 100% sure if the prefix is static or not. There’s no good reason that it should change, except to make self-hosting more difficult, but I have a feeling I’ll see it change at some point.

So basically, if this is confusing and limiting for power users, how are average home users supposed to do it?

There are some standardization things that could make things easier, but ISPs seem to be doing everything they can to make this as painful as possible. Which is to their own detriment. Sticking to IPv4 makes their networks more expensive, less reliable, and slower.

S-expressions are basically directly writing the AST a compiler would normally generate. They can be extremely flexible. M-expressions were supposed to be programming part of Lisp, and S-expressions the data part. Lisp programmers noticed that code is just another kind of data to be manipulated and then only used S-expressions.

Logo is arguably a Lisp with M-expressions. But whatever niche Logo had is taken by Python now.

I’d like something akin to XML DOM for config files, but not XML.

The one benefit of binary config (like the Windows Registry) is that you can make a change programmatically without too many hoops. With text files, you have a couple of choices for programmatic changes:

• Don’t
• Parse it, make the change, and rewrite it (clobbering comments and whitespace that the user setup; IIRC, npm does this)
• Have some kind of block that says “things below this line were automatically set and shouldn’t be touched” (Klipper does this)
• Have a parser that understands the whole structure, including whitespace and comments, and provides an interface for modifying things in place without changing anything around it (XML DOM)

That last one probably exists for very specific formats for very specific languages, but it’s not common. It’s a little more cumbersome to use as a programmer–anyone who has worked with XML DOM will attest to that–but it’s a lot nicer for end users.

There was a giant drop in the number of men in the Soviet Union during WWII. This has had “echos” in their population pyramid every 20 years, where there’s a shortfall of new babies being born. They never had a baby boom the way the US did.

This affects all the old Soviet states, including Ukraine.

All that is to say that Putin was a real goddamn idiot by launching a war right in the middle of one of these echos when they’re already having population issues.

No matter which tool you’re using, this:

- |> LEFT JOIN |> FROM foo |> GROUP BY clusterid |> SELECT clusterid, COUNT(*)
+ |> LEFT JOIN |> FROM foobar |> GROUP BY clusterid |> SELECT clusterid, COUNT(*)
      ON cluster.id = foo.clusterid

Is always less readable than:

  |> LEFT JOIN 
- |> FROM foo 
+ |> FROM foobar
  |> GROUP BY clusterid 
  |> SELECT clusterid, COUNT(*)
      ON cluster.id = foo.clusterid

And this isn’t even the worst example I’ve seen. That would be a file that had a bug due to duplicated entries in a list, and it became very obvious as soon as I converted it to something akin to the second version.

What about respecting the reader of the diff when there’s a change in the middle?

Possibly unpopular opinion: more languages should embrace unicode symbols in their syntax with multi-character ascii equivalents like Raku did. I set my vim config to automatically replace the ascii version with unicode. It wasn’t hard, it makes the code a little more compact, and with good character choices, it stands out in an understandable way.

It’s used that way in Elixir. I don’t find it a problem.