People used to care a lot. The GNU utils absorbed everything all the old Unix vendors did. This made them comparatively heafty back when a high end workstations might have had 64MB of RAM.

Now that Chrome takes up gigabytes per tab, nobody cares except a few old Unix curmudgeons.

Meh. It’s a nice bragging right, but that’s all it is at this point. Linux killed off almost all the old Unix vendors for a reason.

The stock portion is reduced, yes, but there’s almost always some kind of mix of stocks in the portfolio. That’s not necessarily the main issue.

First, you may not get to choose the timing. A lot of older people got trapped in the 2008 downturn. They were planning on retiring a few years out, but they lost their jobs and never got them back. Not only was their portfolio unprepared just based on when they planned to retire, but also the stock crash killed a chunk of what they had. Double wammy of losing their job and destroying their portfolio.

Second, inflation hits hard. If there’s a period of high inflation right when you retire, that can really hurt your savings regardless of how it’s distributed. One of the things those forced 2008 retirees had going for them was that we had a period of relatively low inflation for the next decade. If you took out housing (older people often own their home outright), inflation was sometimes negative.

Capitalism, even when it generally makes line go up, does so in a spiky way. Those spikes cause problems that tend to hit the working class the hardest. Sometimes in ways that cannot be recovered.

There are some liberal economists, particularly of a Modern Monetary Theory bent, who do argue for policies that would flatten growth in return for predictability. Capitalism always goes for the sugar rush of high gains, though. For example, the Fed left rates at rock bottom for far too long, thus letting the market continue extremely high gains (over 20% per year of the sp500, when 7% is a typical long term average). Likewise, you have corps chasing high profits and assuming post pandemic pent up demand would continue indefinitely. Which is now leading to layoffs while major stockholders continue to sweep it in. Both of these lead to the recent high inflation.

I think the efforts to flatten it out are doomed. Capitalism can’t solve its own problems.

Right, and there are tons of other ways that companies run better when workers are empowered to initiate changes. There are a few companies that manage to do this on their own, but most that get there do it because the union forced the issue.

The old plan was that you’d have three things in retirement: Social Security, a corporate pension, and a 401k. Each of these has problems, but if any one of them fails, then the other two are still there to provide enough.

Problem is, pensions have all but disappeared, Social Security gets fucked with, and 401k’s are highly dependent on market conditions at the time you retire.

There’s a theory about Alice in Wonderland that Lewis Carroll was satirizing the absurdity of the increasingly abstract mathematics that was popping up at the time. Now, I don’t think that theory holds weight–Alice in Wonderland doesn’t need to be anything other than a whimsical children’s book–but he did apparently write some things along those lines. This post is a pretty good example of something that would throw him into a rage.

For Debian, “unstable” just means “not running a five year old compiler”.

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.

15k rpm fans help, too.

Sometimes. Those can get canceled when they layoff the team after release.

Who are the real pirates?

In particular, the big push in Wisconsin for expanding Amtrak (not even high speed rail) circa 2010 was killed by Republicans taking office. The trains themselves were already paid for, but they never took delivery. So the state paid all the costs for nothing, and IIRC, it was actually more expensive to cancel it at that stage.

I recently took the Amtrak from Columbus, WI to Minneapolis. Even as limited and poorly implemented as Amtrak is compared to European rail, it was still a more pleasant experience than either flying or driving. I always feel exhausted after a flight; even though you’re not physically doing much, the whole process is so unpleasant that I need to collapse in bed afterwords. Didn’t feel that way at all on Amtrak.

To clarify, that’s by metro district. St Louis is 76th by the population inside its city boarders. It’s about 100k more than Springfield, MO.

Suburban sprawl sucks.

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.