Skip Navigation

Posts
12
Comments
197
Joined
3 yr. ago

Just a basic programmer living in California

  • I recommend at least watching Yesteryear, the episode about Spock's childhood. That's a good one, written by one of Star Trek's most significant writers, D. C. Fontana.

    If you want to learn what the deal is with Spock 2 you'll have to watch a very, very strange episode.

  • Thanks for the summary! Initially I thought the headline was about writing Typescript programs 10x faster.

  • It might be clear to many what this is from the subtitle. But since I took the time to click through I'll summarize: it concatenates multiple text files into one text file / string with markers so that the individual files can be extracted out again with intact file content, path, and permissions.

  • I customized the top bar to resemble Gnome's. That's stuff like clock and notifications top-center, control center top-right, using the Cantarell font. It's definitely not exactly the same. Here's the config. (It's written in Nix which generates the Noctalia config file.)

    Some Gnome settings configure GTK which apply to GTK windows in non-Gnome window managers. But you wouldn't be using Gnome's control center. You'd use a combination of Noctalia's control center (handles lots of stuff like wifi, bluetooth, audio inputs & outputs) plus the settings system of whichever window manager you use Noctalia with. The WM will manage stuff like display settings, and key bindings.

    I think xdg support is mostly managed by the window manager? That's stuff like screen & sharing, file pickers. I use Niri, and it's got solid support for that stuff. Some of my favorite Niri features are how it handles screen sharing and privacy.

  • I heard about the story about how Paramount turned down the Babylon 5 pitch, then turned around and made Deep Space 9. Of course the two shows went in different directions, and are each great in different ways. But there are eyebrow-raising surface similarities. Both shows are named after a numbered space station, feature a commander who is a prophesized savior, have long story arcs, explore moral complexity.

    Yesterday I watched the movie pilot, The Gathering. There is another similarity I hadn't realized before: both commanders are romantically involved with a freighter caption whose name starts with "Ca"!

  • The sentient hologram idea bothers me. With Data they establish that consciousness is only possible with a specialized positronic neural net that is extremely difficult to reproduce. OTOH holograms are programs running in the ship's computer. Ordinary programs, on ordinary (for Star Trek) computer chips.

    Voyager is often written as though a hologram has some special physical properties that make it logically different from a computer program without a holographic projection. But I think it's clearly established in TNG and DS9 that holograms are programs in the computer controlling projected force fields and replicated matter and whatnot.

    I know The Doctor sometimes runs on the mobile emitter instead of the ship's computer. And TNG did break its own rules with Moriarty. And arguably DS9 did too with Vic Fontaine. I don't mind because these occasional exceptions are fun! The Doctor is the best part of Voyager! Mostly it bugs me when they imply that every computer program is sentient (but only if it's connected to a projector!); or especially when they bring in photonic beings that somehow aren't projections controlled by a computer and holographic hardware?

    Maaaybe you could argue that Voyager holograms are special because the bio-neural circuitry has some of the same properties as positronic neural nets. But I don't recall any explanation of that sort in the show.

  • The author described the process in Rewriting Bun in Rust. The tl;dr is it wasn't as simple as prompting "rewrite this in Rust", but the process was done entirely by a series of AI agents.

  • Very nice! One of the issues of using Nix has been the ad-hoc methods for pinning versions, such as rust-overlay. (Although rust-overlay is great for toolchain customization which might make it worth keeping around.)

    Even with some ad-hoc pieces I'm happier using Nix than using completely unrelated tools for each ecosystem, like Rustup and Nvm. If we could have a more unified Nix solution that would be even better.

    It could certainly make my old Python versions test matrix easier to maintain.

  • You're welcome! It's a self-serving pleasure to show off my knowledge of Star Trek episodes.

  • Hmm... episodes where violence is the answer. The obvious candidates are the first two Borg episodes. Those were written to challenge the idea that diplomacy is always an option:

    • Q Who
    • The Best of Both Worlds

    Other (less good) episodes with an enemy that can't be reasoned with include Skin of Evil, and Conspiracy. And I suppose Time's Arrow (but that one is a good episode).

    Episodes where negotiation fails, and the Federation chooses violence:

    • The High Ground (hey, it's in both of my lists!)
    • Preemptive Strike

    There are a bunch of episodes where there is an individual, or a handful of individuals, who must be stopped. That's a common story even in Star Trek. A couple that seem most relevant to me for this idea are:

    • The Most Toys (because of Data's analysis of his situation)
    • Starship Mine (maybe the purest example of a regular crew member choosing violence)

    It is a shorter list. After all, we're not talking about TOS.

  • I considered Too Short a Season in my "Episodes about negotiation, but really it's about a hotshot ambassador" category. But IIRC it's ends up being a two-party negotiation - there isn't a mediating party.

  • You already mentioned Angel One

    Episodes where the crew clearly mediate a cultural conflict:

    • Symbiosis
    • The Ensigns of Command (the two sides don't interact directly, and one side is human, but this is all about negotiation, and it's a good one)
    • The Vengeance Factor
    • Devil's Due (political negotiation via courtroom procedure)
    • Suddenly Human (family-scale dispute, but culturally divisive, one side is human)
    • Birthright
    • Journey's End (one side is human)

    Episodes where the crew gets involved in an internal conflict (episodes with * are more action than negotiation):

    • Angel One
    • The Hunted*
    • The High Ground
    • Transfigurations*
    • Legacy*
    • Unification*
    • The Outcast

    Internal conflicts, but specifically Klingon politics where the two sides are Klingon factions:

    • Reunion
    • Rightful Heir

    Episodes about negotiation, but really it's about a hotshot ambassador:

    • Loud as a Whisper
    • Sarek
    • The Host
    • Man of the People

    Honorable mention: The Price is mostly negotiations between several cultures. But there isn't a clear mediating party. And the negotiation is over a purchase agreement, not a political disagreement.

  • I agree that this doesn't seem necessary. Personally I think Nix would be a good candidate for dependency management that works consistently between languages. I think that may be partway set up for Haskell, and I've noticed that nixpkgs has a good collection of Python dependencies. But for most cases the Nix flow currently usually involves using the language's bespoke dependency manifest to generate a Nix expression that downloads dependencies from the language's bespoke package repo.

    One advantage of Nix is that you don't need all packages in one repo. Nixpkgs is mostly geared for the NixOS Linux distro. Each language ecosystem could have its own repo if that makes the most sense, with Nix being the common connective language.

  • Nix / NixOS @programming.dev

    Experiments configuring jj fix with Nix devShell

  • I think it would be more clear with an apostrophe at the beginning of the word. But if you do the technically correct thing and put apostrophes at both ends to stand in for both elided syllables then it looks like the whole word is in quotes, and you're back to square one. It's a 'nundrum.

  • So long Garnix! It will be missed

  • I'm using Rust on the server, Typescript on the client. Some very interesting options have appeared in Typescript over time for better ADT handling!

    ts-pattern provides a match function that verifies matches are exhaustive. Yes, it's a static check. It's got a powerful matching language that does stuff like extract nested properties from complex inputs, like Rust's match. I recommend reading the documentation - for me it led to some "I didn't know that was possible!" moments.

    I've also been using fp-ts to get Option and Either types. (Either instead of Result because fp-ts is inspired by Haskell.) It has features for processing fallible values as monads which gets close to the conciseness of Rust's ? operator and try Trait, but is more generalized. It also has mtl-ish types like TaskEither which roughly serve the purpose of a Promise but with an explicit error type.

    Now that you mention it, must-use detection for Either values would be helpful. Eslint has a built-in check that does exactly that for Javascript's native Promise type. I haven't tried it, but it looks like eslint-plugin-fp-ts has a rule that might do the same for other types.

  • Oh, nice! Does this do something like Git Butler where you can have multiple branches "checked out" simultaneously, and keep track of which changes belong to which of those branches as you work? But maybe without the commitment that Git Butler requires to using its tooling?

  • I try to capture every detail of the build and test environments in Nix devshells. And where I can I try to encapsulate as much as possible in Nix checks and packages which run in build sandboxes - both locally and on the server. Build sandboxes don't work for everything, but the devshells alone are great for reproducibility.

    • Wrong interpreter version? A devshell with a flake.lock file ensures every environment is using the exact same interpreter.
    • Accidentally picking up stuff from the local .env? Sandboxed checks and builds don't get any files that aren't version controlled, so that's not an issue. But it's still an issue with devshells.
    • Accidentally picking up programs or env vars in your environment? Sandboxed builds always get a clean starting environment. If you run nix develop --ignore-env you get a devshell that also gets a clean starting state.

    Nix doesn't fix everything.

    • File system case sensitivity - depending on where this issue presents (program-generated files vs source files), I use property testing to catch this problem. In fact I was working on exactly that the other day.
    • Timing issues - that's a good old fashioned hard problem. Try to make logical dependencies explicit. It's really easy to get implicit order dependencies in concurrent code if you aren't on guard. In languages that support it promises or futures are good for spelling out what needs to happen in what order.
    • Edit: Difficulty keeping secrets in sync - one option is to use Sops or Age to put encrypted secrets in version control. Then your CI only needs to be configured with one secret to decrypt the other secrets it needs.
  • I'm not sure how to pronounce that name so I'm going to opt for an all-in French pronunciation. That makes the capital X silent!

  • Nix / NixOS @programming.dev

    Embedded SQL highlighting in Neovim, a look into Treesitter, and some NixOS patching

    sitr.us /2026/05/03/embedded-sql-highlighting-in-neovim/
  • Programming @programming.dev

    The 6 Big Ideas of Typescript

    sitr.us /2026/04/06/big-ideas-of-typescript.html/
  • Nix / NixOS @programming.dev

    run Kodi media center

  • Linux @programming.dev

    Selective VPN confinement in NixOS

  • Nix / NixOS @programming.dev

    Selective VPN confinement in NixOS

  • Nix / NixOS @programming.dev

    Patch interpreter path in embedded binary?

  • Nix / NixOS @programming.dev

    work around a misbehaving binary cache

  • Nix / NixOS @programming.dev

    Native Wayland gaming with Wine on NixOS

  • Rust @programming.dev

    Comprehending Proc Macros

  • Rust @programming.dev

    “Truly Hygienic” Let Statements in Rust

    sabrinajewson.org /blog/truly-hygienic-let
  • Nix / NixOS @programming.dev

    gnome-keyring as ssh agent in lightweight window manager