so get an anonymous pre-paid number

That’s not something that exists in many countries. SIM-cards have to be attached to a real world identity by law.

Why is that a problem?

Why are you posting as [email protected] and not <real name>@<home address>?

OK, well buy a burner SIM card

Illegal in many countries. SIM cards are attached to your real world identity.

Multiple-accounts and pseudonyms. It’s like the 101 of interacting on the Internet. With a phone number requirement that’s automatically made impossible.

Also SIM-cards/phone numbers are required by law to be attached to your real world identity in many countries.

The crux is that all the alternatives suck. I don’t have a problem going App hopping, I just have a very hard time finding ones that don’t fundamentally suck, and I am not talking about little implementation issue, but garbage like Signal that violates the GDPR, wants your phone number and is proud of it. Always grinds my gears when that gets celebrated as the “alternative”. Same with the Fediverse, where user owns nothing and server operator controls everything, how again is that different from Reddit, Facebook and Co.?

Nostr and Tox seem ok so far, but really the amount of true alternatives that improve on the original in significant ways is pretty damn rare.

You prefer:

     (add-after 'install 'remove-examples
       (lambda* (#:key outputs #:allow-other-keys)
         (with-directory-excursion
             (string-append (assoc-ref outputs "out") "/lib")
           (for-each delete-file
                     (list
                      "basic-server"
                      "helloworld"
                      "postcollector")))

over:

postInstall = ''
   rm  $out/lib/basic-server $out/lib/helloworld $out/lib/postcollector
''

?

The two main advantages of Guix are the language

I wouldn’t call that an advantage for the average person. Nix is far nicer to work with. Some Lispers might disagree, but I, for one, can’t exactly see the beauty in trying to turn Scheme into a configuration language with macros and hacks. Also Guix puts Scheme everywhere, things you can do with plain old Bash in Nix, you’ll have to all do in Scheme in Guix, so there is a much steeper learning curve.

The biggest problem with Scheme as config language is that it is sloooooowwwww. Nix is already quite sluggish when it comes to configuration changes, in Guix it’s a lot worse, and it’s unlikely to change anytime soon, given that Scheme allows macros and other hacks that might make it difficult to properly cache or index the package database.

Any advice on what should I do would be welcome.

You can play around with the mount option nofail, if that’s set, systemd will not wait for the mount point to be ready and continue booting normally. Can be useful with HDDs that take a while to spin up and aren’t needed for the boot process (e.g. backup drives, etc.).

Another thing to look out for: SDCards or USB flash drives that might randomly fail to “spin up” and hang, unplugging those helps.

journalctl is the one part of systemd I really do not like. For whatever reason, it’s insanely slow, taking multiple seconds before it gets around to display anything. It also has all the wrong defaults, displaying error messages from a year ago first, while scrolling to the bottom again also takes forever and consumes 100% CPU while doing so.

There are flags to filter and display only the relevant parts, but not only are none of them intuitive, doing a mistake there just gives you “-- No entries --”, not an error. So you can never quite tell if you typed it wrong or if were are no messages.

Maybe it all makes more sense when studying the man page in depths and learned all the quirks, but /var/log/ kind of just worked and was fast, without any extra learning.

We went from boring beige PC cases, that looked rather boring and were in dire need of some stylish upgrades, in the complete other direction and overshot the target by a mile. I find most modern PC stuff incredible ugly and impractical. Even just finding a tower that still has a 5.25" slot took effort, since most don’t even have them anymore. The whole idea of transparent windows on your case or putting your PC on the desk instead of below it, is complete nonsense, especially when you don’t even have room for swappable disk drives. The good old desktop PC at least went under your monitor, but modern PC cases don’t even do that.

I am kind of surprised, despite all those decades of PC gaming, we still don’t have gaming PCs as compact as a Playstation/Xbox. They do exist, e.g. the old Alienware Steam Machine was tiny, but they are far from common place and often either underpowered or overpriced.

You can manage multiple machines with a single Nix configuration git repository and modularize the configuration as much as you want. You can have a config with a desktop environment that you skip on servers, override individual variables for a specific host or do whatever you want. You can even remote deploy it all with a simple nixos-rebuild build --target-host "user@host" and it works across different architectures too (e.g. build on your fast x86 machine and deploy to a slow RaspberryPi).

That is something you can’t quite escape in Nix either. While it doesn’t use parenthesis like a Lisp, the nature of the language and the depths of the sets you are dealing with still makes you end up getting a lot of this at the end of your files:

        ];
      };
    };
  };
}

Having one } too many or too few is a pretty common issue with Nix and feels very similar to Lisp, even when the rest of the language is quite different.

While some people love putting Lisp in everything, I really don’t get it. Guix is far uglier than Nix in the language department. Scheme is not a configuration language and thus has none of the nice things that Nix has (multi-line string handling, defaults, lazy evaluation, inline expression, etc.), instead you get multiple levels of macro spaghetti. Furthermore, Guix forces you to turn everything into Scheme, where you can just use plain Bash in your Nix build steps, in Guix that is all Scheme.

I had spent a lot of years with Scheme before starting with Guix and then spend quite a few years with that, but even after all that switching to Nix just felt so much better instantly. Instead of trying to hack a DSL onto of Scheme you just get a language that’s actually build for the task.

Where are the source packages?

It’s reproducible, so random updates are a no-no. You can however just dump the Git URL in your flake.nix inputs and then override the src of the package with that. The source gets updated when you do nix flake update next time. Something like this:

inputs {
    ...
    mypackage_src.url = "github:myorg/mypackage";
    mypackage_src.flake = false;
    ...
}

pkgs.mypackage.overrideAttrs (oldAttrs: {
              src = mypackage_src;
              version = "nightly-${mypackage_src.shortRev or "src"}";
            })

The Nix language itself is the hardest part.

Let me disagree there, the language is trivial. It’s just JSON-lookalike with expressions, with a lot of nice touches that make using it much easier than all the alternatives (e.g. sane multi-line string handling, lazy evaluation, default values, powerful key/value sets, etc.). The only real stumbling for me when first encountering it was realizing that functions can only take a single argument (which can be a key/value set) and that functions are literally just : (e.g. (a: a + 5) 6 => 11). That’s easily missed if you just look at a file without reading the documentation.

The thing that makes it hard is just the complexity of the actual package collection, your configuration contains literally your whole system, and it’s not always obvious where to find the thing you need, since sometimes it’s a plain package, sometimes it is a services.foobar.enable = true and sometimes you have to fiddle with override or other package specific things. Knowing that https://search.nixos.org/ exists is half the battle here.

There is also the lack of static typing that can lead to rather verbose error messages, but it’s not like many other configuration formats have that either.

On top of that, the content of .git/objects/ is write protected, so even if you go rm -r, you’ll get an additional warning.

Periscope solved that quite well by showing a world map with everybody currently livestreaming. So you could just hop between countries and continents and see what others were doing. Wasn’t profitable enough or something, so Twitter killed it.

I use bat sometimes, but how do you stop it from wrapping lines?

$ cat ~/.config/bat/config
--wrap=never