[Nix-dev] Will there be a systemd replacement at any time inthefuture?

[Michael Raskin]

>Shea & Michael: By default systemd sends stdout & stderr to the journal,
>this is controlled by DefaultStandardOutput & DefaultStandardError in
>systemd-system.conf. So yes, if these are set to `journal` (or stdout is
>set to `journal` and stderr to `inherit`) and you had stdout/stderr
>messages which weren't caught then this is a bug. Were the issues you
>were having something you could replicate or...?

Maybe I should break vsftpd once more.

>Michael: The speed issue with the journal is more likely fragmentation;
>the journal fragments like nothing else on my systems, unfortunately,
>and the slowdown for journal commands is one of the few annoying issues
>I've found with systemd in actual usage :(. journalctl should not
>otherwise be slow, unless you're not specifying a timerange and are just
>seeking forward from boot or other distant past time. On that note, `-e`
>should really be default on journalctl, bleh.

I tried with ```-e``` and with and without ```-n 20```. If ```-e``` 
worked, I'd just say "Thank you!" and start spamming this knowledge
around. On my system the command ```journalctl -u sshd -e -n 20 -b```
takes an eternity. Fun fact: if I manually cat the journal to /dev/null,
journalctl works fine from cache; entire journal size is les than 
250MiB; the cat command actually works faster than failed attempts to
use journalctl…

So all in all: it writes to a file in a way that ensures fragmentation,
then reads it randomly in small chunks, reads most of it, and ends up
way slower than just reading the entire file…

What I wonder about is whether it can be told to please do this only to
the last megabyte of the file or something…

>Matthias: Ultimately, adding an alternative init system is a non-trivial
>amount of work, and thus like most Nix-related things it'll happen as
>soon as someone who cares about it (e.g. you?) devotes the time to make
>it happen.

The real problem is also that support for non-systemd init systems is 
quite likely to be a long-term fork: even if it works, its inclusion can
fail to happen.