I look at the number of (hopefully recent) committers and whether they’re human or not.

It was surprisingly common, though due to the cost of buying tapes, it wasnt as common as it is now.

VHS tapes have this nifty feature where you could store video on it in 3 different formats. While the tape from the rental place was stored in the format that fit roughly 2hrs on a tape, you could record three 2hr movies to a tape if you used the lower quality EP format (I think that was the acronym).

This lead to people like my friend’s dad keeping shelves of tapes with hastily scrawled labels on them for 3 different movies or 6 different episodes.

All you needed for any of this was 2 VCRs, which from the early 90s were pretty affordable.

That was a frustrating read. Dude gets screwed by Microsoft who effectively steals his code and rebrands it as theirs and then he goes on to talk about why he prefers MIT.

That’s understandable, though one of the other commenters suggested the LGPL which might make for a good fit for your case. Here’s a comparison with the other two if you’re interested.

The AGPL is just the GPL with extra rules requiring sharing the code even if you expose it exclusively via a service.

Ooh, yes for for this case, the LGPL would be a good middle-ground for OP’s concerns.

A simple comparison between the two via interoperable-europe.ec.europa.eu says that they’re almost identical save for one clause around trademarks:

https://interoperable-europe.ec.europa.eu/licence/compare/BSD-3-Clause;MIT

But I’d be remiss if I didn’t advocate for a license that better protected your project from corporate theft. The AGPL and GPL are excellent licenses that protect your work and that of the community from companies that would copy it, improve it exclusively for themselves and then ship your work exclusively in binary form:

https://choosealicense.com/licenses/

I suppose the most important thing to have post-apocalypse is a copy of Wikipedia.

You might want to look into Gemini (not Google’s “AI” offering, despite the name). It’s an internet protocol for sharing text-only communication. There’s a whole community out there working with it.

I’ve been using the FOSS version of Kvaesitso and I quite like it.

I’ve had a really hard time figuring out how to get cloud native pg working 'cause I couldn’t get longhorn working for disk space.

So instead I went with a separate Raspberry Pi that isn’t part of the cluster to host a single Postgres instance.

It’s inelegant, but has worked for years. Still, I’d rather host a separate pg instance for each project… I just have to figure the above out first.

Neat project, but it appears to be using (L)GPL code in a bunch of places while being licensed under MIT. That’s a big no-no.

#Solarpunk!

Wow, Markdownr is fantastic! Thanks for sharing!

I couldn’t abide such a wall of text, so I reformatted everything into a Markdown table:

Cool stuff! For future projects, you might want to check out Typer, as it’d save you a bunch of the boilerplate and supports things like tab completion too.

Don’t do it. AI makes you stupid, and using it for school is counterproductive.

My girlfriend’s dad had hundreds of movies on VHS, pirated from cassettes he’d rented in the past and copied at home by chaining two VCRs together over coaxial cable.

Software was wild pre-internet. My buddy had Windows 95 on 42 3¼" floppies that we copied onto additional sets of 42 floppies that we kept in heavy boxes and then painstakingly installed onto computers belonging to friends and family around the neighbourhood.

I also had a whole bunch of audio cassettes that contained music I dubbed from radio, other cassettes, and later CDs (burning your own was at first, impossible, and later, expensive).

I’m 46.

I’ve used FluxCD in the past and have looked into ArgoCD, but honestly, I’ve not seen any big benefit from either to be honest. I use k8s both at home and at work, and in both cases, we do “imperative” deploys: you run helm install ... either directly or via the CI and stuff is deployed.

So for example at my last job, our GitLab CI just had a section triggered exclusively for merges into master that ran helm install ... for all three environments. We had three values.yaml files, one for each environment, and when we wanted to deploy a new version, the process was:

1. Create a tag for our release version (ie. 1.2.3) and push it to the repo. This would trigger a build and push the resulting image into the container registry.
2. Push an update to the repo with the new tag set in the appropriate Helm values file. If we wanted to deploy 1.2.3 to development but not yet to staging or production, then the tag: value in each of the environment files would look like this:

• k8s/chart/environments/development.yaml: tag: 1.2.3
• k8s/chart/environments/staging.yaml: tag: 1.2.2
• k8s/chart/environments/production.yaml: tag: 1.2.2

Once that change is pushed, the CI will automatically apply it with helm install ... and make sure that all three environments are what they’re supposed to be.

As for dependent services, that should all be in your Helm chart so they’re stood up and torn down together. The specific case you mention about “Service A” being dependent on “Service B” but stood up before “Service B” is ready is a classic problem, but easily solved:

The dependent service (“A” in this case) should have an entrypoint that checks for everything else before starting. Here’s what I’m using right now in a project:

#!/bin/sh

while ! nc -z "${POSTGRES_HOST}" 5432; do
  echo "Waiting for postgres..."
  sleep 0.1
done
echo "PostgreSQL started"

touch /tmp/ready

exec "$@"

I’ve even got some code that checks that all the Django migrations have run first for the same situation. The Kubernetes philosophy is that any container should be able to die at any time and be eventually be brought back up and that every container needs to be prepared for this. Typically this means that your containers should operate on the basis of “if I can’t work, die, and hope the problem is solved by the time Kubernetes redeploys me”.

Kubernetes. For a homelab, the stripped-down k3s is fantastic and surprisingly easy to get going.

Once you’ve got Kubernetes set up, you can lean on all the many tools already out there for things like deploying complex projects (Helm) and monitoring (Prometheus/Grafana). OpenLens is a nice piece of software you can use to monitor and control your cluster too, as is k9s.

I’ll just leave this here.