zamalek

I'll be hanging around until someone mods more PIs into it.

I think that many companies have been appending + to the end of product names for an extremely long time. This is hardly an Apple innovation.

I wonder if [good examples of] SVGs of pelicans on bikes are "being introduced" into training sets. Some of the engineers who work on this stuff are the kind to hang out here.

I recently switched back to kitty from ghostty. Ghostty was taking > 1s to boot, and I really don't have the time to debug it.

My friend sent me that article a few months ago. It _completely_ changed my approach to OSS contribution: from a 25yr MIT/BSD adherent to AGPL adherent in 30min.

EAC works fine if the game has it enabled for Linux, which The Finals does (I play it).

Yeah it legitimately trades blows with the lightweight desktops.

I attempted to make a ostree+Nix distro a while back, but ublue didn't exist at the time and the build documentation was a masterclass in obfuscation.

Immutable is definitely the future.

You're absolutely right!

I worry about the brain rot because, while I am not purely vibing, I am relying on Claude for most of my typing. I still routinely need to work those hard-earned brain muscles with what it produces; it's terrible at factoring things into components, I've seen it write SQL injection vulnerable code frequently, and it litters the code base with TODOs. If I were to describe it, it's extremely lazy - and you constantly have to remind it to do the work, do it correctly, and course correct it when it's making bad long term decisions.

If I end up brain rotting I am seriously concerned about the quality of code that I will be producing.

But I do agree with the core of your argument. Code is a tool, one that I don't mind replacing.

There is one unmentioned far future benefit: if you pay your mortgage off before retirement you'll probably enjoy more shelter security than your peers. Rent is a monthly cost (eating into your retirement) that could skyrocket (which your retirement plans may not have accounted for).

Of course, a solid investment plan may offset these - but only a domicile (doesn't need to be a house) would survive everything related to the economy going to utter hell.

I agree about houses, though. A saner plan may be to purchase a modest apartment or the like, that you keep in the wings until you reach retirement.

One reason is that the JIT needs info on the types passed to the method, which are only available after a few calls. Per the article, a+b could refer to any type of a and b. The only way to know what was used is profiling.

Even for varints (you could probably drop the intermediate prefixes for that). There are many examples of using SIMD to decode utf-8, where-as the more common protobuf scheme is known to be hostile to SIMD and the branch predictor.

Not much use in the modern world, but SQL Server has this and I've had too many projects to approach doing it for pgsql. In Visual Studio there was a SQL project, and in it you would write your SQL as though you were bringing up the DB from scratch; with directories and all for your convenience.

Internally it would materialize it all into a schema which could not only be used for things like go to def, but also for diffing against another schema - either a previous build, or your live db, and subsequently emitted as a migration. It was magical, but flew under the radar, and these days any individual stuck working with SQL Server deserves many condolences.

> Yeah it's weird.

When you consider SK's neighbors, and their neighbors' ambitions, it really isn't at all.

WebAuthN/fido/passkey should be mandatory to publish a package with >N downloads. Email and TOTP codes can be MITMd.

For the uninitiated, one popular example is SPICE: https://en.wikipedia.org/wiki/SPICE

Even with my limited knowledge about FP I am pretty sure I would only grow more in agreement as I learn more. My only exposure to functional is via Nix and Rust (I promise I'll learn OCaml soon). One thing that I've really come to appreciate is the concept of "making invalid states unrepresentable," a trick that is harder than it should be (though not impossible) in "less functional" languages. Coming back to distributed systems, I have wondered what a functional database would look like. Mutations as pure functions, DUs in tuples, could we store a function, etc.

As a huge fan of podman this is definitely one of my disappointments. In the event that you're still struggling with this, the answer is using a --user systemd quadlet. You'll need to use machinectl (machinectl shell <user>@.host) for systemd commands to work, and you'll want to enable linger for that user.

One thing which just occurred to me, maybe it's possible to have a [container] and a [service].user in a quadlet?

I've tried it, but then I have to remember what has been pushed.

But that would undo what I've done, right? I Wang to keep the changes but only diff them against what I've pushed.

I'm a through-and-through JJ convert. One papercut I have experienced a few times (though I am getting much better at avoiding) is what to do when I forget to `jj new`. Assuming that I have pushed the current bookmark to the remote, is there any way to recover a new change that is the diff against the remote? I have tried rebasing, but that leads to bookmark ambiguity instead of the solution I'm looking for.

A ton of these new system languages can't seem to let go of exceptions (and/or null), which is increasingly being shown to be bad design. I would wager good money that a significant majority of those who disagree have not used exceptionless languages in anger.

Personally, I would learn any of them for a job - but not for joy. Exceptions subtract joy.

V is definitely worth looking at (but I have found the time yet).

Interesting, databricks has been my first exposure to DE at scale and it does seem to solve many problems (even though it sounds like it's causing some). So what does everyone else do? Run spark etc. themselves?

When I truly grokked complex numbers, I felt as though real numbers were a lie - though I would now say that it was a convenient omission. There are many things that are more naturally described using complex numbers - waves (which much of reality boils down to) immediately come to mind. Even if something does align better with real numbers, it's still just x+0i. Maybe I'll change my mind ~when~ if I finally grok quaternions.

One things have seen through my more recent exposure to experienced data engineers is the lack of repeatability rigor (CI/CD, IaC, etc.). There's a lot of doing things in notebooks and calling that production-ready. Databricks has git (GitHub only from what I can tell) integration, but that's just checking out and directly committing to trunk, if it's in git then we have SDLC right, right? It's fucking nuts.

Anyone have workflows or tooling that are highly compatible with the entrenched notebook approach, and are easy to adopt? I want to prevent theses people from learning well-trodden lessons the hard way.

It's not technically a make replacement (make does do things like incremental build management etc.), but it just goes to show how bad the DX of make is.

It could just as easily be known, or unknown, physics.

(I'm a bigger podman stan)

I agree about quadlets, amazing.

Docker has one of the most severe cases of not-invented-here. All solutions require a combination of a new DSL, a new protocol, a new encryption scheme, a new daemon, or any combination there-of. People are sleeping on using buildah directly; which OP alluded to with Bakah (but fell short of just using it directly).

Ever wish you could run multiple commands in a single layer? Buildah lets you do that. Ever wish you could loop or some other branching in a dockerfile? Buildah lets you do that. Why? Because they didn't invent something new, and so the equivalent of a dockerfile in buildah is just a script in whatever scripting language you want (probably sh, though).

This will probably give you the general idea: https://www.mankier.com/1/buildah-from

I came across this when struggling and repeatedly failing to get multi-arch containers built in Circle CI a few gears ago. You don't have access to an arm64 docker context on their x86 machines, so you are forced to orchestrate that manually (unless your arm64 build is fast enough under qemu). Things begin to rapidly fall apart once you are off of the blessed Docker happy path because of their NIH obsession. That's when I discovered buildah and it made the whole thing a cinch.

I'm guessing this is fiction, but it's not unreasonable. Employers love to harp on about "loyalty," "being family," and "caring for you." Try to remember the last time any employer of yours has demonstrated these traits for either you or a, functionally ex-, colleague.

We need to stop participating in this brouhaha as an industry. If your employer wanted to demonstrate loyalty you would see it in your contract.

Operating a business is hard? Well, yes, so is surviving.