Lightnews — Scholar-powered news

beat

@beathagenlocher.com

Apparently this is a thing: Desktop Environments in the browser

#OS #TheWeb

I did not know it's a thing that people are building desktop environments in the browser for fun:

- https://webos.js.org/
- https://dustinbrett.com/

Wild.

February 16, 2026 at 9:58 AM

beat

@beathagenlocher.com

Just found a better sqlite cli: [litecli](https://litecli.com/)

#TIL #sqlite

After getting annoyed by the default sqlite Command Line Interface (it doesn't even support `arrow up` ≙ last typed command), I found `litecli`

```nix title=flake.nix
# ...
packages = [
# ...
pkgs.litecli
# ...
];
# ...
```

in every sqlite project from now on :)

February 15, 2026 at 5:10 PM

beat

@beathagenlocher.com

Auth

#Auth #BetterAuth #ZITADEL #StackAuth #Logto #kanidm

Over the last few weeks, I've spent some time on and off researching a good way to do Authn and Authz, and struggled quite a bit with the number of options available.

Not completely understanding what I'm doing/how to search for my requirements, I've first started trying Logto (but that an UI clicking contest to set up), then going for kanidm without realizing this doesn't have support for a public sign in form, which is something I need.

And just now when I'm relatively sure that Better Auth fits my needs quite well, I've discovered Stack Auth via this nice website: https://www.auth0alternatives.com/

Man, if I only would've found this 4 weeks earlier.

February 12, 2026 at 8:04 PM

beat

@beathagenlocher.com

I wrote a very simple introductory note I'd really enjoyed reading some years ago: Setting Up A Server (with NixOS and Clan)

#ssh #TheInternet #IP

# 1. Getting the server

As with most things, setting up a server is relatively straighforward once you know what you're doing.

So, what you want is:

- a machine that runs on the internet for you, awaiting your requests and which
- you can reach from anywhere.

Since both the 'is reachable' and the 'runs constantly' parts are relatively hard to provide when you're just starting out (and probably only have a laptop/phone), you want to go to someone who's _job_ is to provide these two things for this (That's called a _Hosting Provider_).

For starting out, the thing you're looking for is the cheapest option of a _Virtual Private Server_ (called VPS).

So for finding what you're looking for, google something like `hosting provider vps cheap reddit`, and see what's currently in store.

(This should be about 5€/month)

Then go onto the site of your choice, create an account, and rent the VPS you want.

For Hetzner in 02/2026 (the provider I'm currently using), this is something like:

- [x] Cost-optimized
- [x] CX23
- [x] Somewhere in the EU, preferably close to where you are
- [x] Ubuntu (but we're gonna change that later)
- [x] both a IPv4 and IPv6
- [ ] your _ssh keys_ (You might be wondering: What are _those_?)
- [x] and a name

That's it.

> Except for the ssh keys.

## Generating ssh keys

An _ssh key_ is a thing you can use to verify you're you to someone else.

For now, the only thing that's important about them is that our server can let us login without a password if we have the correct ssh key available on our system.

So what we need to do is generating a key pair (a private key with a matching public 'lock', confusingly also called a key), and then depositing the _public_ key of the pair (so the _lock_) on the server.
With this, the server will be able to tell that we're allowed to login whenever we log in from a system that has the private key of this specific key pair.

With this knowledge:

<Il href="/setting-up-git#1-generating-the-ssh-key-pair">Generate the ssh key pair</Il>

And then upload the public key to the hetzner.

You can check that everything worked by `ssh`ing onto your server:

If you're _not_ prompted for a password, everything worked.

# 2. Put NixOS on the server with Clan

Now for the important part. Just having a server means manual, stateful configuration, and we're not going to do that.

Instead, we're going to use NixOS with Clan.

Follow Creating your first Clan.

And that's it.

February 12, 2026 at 7:39 PM

beat

@beathagenlocher.com

I've recently set up Immich on my home server (with Clan), and half-finished a note on this :)

#NixOS #Clan #Immich #HetznerStorageBox #Samba/CIFS #FileSystemMount

$Today, I spent some time getting my photo setup together, (and away from manually uploading them to my storage box from time to time 😬). So I've decided I'd give Immich (as a self-hostable photo solution on my server) a try. <Callout type="info"> In case you don't know yet how to get and set up a server, take a look here: Setting Up A Server (with NixOS and Clan) </Callout> # Setting up Immich Setting Immich up with NixOS is relatively straightforward, at least at first glance: ```nix services.immich = { enable = true; host = "photos.example.ts.net"; }; ``` But since I'm not running a Tailscale network (yet, I guess?), I need to make my immich service reachable from the outside. This looks like this: ```nix services.immich = { enable = true; }; services.caddy = { enable = true; virtualHosts."photos.your.domain" = { extraConfig = '' reverse_proxy 127.0.0.1:2283 ''; }; }; ``` <Callout type="info"> For this to work, you need to: - own a domain - set a DNS A record to `photos` -> "IPv4 IP of your server", e.g. `1.12.234.45` If you don't know how to do that, take a look here: Setting A DNS Record On A Domain </Callout> Now we've got a machine running Immich that's reachable from the outside via a domain. Meaning: You should be able to go to `https://photos.your.domain`, and see the Immich login screen. So that's it—almost. # Mounting a storage box We've still got one problem: The machine this is running on is the smallest Hetzner VPS: powerful enough to run Immich, but not large enough to host all the photos. It's got only 40GB of disk space, and upgrading that gets expensive fast. So you probably don't want to store photos on there. Thankfully, Hetzner also has a service called a _Storage Box_. A Storage Box has the opposite characteristics to a VPS: It's pretty cheap per TB, but you can't really run anything on it. So, let's match the two. What we're going to do is the following: We will mount the storage box as a file system into the folder in which Immich is going to store its data in. For this, you need to: 1. Have a Storage Box (so rent one) 2. Create a new sub-account (with corresponding subfolder) on it. _Save the password for this into your password manager_ 3. Mount the subfolder into our server Mounting the subfolder looks like this: <Draft> ```nix services.immich = { enable = true; }; services.caddy = { enable = true; virtualHosts."photos.your.domain" = { extraConfig = '' reverse_proxy 127.0.0.1:2283 ''; }; }; environment.systemPackages = [ pkgs.cifs-utils ]; fileSystems."/var/lib/immich" = { device = "//uXXXXXX-subX.your-storagebox.de/uXXXXXX-subX"; fsType = "cifs"; options = [ "x-systemd.automount" "noauto" "x-systemd.device-timeout=5s" "x-systemd.mount-timeout=5s" "credentials=${config.clan.core.vars.generators.storagebox-immich-secret.files."credentials".path}" "uid=immich" "gid=immich" ]; }; ``` - vars setup - add the secret to vars - issues - immich can't write or read the files - with disabled machine learning the server dies, and I don't know why </Draft> # Notes <References> <ReferenceLink href="https://forums.linuxmint.com/viewtopic.php?t=333084">Samba Storage Share </ReferenceLink> </References>$

February 12, 2026 at 7:38 PM

beat

@beathagenlocher.com

Trader/Non-trader in Chrome Web Store

#EU #ChromeWebStore

Today, I thought about writing and publishing an extension to the Chrome Web Store.

I researched, and found this funny bit:

The EU apparently requires you to indicate whether you're a _Trader_ or _Non-Trader_, when you want to publish extensions on the store.

Which is fine, (I guess), but apparently literally no one has a definitive answer to what that means:

- Am I a trader or non-trader | Stackoverflow
- What constitutes a trader
- trader/non-trader disclosure | Google Groups

February 12, 2026 at 7:22 PM

beat

@beathagenlocher.com

Diffing two directories

#TIL #shell

Today I learned that you can diff two directories just like you can diff two files:

```shell
diff dir1/ dir2/

# or recursively
diff --recursive dir1/ dir2/
```

Sweet!

Comparing the contents of two directories | Stackoverflow

February 8, 2026 at 10:39 PM

beat

@beathagenlocher.com

New stuff

#TIL #Emacs

Just now I learned

- about Shannon, an pentesting agent
- and that there's still an ongoint "Emacs in Rust" experiment people are actively working on!
-> rune

Looking forward to try Shannon out ^^

(rune isn't anything more than an Elisp interpreter right now)

February 8, 2026 at 12:10 PM

beat

@beathagenlocher.com

mas.to/@zekjur/1160...

This is wild.

Michael Stapelberg 🐧🐹😺 (@[email protected])

Attached: 4 images PSA: Did you know that it’s **unsafe** to put code diffs into your commit messages? Like https://github.com/i3/i3/pull/6564 for example Such diffs will be applied by patch(1) (al...

mas.to

February 6, 2026 at 10:22 AM

beat

@beathagenlocher.com

OAuth Playground

#OAuth #PKCE #Learning #Auth

Now that it's working again (I couldn't access it some days ago), OAuth playground is just a pretty nice way to understand code flows in Auth.

February 5, 2026 at 5:11 PM

beat

@beathagenlocher.com

#HTML #TheWeb #TIL

Today I learned there was a `name` attribute in HTML once.

February 5, 2026 at 12:57 PM

beat

@beathagenlocher.com

Okay, I get the hype: npmx.dev is pretty cool.

npmx - Package Browser for the npm Registry

A better browser for the npm registry. Search, browse, and explore packages with a modern interface.

npmx.dev

February 5, 2026 at 11:03 AM

beat

@beathagenlocher.com

Which brought me to write about Dynamic Scoping, too :)

#Racket #Lisp #ProgrammingLanguages #LexicalScoping

> Lexical Scoping refers to when the location of a function's definition determines which variables you have access to. On the other hand, Dynamic Scoping uses the location of the function's invocation to determine which variables are available.

```racket title=dyn-scope.rkt
#lang smol/dyn-scope-is-bad

(defvar y 2)
(deffun (times-2 x)
(* y x))

(let ([y 3])
(times-2 2))
(times-2 2)
```

Evaluation:

```racket
6
4
```

Well, this is bad.

<References>
<ReferenceLink href="https://youtu.be/b1MvKYHCdno?si=O6qEgfY2QtH_HtqG&t=2330">Programming Languages Lectures</ReferenceLink>
<ReferenceLink href="https://www.plai.org/3/2/PLAI%20Version%203.2.2%20printing.pdf"><KB>Ctrl+f</KB> for 'dynamic scope'</ReferenceLink>
</References>

February 5, 2026 at 11:02 AM

beat

@beathagenlocher.com

Inspired by my TypeScript macro finding yesterday, I started a note about Macros :)

#Lisp #Racket #Emacs #Clojure #DSLs #CommonLisp #Rust

The idea is pretty simple:

We write code, and sometimes we repeat ourselves there. So why not write code that abstracts over this repetition?

That is what _Macros_ are.

# C Macros

The lowest sophistication level (and the worst to work with) is something like C preprocessor macros. There, you do the easiest thing possible: A string replacement over the full following program text, irrespective of anything else.

So a Macro in C has this type signature:

```haskell
CMacro :: String -> String
```

---

```c title=simple.c
#define LALA "hohohoho"

char laugh[] = LALA
```

->

```c title=simple.c
char laugh[] = "hohohoho"
```

A standard C Macro usage looks like this:

```c title=min.c
#define min(X, Y) ((X) < (Y) ? (X) : (Y))
x = min(a, b); → x = ((a) < (b) ? (a) : (b));
y = min(1, 2); → y = ((1) < (2) ? (1) : (2));
z = min(a + 28, *p); → z = ((a + 28) < (*p) ? (a + 28) : (*p));
```

But since this is just doing straight string replacement, anything can happen (There's just no rules whatsoever for the expansion, so you can have unbalanced parentheses and other weird stuff).

They're still powerful, and you probably want to use them in C, but we can do better.

# Lisp Macros

Lisp Macros do better: They're not doing string replacement, but operate on the _syntax tree_.

```haskell
LispMacro :: Syntax -> Syntax
```

The also have a second pretty helpful property: They use _the same syntax as the base language_.
So their type is actually this:

```haskell
LispMacro :: LispSyntax -> LispSyntax
```

This is what they look like:

```lisp
> (defmacro the-macro (a b)
`(+ ,a (* ,b 3)))

> (the-macro 4 5) ;; => 19
```

This makes them way more generally useful (for example)

But they, too, have a problem: They're not _hygienic_.

That is, they're introducing variables into their target program that could be referenced both from the inside and outside.

This possibly couples the macro source code to the location it's being used in, which, if you squint, is the one unambigiously bad (default) feature in programming languages (again): Dynamic Scoping

There's an easy fix for this, however: gensym

But this makes for a relatively bad default, and we shouldn't rely on programmers knowing all the ways in which they could fuck up, and then having the mental workload left to fix them.

<Draft>

# Scheme Macros

Scheme was the first language that didn't have the problem of accidental scope leaking. They introduced _hygienic macros_.

# Racket Macros

Racket escalates this completely, and has facilities to define whole new languages.

</Draft>

# Notes

- I've skipped procedural macros#Procedural_macros) (never heard of them before)
- Damn, are those AI Memos badly scanned sometimes: https://dspace.mit.edu/bitstream/handle/1721.1/6111/AIM-057.pdf?sequence=2&isAllowed=y

February 5, 2026 at 10:58 AM

beat

@beathagenlocher.com

TypeScript Macros

#TypeScript #Macros #FunctionalProgramming #Immutable.js

$Today I've been playing around with Immutable.js as a library that supplies immutable collection for JavaScript and TypeScript. Something that's relatively annoying at first sight (cause _verbose_) is how they handle typed Objects (_Records_). I'm not completely sure yet, but I _think_ in TypeScript you want to declare sums of products using those records something like this: ```js import { Record } from 'immutable' type IdleT = { kind: 'Idle' } type Idle = Record<IdleT> const Idle = Record<IdleT>({ kind: 'Idle' }) type TrackT = { id: string; url: string; title: string } type Track = Record<TrackT> const Track = Record<TrackT>({ id: '', url: '', title: '' }) type LoadingT = { kind: 'Loading'; track: Track } type Loading = Record<LoadingT> const Loading = Record<LoadingT>({ kind: 'Loading', track: Track() }) // .. export type State = Idle | Loading // | .. ``` This is, compared to ```js export type Track = { id: string; url: string; title: string } type Idle = { kind: 'Idle' } type Loading = { kind: 'Loading'; track: Track } // .. export type State = Idle | Loading // | .. ``` quite the feat syntax-wise. It can be alleviated a bit by doing something like this: ```js export const makeRecord = <T extends object>(defaults: T) => Record<T>(defaults) const Idle = makeRecord({ kind: 'Idle' as const }) type Idle = RetureType<typeof Idle> ``` But even that is still double the code and more mental workload payed as a price for immutability. So I wondered: > Are there people writing Macros in TypeScript? And as it turns out, there are: - ts-macros - macro-ts But nope, I'm not gonna use them.$

February 4, 2026 at 11:42 PM

beat

@beathagenlocher.com

selfhostblocks

#Clan #NixOS #Selfhosting

Today, I lurked a bit around the on the clan gitea, which made me find this nice PR trying to nail down a better clan positioning in the future, which made me find selfhostblocks.

Cool!

(Though I'm pretty convinced by clan so far)

February 4, 2026 at 10:31 PM

Reposted by beat

Fight Chat Control

@fightchatcontrol.bsky.social

The European Commission continues to push to extend Chat Control 1.0, threatening your fundamental right to privacy. MEPs on the Civil Liberties Committee (LIBE) need to hear from you directly: fightchatcontrol.eu now allows you to contact them all at once. Speak up today!