…except I can run Docker anywhere. It’s not tied to systemd. These quadlets seem like a very systemd-specific thing. Which is great if you’re building everything around systemd but it’s a niche.

How does Bottles know to install VC redistributable or .Net and other stuff kind that?

Yes, storing each backup in 2+ places is best.

You can of course automate it. If you’re running backups from Linux use anacron rather than cron because anacron tries to run when it can (when the machine turns on), whereas cron doesn’t run again if the machine was off when it was time to run.

rsync is the most straightfoward solution. Pros: it won’t copy files again if they haven’t changed; it can copy remotely over ssh. Con: it has a bit of a learning curve.

BorgBackup would be my next recommendation, it takes distinct backups but doesn’t duplicate files between them. It has compression, encryption (optional) and you can run checks on the backups. Con: for remote use you need to run a borg server on the target machine. Another potential con is that it doesn’t store the files in a directly usable format like rsync. Borg archives are similar to a zip archive – you can list the files, you can extract them, you can even mount them somewhere and then access the files directly – but you can’t access them directly without borg.

At the end of the day it’s always a trade-off. If you’re willing to give up some control and privacy Plex is going to be a very smooth experience. If you don’t like to give up privacy but still want a smoother experience and are willing to pay, Emby is probably best for you. If you don’t want to make any privacy compromises and want a free, community-supported and fully open-source solution, you have to use Jellyfin.

Don’t forget to check out Kodi on that list. It’s not a media server, it’s an indexer that runs on the client + a friendly interface. It can be a very nice solution if you mainly access your media on a single device, like a living room TV attached to your NAS.

Jellyfin or Emby, yeah. But it’s more of an artificial limitation for Plex so it’s worth checking that they haven’t fixed it by any chance since the last time I tried.

The way these apps work is that the mobile app scans the local network for the server. That works when you’re connected on WiFi at home but typically not when you’re connecting over VPN, because a VPN isn’t usually configured with broadcast. So the app for all three (Plex/Jellyfin/Emby) will discover the server just fine on WiFi but choke on VPN. To work around this, the mobile app [should] allow you to also enter the server address manually. Plex used to have this too but removed it at some point, so now it only relies on autodetect. 🤷

So now the only way it can work on Plex is if you keep the same server address/name when you’re on WiFi and when you’re on VPN, let the app detect it once on WiFi, then it “just works” on VPN too… but that can be problematic if the address/name is different on VPN, which is 90% of cases.

Between Emby and Jellyfin it’s a toss-up, the main reason I’m using Jellyfin (I used to use Plex and Emby too) is because it’s 100% free. Emby switched essential features like transcoding behind paywall at some point, and Plex locked pretty much everything useful behind paid Plex pass and you have to login to their website every time, so you can’t use it if your external internet connection drops even if your local network is fine.

Here’s an in-depth comparison of all three: https://github.com/Protektor-Desura/Archon/wiki/Compare-Media-Servers

I ran into Droidcam during the pandemic when I needed a webcam and you could not find a decent one anywhere (or it would cost an arm and a leg). It works over USB or network, and it can connect two ways (phone can connect to PC or PC can connect to phone) so you can connect it over Internet or over VPN (like Tailscale). The PC app can work without a GUI so you can install the app for example on an old phone, connect it to power and use it as a surveillance camera too.

Yep. DroidcamX.

If you use a backup solution that does incremental/deduplication you can probably replace the monthly tarball with a monthly deduplicative backup.

Tarballs are useful in repetitive backups, like for example long term archiving to optical media (burning Blu Rays).

Plex has issues with VPNs unfortunately. It wants you to go through them whenever you connect to your server, and this means it needs to know where your server IP/domain is. But if you have situations where the IP/domain changes, like a VPN, it can get confused.

It’s one of the reasons that made me give up Plex back in the day. (Holding your accounts hostage was the other one.)

Usually yes! There will be some minor overhead from both nodes keeping in touch with the Tailscale command server but mostly they talk to each other.

Read this though to see if there’s a case where direct connection might not be possible: https://tailscale.com/kb/1181/firewalls/

I’ve recently looked into this too. I’ve settled on Calengoo as Android calendar app because it has a ton of customization options and can do both events and tasks in the same app. But it depends on GSF (Google Services Framework); if you intend to keep your Android phone completely Google-free it may not work (no idea if it works with MicroG as a GSF substitute). Calengoo can use Android calendar to sync (via DAVx5 or CalDAV-Sync), but can also connect directly to a CalDAV server.

Simple Calendar does not rely on GSF so it doesn’t have this problem.

Another app I found that works without GSF is Business Calendar from Appgenix (the old version 1). The free one works fine, they also have a Pro version if you’d like to contribute. Version 2 requires GSF unfortunately. Neither of them support CalDAV tasks, only events.

The bulk of the traffic between two Tailscale nodes is direct between the nodes. They mainly use the Tailscale servers to help them find each other (NAT hole punching) and establish a connection.

I use the daily/weekly/monthly pattern for machine backups:

• Use a rsync job to copy whatever you deem important from the target machine to a backup dir. Run this once a day.
• Once a week, sync the daily dir to a weekly dir.
• Once a month, take a snapshot of the weekly dir as a tarball.

In addition to that I use Pika Backup (it’s a very user friendly GUI for Borg) to make incremental backups of the monthly dir to a couple of external HDDs.

Around here any taxi driver can have their rating on the online app reset to 5 stars for $50 whenever their want.

Taxis also use a platform to function. They have radio dispatch, they rent cars to drivers, they have digital platforms with online orders.

Taxi companies traditionally stiff their drivers out of benefits too, and are typically in bed with local administration and politicians so they never get called out on it.

Their online platforms have ratings you can’t rely on, there’s fake cabs, fake meters, ghost drivers, cash only, angry drivers, dirty and broken cars, aggressive and unsafe driving etc.

So if your point is that taxi companies will fill back the demand after Uber is gone that’s true, but it won’t change anything for the drivers.

In fact many of the Uber drivers will be permanently out of the picture because they’re not pro drivers and are not familiar with the more cut throat taxi business.

Shh, what part of “secret” don’t you understand?

But you need to pay for a VPS to use Headscale behind NAT. If you’re already paying for VPS it makes sense to use Headscale. But if you don’t then you have to consider the price of a VPS vs Tailscale’s free plan. Even if Tailscale eliminates that free plan, as long as they keep it around $4/mo they will still be a better option than a cheap VPS – assuming, again, that you don’t have a VPS and the only reason you’d get one is for this purpose.

Is it that hard to setup Wireguard or OpenVPN?

TLDR: Unequivocally yes.

I’ve managed to eventually establish a two-point OpenVPN link after reading a lot and fiddling with two dozen settings in both the server and client. I can now generate keys for clients, wrap them into .ovpn files and can get people connected to my server.

However:

• It only works because I get a public IP from my ISP. If that ever stops, this solution stops working too.
• People can only access that one server, and only from the one device they run OpenVPN on. After many hours of reading I have no fucking idea how to expose more devices in my LAN to the client side, how to connect more devices in their LAN to my server, or how to use my server as an exit point towards the larger internet for the clients. I’m sure that with some more reading and experimentation I could figure this out. I have basic networking knowledge but this goes above basic. I hope I won’t have to get a CCNA for it.
• It’s still only a two-point link. If I want to connect more points I have no idea where to begin allowing them to see each other, and if they need to connect to each other it won’t be optimal to go through my server anyway. But setting up and running OpenVPN on each device and distributing keys from each device to every other device would get old very fast anyway.

If you think that’s hairy, I hear that WireGuard is even more complicated to set up than OpenVPN.

With Tailscale I install one thing on each device and run one command (or tap a checkbox on Android/iOS). It gives me a link to open, to enroll that device. And that’s it. It works.

Not only does it work but it comes out of the box with:

• All enrolled devices see each other. It has already established an everybody-to-everybody private mesh network.
• I don’t have to manually manage any keys.
• Connections between any two devices benefit from direct connection speed between those devices.
• Those tricky scenarios where I want to expose LAN devices or use a device as an exit node? It’s one parameter (or one checkbox on mobile clients) and one approval in the control panel, then it just works.

Edit: Yes I know I can use Headscale on a VPS to achieve something very similar to Tailscale. Leaving aside the need for VPS, and while I’m thankful that WireGuard exists and that Headscale is keeping Tailscale honest, and while fully acknowledging my hypocrisy, I’m still going to be a cheap lazy asshole and use Tailscale and get a free ride until Tailscale starts charging. At which point I will weigh their offer against the cheapest VPS out there and either keep using Tailscale or start using Headscale unapologetically while eating crow from all the people shouting “told you so!”. Or maybe I’ll get a CCNA and finish setting up OpenVPN, we’ll see.

And I would die of old age waiting for the compile to finish.

Swap is not “disk RAM”. It’s used for storing pages that go unused for extended periods of time. It’s an optimization system designed to be used during normal system operations.

Technically it could solve some mild out-of-memory situations if given enough time but in practice the disk access is so slow compared to RAM that for all intents and purposes your system appears to freeze so you get bored eventually and reboot it. An attempt to compile a large application under these circumstances would last a very long time indeed.

If anything, you should disable swap in such a situation. Without swap the compile process would crash instantly when growing out of memory, with swap your system freezes.

Swap space is also used for storing a compressed dump of RAM during hybernation but that’s a special case.

when you install a program files are placed in many random places, like /usr/bin, /usr/lib

That’s because back in the day those had some good logic. On mainframe systems you had to be able to split files by how crucial they are too keeping the system alive, so you’d mount something like /bin locally but you could mount /usr/bin remotely and still keep the machine running if the connection was lost. And so on and so forth.

Nowadays we really should revise the Filesystem Hierarchy Standard but it’s required by the UNIX compatibility and it’s baked into so many things that you wouldn’t believe.

I remember back in the 2000s the were distros like GoboLinux that tried to reorganize the files with criteria relevant to a modern machine but it didn’t catch on in the Linux world. However Apple did it for Mac OS.