[erhardm]

They're good points, but from the philosophical point The Unix Way, systemd leaves some things to desire. Is there a modern Unix way? I don't see a lot of exploring in this area/side, but I see a lot of this is the way it's gonna be from now on on the other side.

I'm not on either side, but I appreciate the way some complexity is dealt with simple little things. So elegantly solving problems: https://www.youtube.com/watch?v=S0mviKhVmBI#t=450

[exelius]

I'm not on either side myself, either. But "this is the way we've always done things" is a terrible reason to keep doing them that way. Systems change, requirements change, and so implementations and methods must change as well. I'm not saying this is warranted or not in the case of systemd (I don't know enough of the details to opine either way) but it has been a cultural problem in the Linux community for a number of years. Modern use cases require a more coordination between multiple parts of the system, which is I think where a lot of the friction comes from.

The entire systemd debate is as bad as it is because this is a can that has been kicked down the road for two decades because nobody wanted to have the same argument again. Everyone has known for a long time that at some level, Linux needed better coordination between user applications, hardware, and system services. systemd seems to deliver on most of the functional requirements of such a system, though the implementation method has upset some people on a philosophical level because they believe it's counter to the Unix way, whatever that means.

I would argue that software development in general has drifted away from "the Unix way". Modern software development is a mess of dependencies, abstraction layers, control points and dominant standards controlled by individuals/companies with a vested interest. Linux is a good counterbalance to that, but at the same time it can't stray too far away from the way that people use systems or it becomes too outdated to matter. Is systemd the answer? Who knows. But in the absence of something that performs its function, companies will step up with proprietary solutions for their use cases (launchd on OS X/iOS, whatever Android uses) that lead to more walled gardens, not less.

[agrover]

I think the fallacy is looking at the composability of tools on the command line and thinking you want/need the same composability in how the system runs. You don't. The Unix Way is actually TWO things: one is shellscripting and the composability of the command line, and the other is C and libraries. "Whipupitude vs manipulexity", to quote Larry Wall. Systemd is the result of determining that running system services is complex and needs to be handled by a real program instead of scripts. This is easier in C, but the flipside is the unavoidable loss of whipupitude. For most people this is fine. When Unix was young, whipping up something simple was fine. Now it isn't, and really hasn't been for quite a long time.

[anko]

Thank you, this is the most insightful comment I've read.

People like the whipupitude, because they know it. But nearly every init.d script I've read has bugs. There isn't a testing framework to ensure correctness and even if there were it would be needlessly complex because you'd spend a bunch of time mocking out the filesystem / the process table / whatever else init scripts do.

We know what initialising a process should look like and we should be stabilising this API so that we limit mistakes/bugs.

[bnolsen]

Unix had high goals but ended up compromising. It's been a good system, good enough to fend off other system competitors. Trying to argue details using precedence and pointing to the exceptions and compromises to prop up arguments doesn't excite me very much.

Plan9 seems to have better distilled and refined the "unix way". But it's been too little too late and I'm sure if it became popular there's be wars about it too.