In my perspective it's not that complicated. I'd like to have a good life and I would like for every other human on the planet to also have a good life sustainably. I think it's a rather optimistic vision.

Also an unrealistic one. A lot of hard work is necessary for that. Most people don’t want or can’t do that work.

NixOS does enables this to a degree, for example with nixos-mailserver[0)].

It would be nice if it could enable people with little sysadmin experience to self-host easily, but right now the bar for using NixOS and configuring these projects is still pretty high. Still, with enough work I imagine it could be possible.

[0] https://gitlab.com/simple-nixos-mailserver/nixos-mailserver

Curious, I just learned about hash rings last week when setting up the ironic openstack service [0].

[0] https://docs.openstack.org/ironic/latest/_modules/ironic/com...

Another CalDav server I can recommend is Radicale. It's written in python and designed in a pretty modular way, enabling authentication and authorization (and more) plugins.

Data is saved in plain text files and I track/backup it using git.

Over the time I've accumulated some interesting modifications:

- Authentication runs with pam on the host system.

- To enable sharing of calendars I run a periodic script symlinking the calendars to all authorized users. Unfortunately this suffers from combinatiorial explosion.

- Using a rights plugin with custom CalDav Attributes and a modified web plugin I added support for access Control Lists.

- To enable public calendars you give read permissions to the `public` user using ACL. Then a nginx hack gives blanket acces for read operations:

  location /public {
      proxy_pass http://127.0.0.1:{%RADICALE_PORT%};
      include proxy_params;
      proxy_set_header Authorization "Basic {%RADICALE_PUBLIC_AUTH%}";
      proxy_hide_header Authorization;
      add_header Access-Control-Allow-Origin * always;
      add_header Access-Control-Allow-Methods "GET, OPTIONS, PROPFIND";
      add_header Access-Control-Allow-Headers "Depth";
      limit_except GET OPTIONS PROPFIND { deny all; }
  }

These public calendars are can be viewed on a web calendar (https://gitlab.nomagic.uk/popi/js_calendar_from_ics)

I should probably write a blog post about the setup.

Let us know when that blog post goes live… ;)

Yup, also interested in that. I have a half broken home cooked software that is basically radicale x monica crm that I would like to phase out for something better.

This. Have been using Radicale for years. Except occasional issues with BusyCal it's been a very smooth ride.

I really like quadlets as they enable using containers like normal system services. That said the UX for rootless containers does not play well with this conceptualization.

Normally system services run as system users in the system systemd-session, but for rootless containers the services reside in the user systemd sessions of the system user. I'd love to be able to run rootless quadlets within the system session.

Is there any effective difference by enabling user-linger and running rootless via user systemd? That's what I've always done.

I used to do that but I find the UX of that quite annoying because before you can do: systemctl status and see what's up with all the system services. Now you have to do systemctl status -M <user-for-that-stack> for every stack that you're running to get a complete picture.

I haven't found a way around that and would be very thankful for pointers.

> I'd love to be able to run rootless quadlets within the system session.

Likewise. I'd also like to be able to run rootless quadlets with the DynamicUser= option. DynamicUser= has been a great way to restrict privileges for system services, and it just doesn't fit with podman right now.

In my observation something paradox happens when teachers use LLM-Detectors to fail their students on dubious detection probabilities.

The teacher accuses the student of using the LLM to perform the task they are assigned. This entails not properly understanding the assignment and presenting an accomplishment which has not been achieved by the student themselves.

On the other hand the teacher using an LLM tool also do not understand the reasoning of the decision and present often present them as their own judgement. A judgement that has not truly been felled by the teacher because they do not use the tool for understanding but for deferring their responsibilities.

In doing so the teacher is engaging in the same act of (self-)deception they are accusing the student of: presenting an achievement not truly reached through their own understanding, even if the situation necessitates it (non-deferrable learning vs. non-deferrable decision).

The use of LLM-detection in this way thus mirrors the very problem it seeks to address.

Unfortunately the essays of your students can not be found on gutenberg.org. You have to try evaluating only the text and it's context to guess what's LLM-generated.

Location: Berlin, Germany

Remote: Yes

Willing to relocate: No

Technologies: Python, Javascript, Rust, Julia, HTML/CSS, Linux Sysadmin, SQL,...

Résumé/CV: https://finn.krein.moe/CV.pdf

Email: finn@krein.moe

I'm a recently finished physics MSc and worked as a Linux sysadmin during my studies. I'm interested in software development and system administration/DevOps and love learning new things.

The first thing that comes to my mind is a quantum state of 36 qubits represented in 64-bit complex floats.

The first thing I thought of was a pile of 3 million 360KB floppies.

In this case I think it is important to distinguish nix (the package manager) and nixpkgs (the popular package repository / distribution used with nix).

Packaging python applications with nix is doable, but you have to specify the exact versions of your dependencies and for that you can't easily use nixpkgs.

Nixpkgs tries to keep a minimum number of packages (like Arch or Debian as well), so each of the dependencies will typically only occur with one minor version for each release of nixpkgs.

We could still use the nixpkgs to build our application but we have to override each of our dependencies to the right version, but that approach can get quiet tedious for a large number of dependencies.

Fortunately there are tools to automatically generate your dependencies from a requirements.txt such as mach-nix or pip2nix.