I actually have a technical rationale for avoiding systemd, among others.<p>This is a comment I was supposed to send to chris_wot in the systemd v227 announcement thread, but his posts got nuked by dang.<p>Here goes:<p>----------------------<p>systemd tries to force various system resources into the Unit abstraction, to a rather mixed effect. Some are IPC resources (sockets), others are abstract entities which are driven by a lower-level primitive (services that drive jobs), yet others still claim to wrap resources but really drive util-linux binaries (mounts and swaps). The information hiding&#x2F;encapsulation is inconsistent, too. I&#x27;m not shielded from the dirty details of transactions and the seven different job queuing modes, and when they actually blow up in my face, the debugging context is very scarce.<p>All of this takes place in an ad-hoc graph engine that I cannot really observe. I can look at <i>approximations</i> of it (systemd-analyze), but I have no way of directly manipulating it, only indirectly through normal operations on system and service state of which the effects I cannot reliably gauge as they undergo systemd&#x27;s heuristics. Moreover, I cannot checkpoint the graph state to disk, so I could e.g. replay and reboot from a known-good system state manifest. systemd snapshots are ephemeral (in-memory) and moreover do not fully preserve the graph info, anyway.<p>systemd clearly has an identity crisis between whether it wants to be an eager or lazy service manager. Publicly, it recommends laziness through so-called socket activation, but in practice people mostly tend toward using the dependency system. The dependency system, of course, exists mostly to calculate ordering requirements for parallel startup. This however comes at a cost of non-deterministic ordering, whereby a service can be malignantly reordered, breaking the boot sequence (NFS seems especially prone). This is somewhat inherent to parallelism in general, but is particularly undesirable given parallelism serves no other purpose beyond startup speed optimization (for which process checkpointing I maintain is a better solution).<p>Between all of this intermediate complexity, I can end up in stuck start&#x2F;stop jobs, cyclical transactions and dependency loops without knowing the exact origin, because the graph engine doesn&#x27;t supply me with sufficiently good debugging context.<p>And the worst part is that most of this is not even a reliability&#x2F;fault tolerance thing. The Unix process model has no semblance of anything resembling a &quot;transaction&quot;, nor is the Unit object versatile enough. It&#x27;s all heuristics on a private graph engine meant to topologically sort the edges, so as to accommodate systemd&#x27;s dependency system (which conflates hard service relationships with softer ordering requirements, and is generally inflexible)... yet at the same time you&#x27;re actually expected to lazy load everything, but barely so in the real world.<p>Oh, and of course, handling anything related to Unit objects in PID1 creates an unnecessary coupling between global system state and service state in particular, on top of all the intermediate complexity of the graph.