1. 45
  1.  

  2. 20

    Over the last year I’ve made a transformation from being reluctantly acceptive of systemd, to strongly opposing it, to accepting it more fully. Interestingly this didn’t come from systemd itself, but a greater immersion in emacs that made me question the so-called “unix philosophy” – the fact that systemd wasn’t that relevant seems to me to reflect the issue and attitudes in general.

    Nevertheless, or maybe even precisely because of it, I understand the problems people have with it. Special formats that doesn’t directly cooperate with the userland, isolated and non-trivially replaceable components and unexpected behaviours (something I do think *nix generally gets right) all are one the one hand an attempt to shed of legacy constraints, but at the same time make the appearance that systemd isn’t a component or something that is added, but something one has to submit to: just think about all the software that depends on a specific init system! (albeit, it can usually be circumvent).

    To simply blame all of this on systemd seems to me an incomplete criticism, since systemd didn’t just pop up out of nowhere with the intention to provoke the greatest amount of graybeards. Real design issues, real legacy problems and real limitations which are to be found with a set of ideoms that resulted from quite a different environment, all had their influence. No solution is pretty or clean when the issue to begin with isn’t pretty of clean either.

    1. 11

      One-line summary for the impatient: A BSD proponent defends systemd (at a BSD conference) and suggests that BSD can take ideas from it

      Interesting talk.

      1. 4

        A comment about the actual video and not just a pro-/anti-systemd rant? Fantastic!

      2. 35

        Good talk.

        I recently used systemd “in anger” for the first time on a raspi device to orchestrate several scripts and services, and I was pleasantly surprised (but also not surprised, because the FUD crowd is becoming more and more fingerprintable to me). systemd gives me lifecycle, logging, error handling, and structure, declaratively. It turns out structure and constraints are really useful, this is also why go has fast dependency resolution.

        It violates unix philosohpy

        That accusation was also made against neovim. The people muttering this stuff are slashdot markov chains, they don’t have any idea what they’re talking about.

        1. 23

          The declarative units are definitely a plus. No question.

          I was anti-systemd when it started gaining popularity, because of the approach (basically kitchen-sinking a lot of *NIX stuff into a single project) and the way the project leader(s) respond to criticism.

          I’ve used it since it was default in Debian, and the technical benefits are very measurable.

          That doesnt mean the complaints against it are irrelevant though - it does break the Unix philosophy I think most people are referring to:

          Make each program do one thing well. To do a new job, build afresh rather than complicate old programs by adding new “features”.

          1. 31

            If you believe composability (one program’s output is another program’s input) is an important part of The Unix Philosophy, then ls violates it all day long, always has, likely always will. ls also violates it by providing multiple ways to sort its output, when sort is right there, already doing that job. Arguably, ls formatting its output is a violation of Do One Thing, because awk and printf exist, all ready to turn neat columns into human-friendly text. My point is, The Unix Philosophy isn’t set in stone, and never has been.

            1. 7

              Didn’t ls predate the Unix Philosophy? There’s a lot of crufthistory in unix. dd is another example.

              None of that invalidates the philosophy that arose through an extended design exploration and process.

              1. 4

                nobody said it’s set in stone; it’s a set of principles to be applied based on practicality. like any design principle, it can be applied beyond usefulness. some remarks:

                • i don’t see where ls violates composability. the -l format was specifically designed to be easy to grep.
                • the sorting options are an example of practicality. they don’t require a lot of code, and would be much more clumsy to implement as a script (specifically when you don’t output the fields you’re sorting on)
                • about formatting, i assume you’re referring to columniation, which to my knowledge was not in any version of ls released by Bell Labs. checking whether stdout is a terminal is indeed an ugly violation.
                1. 6

                  i don’t see where ls violates composability. the -l format was specifically designed to be easy to grep.

                  People have written web pages on why parsing the output of ls is a bad idea. Using ls -l doesn’t solve any of these problems.

                  As a matter of fact, the coreutils people have this to say about parsing the output of ls:

                  However ls is really a tool for direct consumption by a human, and in that case further processing is less useful. For futher processing, find(1) is more suited.

                  Moving on…

                  the sorting options are an example of practicality. they don’t require a lot of code, and would be much more clumsy to implement as a script (specifically when you don’t output the fields you’re sorting on)

                  This cuts closer to the point of what we’re saying, but here I also have to defend my half-baked design for a True Unix-y ls Program: It would always output all the data, one line per file, with filenames quoted and otherwise prepared such that they always stick to one column of one line, with things like tab characters replaced by \t and newline characters replaced by \n and so on. Therefore, the formatting and sorting programs always have all the information.

                  But, as I said, always piping the output of my ls into some other script would be clumsier; it would ultimately result in some “human-friendly ls” which has multiple possible pipelines prepared for you, selectable with command-line options, so the end result looks a lot like modern ls.

                  about formatting, i assume you’re referring to columniation, which to my knowledge was not in any version of ls released by Bell Labs. checking whether stdout is a terminal is indeed an ugly violation.

                  I agree that ls shouldn’t check for a tty, but I’m not entirely convinced no program should.

                  1. 4

                    just because some people discourage composing ls with other programs doesn’t mean it’s not the unix way. some people value the unix philosophy and some don’t, and it’s not surprising that those who write GNU software and maintain wikis for GNU software are in the latter camp.

                    your proposal for a decomposed ls sounds more unixy in some ways. but there are still practical reasons not to do it, such as performance and not cluttering the standard command lexicon with ls variants (plan 9 has ls and lc; maybe adding lt, lr, lu, etc. would be too many names just for listing files). it’s a subtle point in unix philosophy to know when departing from one principle is better for the overall simplicity of the system.

              2. 25

                With all due respect[1], did your own comment hit your fingerprint detector? Because it should. It’s extrapolating wildly from one personal anecdote[2], and insulting a broad category of people without showing any actual examples[3]. Calling people “markov chains” is fun in the instant you write it, but contributes to the general sludge of ad hominem dehumanization. All your upvoters should be ashamed.

                [1] SystemD arouses strong passions, and I don’t want this thread to devolve. I’m pointing out that you’re starting it off on the wrong foot. But I’m done here and won’t be responding to any more name-calling.

                [2] Because God knows, there’s tons of badly designed software out there that has given people great experiences in the short term. Design usually matters in the long term. Using something for the first time is unlikely to tell you anything beyond that somebody peephole-optimized the UX. UX is certainly important, rare and useful in its own right. But it’s a distinct activity.

                [3] I’d particularly appreciate a link to NeoVim criticism for being anti-Unix. Were they similarly criticizing Vim?

                1. 9

                  [3] I’d particularly appreciate a link to NeoVim criticism for being anti-Unix. Were they similarly criticizing Vim?

                  Yes, when VIM incorporated a terminal. Which is explicitly against its design goals. From the VIM 7.4 :help design-not

                  VIM IS... NOT                                           *design-not*
                  
                  - Vim is not a shell or an Operating System.  You will not be able to run a
                    shell inside Vim or use it to control a debugger.  This should work the
                    other way around: Use Vim as a component from a shell or in an IDE.
                    A satirical way to say this: "Unlike Emacs, Vim does not attempt to include
                    everything but the kitchen sink, but some people say that you can clean one
                    with it.  ;-)"
                  

                  Neo-VIM appears to acknowledge their departure from VIM’s initial design as their :help design-not has been trimmed and only reads:

                  NVIM IS... NOT                                          design-not
                  
                  Nvim is not an operating system; instead it should be composed with other
                  tools or hosted as a component. Marvim once said: "Unlike Emacs, Nvim does not
                  include the kitchen sink... but it's good for plumbing."
                  

                  Now as a primarily Emacs user I see nothing wrong with not following the UNIX philosophy, but at it is clear that NeoVIM has pushed away from that direction. And because that direction was an against their initial design it is reasonable for users that liked the initial design to criticism NeoVIM because moving further away from the UNIX philosophy.

                  Not that VIM hadn’t already become something more than ‘just edit text’, take quickfix for example. A better example of how an editor can solve the same problem by adhering to the Unix Philosophy of composition through text processing would be Acme. Check out Acme’s alternative to quickfix https://youtu.be/dP1xVpMPn8M?t=551

                  1. 0

                    akkartik, which part of my comment did you identify with? :) FWIW, I’m fond of you personally.

                    I’d particularly appreciate a link to NeoVim criticism for being anti-Unix

                    Every single Hacker News thread about Neovim.

                    Were they similarly criticizing Vim?

                    Not until I reply as such–and the response is hem-and-haw.

                    1. 9

                      To be fair I don’t think the hacker news hive mind is a good judge of anything besides what is currently flavour of the week.

                      Just yesterday I had a comment not just downvoted but flagged and hidden-by-default, because I suggested Electron is a worse option than a web app.

                      HN is basically twitter on Opposite Day: far too happy to remove any idea even vaguely outside what the group considers “acceptable”.

                      1. 4

                        Indeed, I appreciate your comments as well in general. I wasn’t personally insulted, FWIW. But this is precisely the sort of thing I’m talking about, the assumption that someone pushing back must have their identity wrapped up in the subject. Does our community a disservice.

                        1. 0

                          OTOH, I spent way too much of my life taking the FUD seriously. The mantra-parroting drive-by comments that are common in much of the anti-systemd and anti-foo threads should be pushed back. Not given a thoughtful audience.

                          1. 2

                            Totally fair. Can you point at any examples?

                            1. 3

                              https://news.ycombinator.com/item?id=7289935

                              The old Unix ways are dying… … Vim is, in the spirit of Unix, a single purpose tool: it edits text.

                              https://news.ycombinator.com/item?id=10412860

                              thinks that anything that is too old clearly has some damage and its no longer good technology, like the neovim crowd

                              Also just search for “vim unix philosophy” you’ll invariably find tons of imaginary nonsense:

                              https://hn.algolia.com/?query=vim%20unix%20philosophy&sort=byPopularity&prefix&page=0&dateRange=all&type=comment

                              Please don’t make me search /r/vim :D

                              1. 4

                                thinks that anything that is too old clearly has some damage and its no longer good technology, like the neovim crowd

                                That’s not saying that neovim is ‘anti-Unix philosophy’, it’s saying that neovim is an example of a general pattern of people rewriting and redesigning old things that work perfectly well on the basis that there must be something wrong with anything that’s old.

                                Which is indeed a general pattern.

                                1. 1

                                  That’s not saying that neovim is ‘anti-Unix philosophy’

                                  It’s an example of (unfounded) fear, uncertainty, and doubt.

                                  rewriting and redesigning old things that work perfectly well on the basis that there must be something wrong with anything that’s old.

                                  That’s a problem that exists, but attaching it to project X out of habit, without justification, is the pattern I’m complaining about. In Neovim’s case it’s completely unfounded and doesn’t even make sense.

                                  1. 1

                                    It’s not unfounded. It’s pretty obvious that many of the people advocating neovim are doing so precisely because they think ‘new’ and ‘modern’ are things that precisely measure the quality of software. They’re the same people that change which Javascript framework they’re using every 6 weeks. They’re not a stereotype, they’re actual human beings that actually hold these views.

                                    1. 2

                                      Partial rewrite is one of the fastest ways to hand off software maintainership, though. And vim needed broader maintainer / developer community.

                                      1. 0

                                        Vim’s maintainer/developer community is more than sufficient. It’s a highly extensible text editor. Virtually anything can be done with plugins. You don’t need core editor changes very often if at all, especially now that the async stuff is in there.

                                        1. 3

                                          You don’t need core editor changes very often if at all, especially now that the async stuff is in there.

                                          Which required pressure from NeoVim, if I understood the situation correctly. Vim is basically a one-man show.

                                2. 2

                                  Thanks :) My attitude is to skip past crap drive-by comments as beneath notice (or linking). But I interpreted you to be saying FUD (about SystemD) that you ended up taking seriously? Any of those would be interesting to see if you happen to have them handy, but no worries if not.

                                  Glad to have you back in the pro-Neovim (which is not necessarily anti-Vim) camp!

                      2. 20

                        What is FUD is this sort of comment: the classic combination of comparing systemd to the worst possible alternative instead of the best actual alternative with basically claiming everyone that disagrees with you is a ‘slashdot markov chain’ or similar idiotic crap.

                        On the first point, there are lots of alternatives to sysvinit that aren’t systemd. Lots and lots and lots. Some of them are crap, some are great. systemd doesn’t have a right to be compared only to what it replaced, but also all the other things that could have replaced sysvinit.

                        On the second point, it’s just bloody rude. But it also shows you don’t really understand what people are saying. ‘I think [xyz] violates the unix philosophy’ is not meaningless. People aren’t saying it for fun. They’re saying it because they think it’s true, and that it’s a bad thing. If you don’t have a good argument for the Unix philosophy not matter, or you think systemd doesn’t actually violate it, please go ahead and explain that. But I’ve never actually seen either of those arguments. The response to ‘it violates the Unix philosophy’ is always just ‘shut up slashdotter’. Same kind of comment you get when you say anything that goes against the proggit/hn hivemind that has now decided amongst other things that: microsoft is amazing, google is horrible, MIT-style licenses are perfect, GPL-style licenses are the devil-incarnate, statically typed languages are perfect, dynamically typed languages are evil, wayland is wonderful, x11 is terrible, etc.

                        1. 8

                          claiming everyone that disagrees with you is a ‘slashdot markov chain’ or similar idiotic crap

                          My claim is about the thoughtless shoveling of groundless rumors. Also I don’t think my quip was idiotic.

                          there are lots of alternatives to sysvinit that aren’t systemd

                          That’s fine, I never disparaged alternatives. I said: systemd is good and I’m annoyed that the grumblers said it wasn’t.

                          1. 2

                            It’s not good though, for all the reasons that have been said. ‘Better than what you had before’ and ‘good’ aren’t the same thing.

                            1. 1

                              seriously. If you don’t like systemd, use something else and promote its benefits. Tired of all the talking down of systemd. It made my life so much easier.

                              1. 1

                                seriously. If you like systemd, use it and shut up about it. Tired of all the talking up of systemd as if it’s actually any better than its alternatives, when it is objectively worse, and is poorly managed by nasty people.

                                1. 4

                                  Have you watched the video this thread is about? Because you really sound like the kind of dogmatist the presenter is talking about.

                                  If you like systemd, use it and shut up about it

                                  Also, isn’t this a double-standard, since when it comes to complaining about systemd, this attitude doesn’t seem that prevalent.

                                  1. 2

                                    No, because no other tool threatens the ecosystem like systemd does.

                                    Analogy: it wasn’t a double-standard 10 years ago to complain about Windows and say ‘if you like Windows, use it and shut up about it’.

                                    1. 3

                                      I see this kind of vague criticism when it comes to systemd alot. What ecosystem is it really breaking? It’s all still open source, there aren’t any proprietary protocols or corporate patents that prevent people from modifying the software to not have to rely on systemd. This “threat”, thr way I see it, has turned out to be at most a “ minor inconvenience “.

                                      I suppose you’re thinking about examples like GNOME, but on the one hand, GNOME isn’t a unix-dogmatist project, but instead they aim to create a integrated desktop experience, consciously trading this in for ideal modularity – and on the other, projects like OpenBSD have managed to strip out what required systemd and have a working desktop environment. Most other examples, of which I know, have a similar pattern.

                        2. 6

                          I think that the problem is fanboyism, echo chambers and ideologies.

                          I might be wrong, so please don’t consider this an accusation. But you writing this sounds like someone hearing that systemd is bad, therefore never looking at it, yet copying it. Then one tries it and finding out that baseless prejudices were in fact baseless.

                          After that the assumption is that everyone else must have been doing the same and one is enlightened now to see it’s actually really cool.

                          I think that this group behavior and blindly copying opinions is one of the worst things in IT these days, even though of course it’s not limited to this field.

                          A lot of people criticizing systemd actually looked at systemd, really deep, maybe even built stuff on it, or at least worked with it in production as sysadmin/devop/sre/…

                          Yes, I have used systemd, yes I understand why decisions we’re taken, where authors if the software were going, read specs of the various parts (journald for example), etc.

                          I think I have a pretty good understanding compared to at least most people that only saw it from a users perspective (considering writing unit files to be users perspective as well).

                          So I could write about that in my CV and be happy that I can answer a lot of questions regarding systemd, advocate its usage to create more demand and be happy.

                          To sum it up: I still consider systemd to be bad on multiple layers, both implementation and some ideas that I considered great but then through using it seeing that it was a wrong assumption. By the way that’s the thing I would not blame anyone for. It’s good that stuff gets tried, that’s how research works. It’s not the first and not the last project that will come out sounding good, to only find out a lot of things either doesn’t make a difference or make it worse.

                          I am a critic of systemd but I agree that there’s a lot of FUD as well. Especially when there’s people that blame everything, including own incompetence on systemd. Nobody should ever expect a new project to be a magic bullet. That’s just dumb and I would never blame systemd for trying a different approach or for not being perfect. However I think it has problems on many levels. While I think the implementation isn’t really good that’s something that can be fixed. However I think some parts of the concept level are either pretty bad or have turned out to be bad decisions.

                          I was very aware that especially in the beginning the implementation was bad. A lot got better. That’s to be expected. However next to various design decisions I consider bad I think many more were based on ideas that I think to most people in IT sound good and reasonable but in the specific scenarios that systemd is used it at least in my experience do not work out at all or only work well in very basic cases.

                          In other words the cases where other solutions are working maybe not optimal, but that aren’t considered a problem worth fixing because the added complexity isn’t worth it systemd really shines. However when something is more complex I think using systemd frequently turns out to be an even worse solution.

                          While I don’t wanna go into detail because I don’t think this is the right format for an actual analysis I think systemd in this field a lot in common with both configuration management and JavaScript frameworks. They tend to be amazing for use cases that are simple (todo applications for example), but together with various other complexities often make stuff unnecessarily complicated.

                          And just like with JavaScript frameworks and configuration management there’s a lot of FUD, ideologies, echochambers, following the opinion of some thought leaders, and very little building your own solid opinion.

                          Long story short. If you criticize something without knowing what it is about then yes that’s dumb and likely FUD. However assuming that’s the only possible reason for someone criticizing software is similarly dumb and often FUD regarding this opinion.

                          This by the way also works the reverse. I frequently see people liking software and echoing favorable statements for the same reasons. Not understanding what they say, just copying sentences of opinion leaders, etc.

                          It’s the same pattern, just the reversal, positive instead of negative.

                          The problem isn’t someone disliking or liking something, but that opinions and thoughts are repeated without understanding which makes it hard to have discussions and arguments that give both sides any valuable insides or learnings

                          Then things also get personal. People hate on Poetteing and think he is dumb and Poetteing thinks every critic is dumb. Just because that’s a lot of what you see when every statement is blindly echoed.

                          1. 1

                            That’s nice, but the implication of the anti-systemd chorus was that sys v init was good enough. Not all of these other “reasonable objections” that people are breathless to mention.

                            The timbre reminded me of people who say autotools is preferrable to cmake. People making a lot of noise about irrelevant details and ignoring the net gain.

                            But you writing this sounds like someone hearing that systemd is bad, therefore never looking at it, yet copying it.

                            No, I’m reacting to the idea that the systemd controversy took up any space in my mind at all. It’s good software. It doesn’t matter if X or Y is technically better, the popular narrative was that systemd is a negative thing, a net-loss.

                            1. 2

                              In your opinion it’s good software and you summed up the “anti-systemd camp” with “sys v init was good enough” even though people from said “anti-systemd camp” on this very thread disagreed that that was their point.

                              To give you an entirely different point of view, I’m surprised you don’t want to know anything about a key piece of a flagship server operating systems (taking that one distro is technically an OS) affecting the entire eco system and unrelated OS’ (BSDs etc.) that majorly affects administration and development on Linux-based systems. Especially when people have said there are clear technical reasons for disliking the major change and forced compliance with “the new way”.

                              1. 2

                                you summed up the “anti-systemd camp” with “sys v init was good enough” even though people from said “anti-systemd camp” on this very thread disagreed that that was their point.

                                Even in this very thread no one has actually named a preferred alternative. I suspect they don’t want to be dragged into a discussion of details :)

                                affecting the entire eco system and unrelated OS’ (BSDs etc.)

                                BSDs would be a great forum for demonstrating the alternatives to systemd.

                                1. 2

                                  Well, considering how many features that suite of software has picked up, there isn’t currently one so that shortens the conversation :)

                                  launchd is sort of a UNIX alternative too, but it’s currently running only on MacOS and it recently went closed source.

                          2. 3

                            It violates unix philosohpy

                            That accusation was also made against neovim. The people muttering this stuff are slashdot markov chains, they don’t have any idea what they’re talking about.

                            i don’t follow your reasoning. why is it relevant that people also think neovim violates the unix philosophy? are you saying that neovim conforms to the unix philosophy, and therefore people who say it doesn’t must not know what they’re talking about?

                            1. 1

                              are you saying that neovim conforms to the unix philosophy, and therefore people who say it doesn’t must not know what they’re talking about?

                              When the implication is that Vim better aligns with the unix philosophy, yes, anyone who avers that doesn’t know what they’re talking about. “Unix philosophy” was never a goal of Vim (”:help design-not” was strongly worded to that effect until last year, but it was never true anyways) and shows a deep lack of familiarity with Vim’s features.

                              Some people likewise speak of a mythical “Vim way” which again means basically nothing. But that’s a different topic.

                              1. 1

                                vim does have fewer features which can be handled by other tools though right? not that vim is particularly unixy, but we’re talking degrees

                            2. 1

                              The people muttering this stuff are slashdot markov chains, they don’t have any idea what they’re talking about

                              I’ll bookmark this comment just for this description.

                            3. 7

                              I think systemd had some really noble aims, and it has succeeded in many of them, which is at least partly why it’s so successful. There are, however, I think a couple of under-represented negative points, more from my point of view as a developer of unix daemon software than from the end-user view:

                              • Primarily, a general lack of regard for the server-side Linux community’s needs. Everything is very “finally year of the Linux desktop” -oriented, and when long-time server admins question how systemd’s design affects server operations, their pleas aren’t really heard much.
                              • Cross-platform was thrown out the window. Sure, traditional *nix “APIs” at various levels had their platform quirks, but it was mostly not that difficult to write cross-platform daemons that did their job on at least the various modern *nixes that mattered (Linux, Darwin, *BSD). Systemd invented new APIs for some very basic low-level stuff about how network daemons start and operate, and didn’t even try to make those things new cross-platform standards. The model seems more or less “We’ll invent arbitrary new standards that are Linux-only with almost no expert input or peer review, screw everybody else”.
                              • In some cases, things that were reasonably possible using the traditional *nix interfaces are no longer possible to do well portably. Certain things are broken if you ignore systemd and do things the traditional way (as in, what was portable Linux/*BSD/Darwin code now works for all the rest but fails on Linux+systemd), and since you pretty much can’t ignore the dominant Linux+systemd case, you end up having to structure code in a systemd-compatible way, and then maintain two very different sets of code to keep portability, or basically tell all the Darwin/*BSD people “Sorry, you need to fix your to more-closely model how systemd works now”.

                              There are some great ideas in systemd, and great accomplishments. The problems tend to boil down to lack of listening to all of their audiences, lack of open design processes, and lack of even the barest attempt to establish newer/better cross-platform standards and portability. I wouldn’t ask that they spent 10 years trying to update POSIX or something, but even attempting to get some community consensus on the directions and APIs involved among the *BSDs might’ve been a start.

                              1. 0

                                Those are valid points. On the other hand…

                                Sure, traditional *nix “APIs” at various levels had their platform quirks, but it was mostly not that difficult to write cross-platform daemons that did their job

                                … it depends on what “job” you’re doing. Look at what psutil must do to inspect process info (even some very basic queries) for the different BSDs. Cross-platform is not easy, and there are big gaps in POSIX.

                              2. 2

                                This is a nice post that debunks some of the myths and FUD against SystemD http://0pointer.de/blog/projects/the-biggest-myths.html