• 0 Posts
  • 39 Comments
Joined 2 years ago
cake
Cake day: June 30th, 2023

help-circle
  • Been using Nix for just over a year.

    Seconding to go with flakes. No idea wtf channels are or whatever the previous system was.

    Documentation can be confusing due to changes in paradigms. The bare “nix <scope>” seems to be the most modern oppose to “nix-<scope>” (e.g., nix store vs nix-store). That said, not every feature can be found in the newer variants.

    This can make following tutorials difficult if they aren’t using the same paradigm.

    Getting comfortable with the nix language will be helpful. Its a functional programming language, which is very different than languages like bash.

    Not everything has to be done the nix-way. My nvim files are in the same repo, but I just outOfStoreSymlink them instead of wrapping them in a derivation.

    Some useful packages I like not already shared.

    Disk partitioning: https://github.com/nix-community/disko

    Immutable: https://github.com/nix-community/impermanence - Pretty much resets the system to a new install every boot. Discourages manual tweaks via sudo as they get wiped out. You can still mark certain directories to be persistent (logs, personal documents, steam games, etc.).

    Nvfetcher: https://github.com/berberman/nvfetcher - Nix has a concept of overlays. You can pretty much override anything with .override (module args or inputs) and .overrideAttrs (module attribute set or outputs). Nvfetcher helps with checking different sources so you can override a packages src attribute. Why is this useful? So you can install any version you want and are not bound to nixpkgs. That doesn’t mean the install script in nixpkgs will always work on newer versions, but those can be overridden as well if needed.

    Note that disko, impermanence, and nvfetcher all have a flake.nix in the root of the repo. Those provide ready to go overlays so you don’t have to deal with writing your own which is really nice if you want to latest version without much work when available.


  • Toooo real. Its like companies have taken the worst of everything and just call it agile. List out every task and estimate them so we have timelines, but don’t actually architect anything as that’s waterfall. Fake waterfall, with fake dates, but fingers will be pointed like they were real commitments, and spend a month doing it for this executive power point instead of fucking off so devs can build the damn thing.



  • I’ve been screaming its just wage theft. My city provides tax breaks for occupancy (employees prop up the local economy buying lunch). They are making me pay for gas, time, and car maintenance (and lunch but fuck them, I’ll just not eat) for this tax break which goes to C-level bonuses/shareholders. Its just another way of skimming off the top of employee wages.

    We worked fully remote for nearly 2 years and the hybrid policy just keeps getting worse and worse. Coupled with quarterly riffs, I also suspect this is to avoid severance pay/unemployment while accelerating the down sizing. Yet our CEO bonus keeps going up and up despite our stock plummeting since the end of COVID lock downs.



  • I love nix. I started on flakes and have no clue what configuration.nix, channels, or nix-env even are.

    Its pretty much a toolchain to orchestrate a bunch of community bash scripts with some (optional) syntax sugar to do most things right in nix.

    Scripts break. So did my own when I left the sandbox of any other distros curated version set. Now its version controlled and I can rollback.

    Functional programming skills are helpful. The documentation is shit. Like really really bad. I had to go through a few lib/ src to figure out modules. It just wasn’t clicking until I did with the abstractions until I looked at the code.

    I mostly search GitHub now a days for solutions with lang:nix and some tokens I know I’ll need and analyze what someone else did.

    I look at the source for package defs often.

    The repl can be handy.


  • I haven’t tested in Windows, but this is my setup Linux to Linux using rclone which the docs say works with Windows.

    Server

    • LUKS
    • LVM
    • Volgroup with a mishmash of drives in a mirror configuration
    • Cache volume with SSD
    • BTRFS /w Snapshots (or ZFS or any other snapshotting FS)
    • (optional) Rclone local “remote” with Crypt if you want runtime encryption at rest and the ability to decrypt files on the server. You can skip this and do client side only if you don’t want the decryption key on the server.
    • SFTP (or any other self-hosted protocol from https://rclone.org/docs/)

    Client

    • Rclone Config /w SFTP (or chosen protocol)
    • (optional) Rclone Config /w Crypt
    • Rclone mount with VFS.

    I use this setup for my local files and a similar setup to my Backblaze B2 off site backups.

    The VFS implementation has been pretty good. You can also manually sync. Their bisync I don’t fully trust though.

    I can access everything through android using https://github.com/newhinton/Round-Sync. Not great for photos though as thumbnails weren’t loading without pulling the whole file last I tested a year ago.




  • but I am using it not in the way it’s intended

    This is absolutely intended. Nix is a programming language, package manager, and operating system.

    Nix the package manager is intended to be used on nixos and non-nixos operating systems. It has first party support for Darwin (macOS).

    My nixos build is not daily driver ready, so I’m still on Ubuntu for my productivity systems. The majority of the Ubuntu apps I use are managed via nix using home manager at this point. These share the same configurations with my nixos systems.

    It is relatively low risk* since nix installs everything in /nix/store and sets up some env vars and user systemd services with symlinks to map to there. If I install Firefox with nix, the Ubuntu version is still there untouched. My PATH just hits nix first before the system. You have to change like one file if I’m remembering correctly after uninstalling if you want to back out which is the trigger for a nix package to come before a native package.

    • If you dip into declarative app configs (zsh, fish, nvim, etc.) you can absolutely lose the original. I tracked all that in a dotfiles repo before nix personally. Just have backups and start small.


  • If I had used a flake, I could have isolated that dependency from the rest of my build, while still tracking its integration with my system.

    I have to do this weekly with my bleeding edge Hyprland setup.

    I’ve been using nvfetcher to feed my nightlies addiction for software that doesn’t have a flake.

    Only major hiccup I had was pulling a few packages from nixpkgs master due to a bug that got introduced in unstable for electron apps before it hit cachix. Wasn’t expecting it to take a day to compile everything that depended on it.

    10/10 would highly recommend flakes.


  • It doesn’t have to be an all or nothing approach. I wanted to switch to Nix but got lost way in the weeds with declarative partitioning, immutable OS with impermanence and snapshots, fucking coding my own gnome shell with AGS/Astal for Hyprland, and making overrides for bleeding edge software updates from GitHub.

    Realising it was going to be a hot minute before I had a daily driver OS, I started using Home Manager on my Ubuntu daily drivers and installing NixOS on some spare hardware to tinker with.

    The majority of the apps I use are now managed through Nix the package manager on all my Linux systems.

    I do use flakes and what’s installed on Ubuntu is managed with the same files as my NixOS builds. So far I’m really happy with it.



  • One method depends on your storage provider. Rsync may have incremental snapshots, but I haven’t looked because my storage provider has it.

    Sometimes a separate tool like rsnapshot (but probably not rsnapshot itself as I dont think its hard links interact well with rsync) might be used to manage snapshots locally that are then rsynced.

    On to storage providers or back ends. I use B2 Backblaze configured to never delete. When a file changes it uploads the new version and renames the old version with a timestamp and hides it. Rsync has tools to recover the old file versions or delete any history. Again, it only uploads the changed files so its not full snapshots.



  • Important stuff (about 150G) is synced to all my machines and a b2 Backblaze bucket.

    I have a rented seed box for those low seeder torrents.

    The stuff I can download again is only on a mirrored lvm pool with an lvmcache. I don’t have any redundancy for my monerod data which is on an nvme.

    I’m moving towards an immutable OS with 30 days of snapshots. While not the main reason, it does push one to practicing better sync habits.