Boycott systemd
boycottsystemd.org
boycottsystemd.org
I got past that by using eudev with OpenRC on Gentoo.
E.g. you could perfectly plausibly make the argument that systemd's return to inetd-style service starting (on-demand and in-parallel through socket activation) is a lot more unix-philosophy-like than the SysVinit way.
SysVinit is complicated - it wants to be a DSL but is still a shell hack-together. It's inflexible - it's a dependency tracking system, but you can't easily adapt it for userspace launch control, or as a build tool. It doesn't do one thing well. (e.g. doesn't reliably contain a process tree, there are still situations where you want to use pid files or complicated ps greps).
Init is a hard problem. From what I can see all the unix derivatives have made a mess of it. I've had fleeting attempts at writing my own, and I definitely made mess.
In the absence of the good, I reckon the simple becomes the standard. In modern BSDs there's a script called init, it gets called at startup and does nothing for you. I reckon we should judge challengers to init against that.
> 2. systemd's journal files (handled by journald) are stored in a complicated binary format.
Mr Poettering tackles the myth that configuration files are binary (they are very obviously not).
That said, I am not sure how to get the journaling data in an Upstart system, nor in a sysvinit one.
https://bbs.archlinux.org/viewtopic.php?pid=1149530#p1149530
Summary:
0) it is hotplug capable
1) we can know the state of the system
2) it is modular
3) it allows dbus/udev to go back to doing the task they are meant to do
4) we can reduce the number of explicit ordering dependencies between daemons
5) we get a lot of security/sandboxing features for free
6) systemd service files can be written and distributed upstream
7) systemd is a cross-distro project
8) logind will finally deliver on what consolekit was supposed to do
9) systemd is fastDmd is the gnu daemon managing daemons.
Im planning at least to provide more documentation, when I learn guix and dmd more.
I'm a huge fan of Lisp-based languages, but this thing actually wants people to use Lisp for creating service files!
http://www.gnu.org/software/dmd/manual/dmd.html#Service-Exam...
Not even data-based lisp like Clojure's data format (the one that Light Table uses for its configs, forget the name), but full-on lisp!. That would be a maintenance nightmare for sys admins.
Not to mention that it seems rather sparse in basic features... I couldn't find any example in the manual for setting users & groups or permissions. These are fundamental.
I love the fact that the configuration is written in Guile. Data is code and code is data after all. I think you're exaggerating the maintenance nightmare. In fact, the Guix project has already proven that newcomers who don't really know s-expression style syntax can write software packages.
The only way to actually manage such a DSL/Schema is to provide a way to "break out" of it into a general purpose language - that's what systemd does by allowing you to run shell scripts in the case you're not using a "standard" service, and it's also what the Nix expression language does in order to build software.
It's far easier to just provide a fully capable language up front - and abstract the common patterns into functions or macros to simplify the usage for users. sysv has worked well with just shell scripts for years, despite it being a sub-standard general purpose language - although various hacks like the LSB init headers have been added to provide some kind of structure to them - a problem that will be better solved with records in Guile.
As for maintenance, I see it as a big plus - with a language like Guile you have access to a useful REPL and debugger - no need to roll your own debugging interface or inspect log files. On top of that, having a dynamic language makes it easier to develop and test patches for new requirements - you're not forced to recompile and restart your DSL.
0: udev did that. They merged udev in. Now systemd does it. I'd rather see them play nice by communicating with other projects than controlling everything on their own.
1: Apart from internal watchdog, the features he listed are also available in upstart. (others are not, but his list is actually common)
3: This is a strange claim when talking about an init system that effectively starts managing devices.
6: Not sure why it's on the good things list - it already happened before for rc/init/upstart. It's inevitable rather than new awesome - we'll all have to rewrite the configs once again.
8: Why is that part of systemd? Ubuntu was happily running with it being a separate daemon. If it doesn't depend on systemd why is it included (same for udev really). Convenience for developers is not a great answer here.
There seems to be a lot of exaggerated claims going both ways - at least that shows not everyone is happy about the change. Hopefully the next project that replaces init will be what many claim systemd is right now...
I'm not sure why the same maintainer matters for merging. Take openstack as a counter-example. It's mostly the same pool of contributors working on a number of related projects. Not only have they been split into components (nova, nova-volume, nova-network -> nova, cinder, quantum projects), common functionality has been split into separate library projects of their own (oslo-messaging, oslo-logging, etc.) with their own releases, versioning, leadership. This is what I really like and it's exactly the opposite of what systemd is doing (merging device, network, logging, etc. into one system).
If systemd is modular (doesn't require logind) and logind is standalone (requiring only systemd as a library) - what's the point of bundling them. (apart from making it harder for others to use) Systemd owns too much at the same time and I believe it's going to lead to problems in the future.
"I don't think we ever disagreed enough for me to refuse patches from them - it was very much a case of they had different ideas to me, and couldn't contribute them because of the CLA
If the CLA wasn't there, we'd've just tugged and pulled and fought about patches like normal projects, and Upstart would have turned out much like systemd - I'd've been okay with that :)"
The CLA is absolutely why systemd exists. systemd didn't fork because there was no benefit to anyone in sharing code -- Upstart wouldn't take their patches. There are technical differences, but those could have been handled in code (like Scott says) if the CLA hadn't existed.
This does not make sense to me. They could fork it if it was good enough. If they started from scratch, then CLA wasn't the main issue. It's like "the corner store didn't have the milk I like today so I had to start my own farm".
If there was no CLA, the folks who went on to develop systemd could have decided that the benefits of collaborating with an existing project were greater than the benefits of writing systemd from scratch. And everyone involved seems to agree that that's what would have happened. Yes, as a purely technical matter, the systemd people decided starting from scratch was better than forking Upstart. But the reason it was a purely technical decision was their refusal to sign the CLA, which meant the ONLY considerations were technical. But there are other considerations that could have swung the decision the other way if not for the CLA.
Which certainly means he has the right to merge udev in, but it doesn't necessarily make it a nice thing to do for the rest of the community.
Those that have become dependent on udev without believing they'd be hitching their cart to a horse that replaces the init system, cron, at, syslog, etc. now have to go through the process of building systemd to rip udev out, and keep their fingers crossed that it doesn't get harder (or outright impossible).
Lots of projects in the open source community get split up as they get bigger. One of the other commenters on here mentions all of the openstack stuff, which I think is a great example.
From my anecdotal experience in watching the open source community over the last 14 years is that most people, when working on multiple projects, keep them as multiple projects, unless they are /really/ duplicating functionality, and thus, effort. Even then, they might not merge them. See: All of the work Brendan Gregg does for performance engineering tools. He's constantly writing small patches to improve KTap, Systemtap, Sysdig, DTrace linux ports, etc. Despite the fact they're all competing projects. Granted, he's not in charge of any of them, and I can't read his mind, but would someone who likes merging projects together sit there and spend so much time constantly improving projects that are competing with each other? I doubt it.
0) That's not the init systems job.
1) That's not the init systems job. Use something like http://cr.yp.to/daemontools.html
2) Less modular than any init system out there. Having *everything* (including a dhcp deamon soon) in PID 1 is not modular just because you can configure it.
3) See 1.
4) Never bothered me, but fair enough.
5) That's not the init systems job.
6) Not if the path's differ. E.g. are debianized.
7) So was sysvinit.
8) That's not the init systems job.
9) It actually is.
In the end djb's daemontools are nothing more than an init system on top of an init system. So why not include it in the main init system?
What do you mean by that? That it isn't PID 1? Apparently it can be made to run as PID 1. But you can keep the (in my opinion) brilliant design of daemontools and use successors such as s6 are designed to run either as PID 1 or as a plain old daemon (which is nice if you've not got full control of a machine).
http://www.skarnet.org/software/s6/index.html
I've been using s6 to manage a few things, and some features I like are:
- allow a group to manage (stop/restart) certain processes using Unix file permissions
- arrange things in a tree. My toplevel s6-svscan starts a second s6-svscan which starts a handful of related processes. These all inherit the same user and environment vars which makes config easy.
http://skarnet.org/software/s6/why.html
The big feature s6 has that runit lacks seems to be the ability to wait without polling on some event (process started). I haven't used this much myself, but even given that some process has started, it doesn't necessarily mean that it's initialized and ready to do what you expect.
I can understand the issue that people have with systemd swallowing more and more functionality, but this fact is just false.
dhcp is in /usr/lib/systemd/systemd-networkd, which is not the systemd binary running as PID 1 (/usr/lib/systemd/systemd/systemd).
chris@raspberrypi /usr/lib/systemd $ ls -la systemd systemd-networkd
-rwxr-xr-x 1 root root 907340 Apr 14 23:10 systemd
-rwxr-xr-x 1 root root 329604 Apr 14 23:09 systemd-networkd
chris@raspberrypi /usr/lib/systemd $ ./systemd --versionIt is a suite of tools for managing the system state. Going from runlevel 0 to runlevel 3 is just one such transition.
systemd is referred to as monolithic because it is developed in a single repository, but it is in fact extremely modular. "PID 1" is only one of the ~70 binaries which make up the systemd suite.
Saying "That's not the init systems job" seems dogmatic and short sighted when there's currently no other approach which offers the hotplug, service management, security and performance features that systemd brings to the table.
Beside that, I recommend you'd take a look at http://www.freedesktop.org/wiki/Software/systemd/InterfacePo... and possibly http://www.freedesktop.org/software/systemd/man/.
I'm not saying that isn't possible -- ZFS is an example of a tool that gobbled up lots of others, and it's almost better -- for my use-cases not being able to grow a raid-array is a bit of a deal-breaker, as is the requirment of having roughly 4GBs of RAM available -- for many use-cases it isn't. But having disk management, filesystem management and managing disk encryption in one tool is great.
> 0) That's not the init systems job.
For modern Linux, there is nothing but hotplug. And I mean that very literally. Oldest Unices only worked on systems where all the hardware was brought up on boot, before the rest of the system. Then hotplug was added on top of this. Init systems didn't evolve to accommodate this, instead different systems were developed to handle it. However, the Linux kernel has constantly evolved towards eliminating old-style static boot, with right now, on normal bootup, almost all devices are hotplugged. This is why sysvinit doesn't work properly anymore. Being hotplug capable is definately the init system's job.
From that perspective -- the perspective of systems which boot once, and boot again maybe next year if the UPS didn't keep them up when the power flickered, and the perspective of the systems where there are definitely not usb drives or random pieces of unknown crap plugged into user accessible ports, the idea of hotplug at all is the least of concerns, and the idea of boot time is laughable.
Essentially, it seems like systemd is chasing Windows of 16 years ago, where computers took 5 minutes to boot Windows, where device drivers and such were a mess, and things were constantly entering and leaving systems.
No, you don't understand me. Even if actually hotplugging things is completely uninteresting to you, your init system still has to somehow be able to deal with the fact that on a modern box, all your devices show up in essentially random order with random delays. sysvinit currently handles this by putting a completely arbitrary sleep call in the beginning of the boot process. Just last week I had to deal with a server where due to circumstances that sleep wasn't enough, which lead to the ethernet devices getting initially wrongly named, which was bad because the mountains of script doing network configuration there happily treated the external network as the internal one and the internal one as the external one.
Even if hotplug is a feature you don't care at all about, due to design decisions made by the Kernel team, if you want to run a modern Linux kernel your machine will have to fully support hotplug properly or it's going to (rarely and non-replicably) fail in interesting and imaginative ways.
That nevertheless doesn't have anything to do with hotplugging devices, nor does it suggest that we should create an init system which handles dhcp, qr codes, and, no shit, takes core files and jams them into its binary log.
See other replies.
I do (rarely) install Linux on some new PC but I think I stopped installing Arch after this changes. I mean what's the point installing Arch if there is no very elegant and beautiful rc.conf? What is that killer feature that Arch offers, apart from being rolling release?
Anecdotal evidence can be dismissed by anecdotal evidence -- A variation of Hitches' razor
Switching to systemd broke _my_ entire Arch _experience_. Before systemd I knew exactly what gets executed, when and why -- which is exact reason why I switched to Arch many years ago. I don't know the same thing after systemd introduction.
> $ ls -al /etc/systemd/system
and look at its contents. It is not that hard. It changed everyone's experience. Some people just hate change. Others deal with it.
While it did make desktop / laptop users experience a little bit more complicated, from what I have read it makes things much easier on the sysadmins who are working with lots of daemons on the servers.
As a general point for everyone: Just because it's _also_ an init system doesn't mean it's not allowed to provide the binaries for doing a whole lot of other stuff. :)
Why can't we have an independent organisation that defines a spec for all the relevant APIs and tools for managing a system, and systemd just be one implementation of that spec? Actually, it could be a suite of specs, so people could pick and choose which ones solve their problems, and build alternatives for others.
> [...] by the same people, with the same ideas, and the same gatekeepers [...]
Isn't this exactly what made the Linux Kernel great? A consistent vision.
I agree with you on a few points though, the systemd team should be more cooperative and start being conservative on the API changes. If the API is defined clearly, it shouldn't be hard to make proper replacements for parts of it.
I disagree strongly that there should be an independent Organisation to define that spec, because that would quickly be overrun by bikeshedding and all the other problems stemming from design by comittee. Very often in the Open Source world, specs have been defined by the first people arriving at the scene, so to speak. It all works over dbus, no? That is a fairly simple protocol to implement. I think it's an elegant IPC solution.
Anyway. cheers!
Sure, but even today, the Linux kernel has competition. I can run most things on Windows or OSX or FreeBSD or Solaris, even if the technical details are different. I worry about a monoculture forming around systemd, as seems to be happening now; I can't find a modern distro that uses anything else (aside from Gentoo, which I can't take seriously for production work), and it's starting to be assumed that systemd is the only init system that anybody will use.
You can still use Windows, OSX or FreeBSD.
Funny thing. For me systemd has turned that around. I had no idea what was going on in my system, but systemd allows me to easily visualize it, control it and optimize it.
systemd may not be the ultimate init system which all Unix/Linux versions will end up using, but I have no doubt a future init-systems will take a queue from all these things which systemd has done well.
Also try the other options to systemd-analyze, such as "critical-chain", as well as systemd-cgls to get a view of how the currently running processes relate to specific service files.
Together it should give you a view of what gets executed when (to the fraction of a second) and why.
Maybe on Arch this is simpler, on Fedora systemd-analyze dot produces a nightmare that no human mind can navigate.
> -- Try a shell pipeline like 'systemd-analyze dot | dot -Tsvg > systemd.svg'!
EDIT: there are 1101 edges in the graph produced on my machine.
I don't know if it didn't break for the majority but for me it certainly did on many installations.
Like being good solid rolling release distro is not good enough? Frankly I prefer my distros to be free of any "killer features".
That may not sound like much, but it's pretty awesome. I use it as a reference on a few things even when dealing with other Linux distros.
e.g. The page on SSH basically starts with how to restrict users who can log in and disabling root. https://wiki.archlinux.org/index.php/Secure_Shell
Haven't used Arch in a while - not dealt with a non-company Linux box for a while. But it remains my go-to Linux (for development purposes) for good reasons.
> I mean what's the point installing Arch if there is no very elegant and beautiful rc.conf?
rc.conf removal had nothing to do with systemd, I think. And was removed prior.
> What is that killer feature that Arch offers, apart from being rolling release?
Vanilla upstream packages.
When I first used Arch in 2006, rc.conf held a lot of configuration. From what I understand, it held even more configuration options prior to that. Since that time and until the removal of rc.conf, there was a steady removal of features from rc.conf.
I'd be interested to know if the systemd boot process (which can be 2 seconds or quicker) has enough advantages to make the other changes worth it.
Before installing Arch, I was a die-hard Kubuntu/KXstudio[2] user. Now I have the ability to build all the KXstudio packages from git (Cadence, Carla, and Claudia make JACK the greatest thing ever), without all the Ubuntu/Debian cruft underneath.
Another benefit (post-snowden) is that Arch is not an incorporated entity in any of the "Five Eyes" countries. Julian Assange has come out to publicly state knowledge of intentional flaws being added to both Open Source/Free Software projects, and specifically namedrops Debian as compromised. The threat vectors one should analyze are which governments would have access to which corporations. RedHat is a registered corporation in Delaware, USA. Canonical is registered in City of London. If one pays attention to Moxie Marlinspike's convergence demo at DEFCON 19, you can see how it'd be trivial for a government agency such as GCHQ/CCSE/NSA to spoof Canonical's or RedHat's SSL certificates. Gentoo and Arch have no corporate influences, and thus are the only relatively safe Linux distributions left, IMO.
So, AUR, Advanced customization, and potentially increased security are bigger reasons, for me, to switch to Arch than pacman.
Even if all of there points were objectively true, it doesn't matter when sticking with the old init is so much worse in many ways.
People aren't picking systemd because it's perfect, but because both the mess of init scripts it is replacing, and alternatives like upstart,is seen as worse/too lacking.
EDIT: Btw. this just got me to install systemd on one of our dev/test Debian boxes at work, to start testing it.
That said, a lot of systemd seems like a really stupid idea to me, e.g. binary logs, the massively increased SPOF size, and the "do everything" mentality. Unfortunately, I don't know of any distros that aren't using it now (edit: I didn't even realise Slackware was still a thing...), and upstart is even more of a joke than systemd.
[1] http://www.freedesktop.org/wiki/Software/systemd/journal-fil...
tail, less, grep, wc and similar tools are rendered useless. Newer tools like logstash or Splunk are also going to have issues reading your binary logs. It's not really a wise thing to break the tools that most people use every day, it's just going to make them hate you.
All the binary logs are going to do is make people have a cronjob to extract them regularly into a readable format.
Actually, they won't. Because journald has the relevant functionality built-in -- that is, it can automatically stream out the logs in any format you choose, including ones understood by rsyslogd, and if you really just don't like journald, you can just turn off it's storage and turn it into nothing but a shim.
So pipe it to a file and operate on that. Or give the broken tool /dev/stdin as its filename. Or give it a fifo as a filename and "journalctl | /path/to/fifo.
> All the binary logs are going to do is make people have a cronjob to extract them regularly into a readable format.
For those who insist on that, yes. Most of them will presumably have logrotate set up anyway, so it's hardly more complexity. Or you can run a syslog, and trivially set up systemd to forward the log entries to that.
Meanwhile the rest of us will enjoy the ability to do things like specify a start and end time with command line switches when trying to find stuff in the log, filter by priority, filter by user, filter by pid. seeing only data since last boot, get the journal as JSON instead of having to rely on brittle text parsing of entries that contains less information.
Regarding the last point, here's an example of an entry from journalctl -o json-pretty:
{
"__CURSOR" : "s=56750fa36ad94eb99c00e7fd6854c400;i=2;b=2f533403d7a041e7a389e3a7090942de;m=172e6e4;t=4f7c809a2f61d;x=79a98b8a5116658a",
"_SYSTEMD_CGROUP" : "/system/cron.service",
"_SYSTEMD_UNIT" : "cron.service",
"SYSLOG_FACILITY" : "10",
"SYSLOG_IDENTIFIER" : "CRON",
"_CMDLINE" : "/USR/SBIN/CRON",
"MESSAGE" : "pam_unix(cron:session): session closed for user root",
"SYSLOG_PID" : "2398",
"_PID" : "2398",
"_SOURCE_REALTIME_TIMESTAMP" : "1398345421294046"
}It sort of okay when you only have one system that does binary logs, but what if you have 5 or 10, each with their own log format and little tool that I need to pipe the log file through?
The binary logs also assumes that you actually know where stuff is or that you're not going to look across multiple systems in one go. If you're large enough you'll have logstash/splunk or something similar where you have already de-binarized the log and this become less of an issue.
But for may of us doing a "grep <something> 2014-04-*.log" is something that's just natural and we come a bit hostile if you're trying to take that away.
That being said I think systemd might have a way of just giving you the log in plaintext.
Also, systemd writes syslog style plaintext messages to an IPC socket at /run/systemd/journal/syslog if needed for compatibility.
I wish the owner of that website would would make a better alternative instead of complaining.
There's nothing wrong with saying "I like Linux, but it's becoming Lennartix and I'm concerned."
As long as characters like this persist Linux as a direct end user system is going nowhere, and it will remain a lower level component abstracted away by higher level platforms, as in Android or Chrome OS.
For that tiny percent of use cases where services can do all kinds of crazy things and there needs to be extra control, other things like supervisor, foreman_god, daemontools/runit come into play. There are use-cases not many people have to deal with or even exposed to, yet are important considering the impact (say downing a major service like Gmail).
So, a collection of lots of single-purpose binaries that work together flies in the face of "do one thing and do it well". I kinda stopped reading at this point, which was sadly quite high up the page.
Is there any reason why you couldn't do so?
Found this chart: http://www.freedesktop.org/wiki/Software/systemd/InterfacePo... Note the columns "Reimplementable Independently" and "Known Other Implementations"
That's part of the reason why Ubuntu gave up and switched to systemd - a lot of the desktop stuff they shipped relies on logind etc upstream, and it just wouldn't be practical for them to implement their own versions of everything that got Borged by systemd. (Edit: in fact, that page lists logind as something that cannot be independently reimplemented or used separately from systemd.)
The attitude of the systemd (And Freedesktop.org folks in general - and please don't give us the usual Lennart cry of "No really, we're NOT the freedesktop.org people!" - despite all of these projects sharing a tightly knit community of people steering them) devs and their treatment of their projects has meant for some you basically do things their way or the highway.[1]
It's already a pain in the ass to strip udev out to keep using it if you've decided to not use systemd. And that's just taking one portion of the system that was promised to be kept easily independent of the rest of the muck, not trying to make other services work within the framework of a systemd system.
As it becomes the standard across all of the major distros, I find it hard to believe that it will become easier to separate systemd parts from one another than it is now, because there becomes even less incentive to do so.
I don't have much of a horse in this race, because I've long since migrated the vast majority of my production systems to FreeBSD and OmniOS, and out of the few that I have that are running linux still, some of them are using systemd. I don't particularly like it, but instead of complaining about it and doing nothing, I've minimized the impact I feel from it.
People whip out the Unix philosophy the same way they do every other philosophy: whenever it supports what they already want. I don't think it's a valid argument anymore.
I think arguing that systemd breaks with the unix philosophy is entirely valid -- it's taking what could (does!) arguably exist as separate systems with clean, separating interfaces into one monolithic whole for a somewhat unclear gain.
I wonder how hard it would be to write a compiler/translator from systemd service files to sysv init-scripts?
I am not much of a systemd fan so I may be biased but it is interesting read anyway.
Going point by point:
1. As the site says, systemd is both an init system and a collection of programs that make sense to have in a system. One can already strip most of everything from it (I think only journald is mandatory), and there is usually a stable api between every component, so one can simply replace them.
In fact, I believe that half of the complains about systemd would disappear if it all the tools were developed in a different repository and not under a "systemd umbrella" (Isn't one of the major point pro-BSD the fact that the base system is all developed together?)
2. If you want to use systemd but have plain-text logs, journald can pass everything to syslog and similar daemons. What everyone forget is the bonus that journald provides: no more "cat /var/log/*.log | grep <program> | sort -u" and hope that applications log in the same format, I have everything in a single place and can browse them by unit, by user, by time, by urgency...
3. I can agree with that. But it's not that sysinitv or upstart worked on non-linux systems (without ugly hacks)
4. And? I'm not sure what's the problem here. udev and dbus are mandatory by pretty much anything that's not a .sh script nowadays.
5. Okay, fair point. "It assumes that users and admins are dumb" can you really blame them?
6. Fair point again, systemd is bigger than sysinitv. But that's almost saying that we should all use microhttpd instead of nginx/apache because it's smaller.
Also the simple fact that it's included in RHEL 7 mean that it got audicted by RH, which make me feel safe.
7. That's just FUD. Here's Gnome 3.10 running on OpenBSD: http://undeadly.org/cgi?action=article&sid=20140219085851
Gnome will depend on systemd when under wayland, that's instead a fact. Actually, on logind, which has an api that anyone can reimplemnt (https://blogs.gnome.org/ovitters/2013/09/25/gnome-and-logind...)
8. Not true, again. Right now, on my system:
pgrep -l systemd
1 systemd
354 systemd-journal
386 systemd-udevd
766 systemd-logind
1190 systemd
1754 systemd
9. Fair point.
10. This might or not be possible, I don't have much experience in writing unit files so I don't really know the limits.
11. Nobody is forcing anyone to adopt systemd. It's getting adopted because distributions and developers think it's better.
And after months/years of complains about systemd, I still haven't seen anyone trying to produce anything that has the same advantages for sysadmins and programmers.
Really, that's how it feels: "I'm going to complain and complain and complain, but I won't lift a finger to change the course of events".
Can anyone make a point in favor of sysinitv (or against systemd) without bringing in abstract concept as "Unix philosophy" and plain wrong facts?
1. It now has a lot more attention focused on it, so it will get more scrutiny.
2. Unix admins have always been wary of the bleeding edge; distros are adopting systemd today, but those distros themselves are unlikely to see wide production adoption for a year or two.
3. If the systemd team's processes are not up to snuff, a major distro will fork it and run it themselves. If the criticisms have any merit, others will follow. It's why open source is such a great model for critical system software: it's as pure of a meritocratic model as you can get (well, if you accept the fact that merit is based on adoption.)
Basically, any new critical unix process is going to have these types of issues. The fact that systemd has a lot of support basically ensures it will get a lot of attention and bugs/security holes will be fixed.
On another level, I feel the "unix philosophy" of having a lot of interchangeable modules taking care of small, simple tasks hurt it: each level of abstraction has a performance hit, and having to support multiple components in a modular way makes change management a nightmare. There's something to be said for the elegance of tightly integrated components: you can make assumptions that you couldn't otherwise make in a more modular system. I can see how it would be a problem if systemd were proprietary, but it's open source.
For all other processes except pid 1, the status of processes in the system is in a state of Heisenbergian uncertainty because any process could die and have its pid taken by something completely different between the time you query the process table and the time you take action. So if you want sophisticated monitoring and control of all the processes in the system (and you almost certainly do), it should be done in pid 1.
The minimalist init is neckbeard-compliant, but it's just not enough for a robust modern system. Systemd is the correct design.
I think we tried that with openssl already.
I've accepted udev, but I'm still wary of dbus.
A lot of these complaints boil down to the fact that systemd is a single point of control for a lot of different functions. IMO systemd actually reduces overall system complexity by creating a unified interface for launching any sort of automated executables.
I don't know that this was the author's original meaning, but I think the much bigger problem is that udev and (k)dbus have become dependent on systemd. This has caused headaches for the Buildroot team with udev, for example:
http://lists.busybox.net/pipermail/buildroot/2013-March/0681...
How do systemd's proponents respond to these problems? GKH will say "just use mdev":
https://plus.google.com/111049168280159033135/posts/R387kQb1... (conversation about halfway down)
And if you need udev's features after all? "If you disagree with the current developers about decisions like this, then fork. And be prepared to handle the fallout." As in, be prepared for endless public derision by Lennart, GKH, Koen Kooi, and everyone else involved with systemd, as was directed toward everyone working on the eudev fork just for daring to make a version of udev that was no longer tied into systemd.
The author of "boycott systemd" complains that it is "heavily desktop-oriented". I actually like systemd, but this is a legitimate concern for a huge number of embedded Linux users, especially as systemd continues to assimilate peripheral projects. The concern is made much more severe by the confrontational and childish attitude adopted by systemd's developers and lead promoters in such matters.
2. So? Like text files can't get corrupted? At least journal has checksums to ensure that data is not unknowingly corrupted.
4. If I recall correctly, systemd can be used with static dev (with limited functionality).
5. That's not what I've gotten (Gentoo). Also, if it's an issue, it can be turned off.
6.
> it is far smaller in breadth than the Linux kernel itself, yet seemingly just as critical
Isn't it a good thing if stuff is smaller?
8. This isn't an actual argument. systemd has code to catch errors and infinite loop the program. It's not even internally consistent. "have fun rebooting, except my argument isn't even valid because systemd has code to reexec"
9. No, systemd is primarily concerned with glibc. Patches to run on other libcs are accepted if they do not unnecessarily complicate the code.
10. Without actual examples, this is a useless argument at best.
11. This is not a point, just name-calling.
The only stable APIs in systemd are the ones that the whole agglomeration of programs provides to the outside world. Anything else can and will change and break without warning according to the systemd developers.
>3. I can agree with that. But it's not that sysinitv or upstart worked on non-linux systems (without ugly hacks)
Didn't matter, they had their own init systems and until systemd came along very little software depended on a particular init system.
> Gnome will depend on systemd when under wayland, that's instead a fact. Actually, on logind, which has an api that anyone can reimplemnt (https://blogs.gnome.org/ovitters/2013/09/25/gnome-and-logind...)
According to the chart someone else linked, which I think is by the systemd developers, logind cannot feasibly be reimplemented and the systemd version can't be used by anyone else: http://www.freedesktop.org/wiki/Software/systemd/InterfacePo... In practice, no-one has managed to reimplement anything beyond the most trivial APIs exposed by systemd. Some (like the whole new-style daemons API used by many daemons ported to systemd) literally cannot be implemented by init systems that aren't structured the same way as systemd.
> 11. Nobody is forcing anyone to adopt systemd. It's getting adopted because distributions and developers think it's better.
In at least some case, it's getting adopted because important software has been rewritten upstream to depend on systemd.
I disagree that is what the chart shows. A bit later in the document they say
> If you decide to reimplement one of the APIs for which "Reimplementable independently" is "no", then we won't stop you, but you are on your own.
so I think they mean to say sth different than "the APIs can't be tried to be implemented at all".
I think when they say "reimplementable independently" they mean "to develop a feature-par system", which might be way too strict. For example, the unit format also is marked as "not reimplementable independently", when it is clear it is in some form; plausibly, some attributes one can specify in unit files as implemented by systemd can't be replicated in other systems, but that doesn't mean there can't be similar, partially-compatible implementations. I guess in some (most?) cases, those might be enough.
Also, logind's case might be marked as not reimplementable independently to discourage forks like Ubuntu's, which caused their version to remain stagnant when the API changed upstream. I'm not sure, but logind's API might still be a moving target, so a reimplementation might have to face some issues.
Regardless of what init system is right or wrong, the beauty of the Linux ecosystem is we can afford for different distributions each to make different decisions.
Systemd seems functionally better than both sysvinit and upstart and it certainly doesn't seem to be the root of all evil like this article makes out.
I don't believe that everyone boycotting systemd over what's currently out there will aid linux in any way.
We should not (re)write a lower level where all the components are so coupled we will be unable to change one of them with a better alternative without changing the rest.
Quoting the "Unix philosophy" as the reason to keep things like they were 20 years ago is laughable. I want to get things done, and managing processes using init scripts and daemonization is pain. Edit: I'v read the cached version now, and this assumption turned out wrong. The authors see a need to replace sysvinit.
The amount of bad and inconsistent init scripts, messy PID file handling, makeshift service wrappers, defective daemonization and logging workarounds is so much worse than having one place that will handle those ever repeated tasks.
I love that in recent years Linux (as in distributions) got an attitude and actively push things forward, without losing compatiblity to older software. Apple introduced launchd and nobody complained. We start to rely docker and all sorts of new approaches to manage our services and nobody complains. But init is somehow regarded as the holy cow noone is supposed to touch although everybody agrees it sucks.
Even if it's technically wrong: Unix as a platform is now Linux. Everything else is niche products, and we don't have to use the same init mechanism on Linux/BSD/whatever just because we can.
I have deployed the same software on Debian Linux, RHEL Linux and AIX and basically had to reimplement service management scripts for every platform to have the best possible result. How could this get even worse?
I'm happy about this movement.
In 15 years of sysadmin, I can say that writing init scripts never was a big issue. Maybe for "junior sysadmis" or those that are in the office by their last name.
I respect your opinion, but I'm very afraid of the course that linux is taking regarding system design (dbus, systemd, etc) and I resonate with that page content.
No newbie sysadmin should touch init scripts because they can't handle it.
Isn't it about damn time we go from overly complex to what makes sense?
“The only way to control chaos and complexity is to give up some of that control”
There's a lot of things newbie sysadmins are going to be bad at. I wouldn't expect them to come in and architect an infrastructure that will be handling millions of events per second, either. Nor would I expect them to be able to perform a deep dive and become performance engineers.
But sysvinit doesn't have to be the answer. I'm an Illumos guy. The SMF implementation is excellent, moves away from init scripts, and still doesn't throw the baby out with the bathwater like systemd does.
If I was interested in giving up control for the sake of reducing complexity, I'd go back to being a Windows sysadmin so I can click next on wizards and run dcpromo all day.
Jr: "I edited some init file."
Sr: "Which one?"
Jr: "I forget."
Sr: "Oh." sorts /etc directory by time "Oh, I see what you changed. That is wrong because of $REASON. You should do $CORRECT_THING instead."
Jr: "Okay, thanks for letting me know."
Sr: "We were all new guys once."
Good riddance to init files.
If these people want to keep people from using systemd, they need to come up with a better alternative.
The argument of "do one thing well" might be 20 years old, but no one is holding progress back -- rather raising voices against doing so by aggressively removing choice from the agenda with it's current implementation.
For example, I really do like how systemd-journald takes care of logging, although I don't know why it's not using plaintext log files internally. journald gives me the choice to not log to disk at all, which is nice on embedded systems and my notebook SSD. If i wanted to have logs the old way, i'd just attach a syslogd on journald's socket. With systemd and journald I can have my services log to stderr and everything just works.
I don't have to: * Log to stderr if my service can't start for some reason * THEN daemonize (which is a pain to do in node.js and python, and not possible in golang) * Then switch logging to syslog or my own logfile(s) * Think about logfile rotation * use supervisor or monit to make sure my services stay up
PS: as an alternative you could use a tmpfs to move /var/log (and other log directories) to RAM on an SSD system. Far less configuration required, in my experience. And it works with every *nix out there.
The OP is right: some stuff is so essential it should be centralized. Whether systemd is the right way to do that I don't know, but it certainly seems to the compromise we'll live with in the near future. Just as SysV was in the past.
Disclaimer: We are not sysvinit purists by any means. We do recognize the need for a new init system in the 21st century, but systemd is not it.
And I don't think that's an invalid point. I totally agree that a better init system is desirable, but I've also personally really struggled to understand why systemd is a good approach – it does seem, from someone who's not that close to the issue, that it's an extremely complex and monolithic approach to the problem.
taking the discussion out of the opinion level to a more factual level(eg. i like the boot speed of my archlinux machine but the whole consolekit(why did we get that to begin with ?)/logind/ridiculousness, logging and service files vs. startx and grep /var/log is annoying to say the least, but as i said subjective)
on a factual level we have ridiculous bugs specifically caused by systemd that take down your system, and the lead developers saying either i don't care or it's by design. let me bring a few examples:
https://bugs.freedesktop.org/show_bug.cgi?id=76935
> That is the expected current behaviour, "debug" can cause "too many" messages to be useful anymore if things are broken.
or this one, systemd segfaulting with cgroups off:
https://bugs.freedesktop.org/show_bug.cgi?id=74589
Lennart:
> To make this work we'd need a patch, as nobody of us tests this.
There were a few other recent ones. When your new init system consistently takes down your operating syste, because of stupid bugs, and the lead developers say we don't care, and even block efforts to fix these issues, you should indeed worry.
https://plus.google.com/111049168280159033135/posts/Kd57G8s1...
In fact Greg KH jumped in to play daddy, and wrote a patch where tom gunderson commented that that patch would not be merged as it's not clear what problem it solves.
edit: some say openrc is the one. here's a comparison:
https://wiki.gentoo.org/wiki/Talk:Comparison_of_init_systems
I thought OpenRC was that init system? Or what systemd baggage comes with it?
Also a lot of enterprise shops use daemontools and runit, because they just fucking scale.
https://raw.githubusercontent.com/steakknife/my_init/master/...
Another plug for daemontools-encore (last one I promise). The setuidgid(8) program in classic daemontools doesn't set supplementary groups, and a lot of people I know just end up just using sudo in their run files. If you use daemontools-encore though, you can just use `setuidgid -s` instead.
PS. Really, daemontools-encore should imo be called daemontools 1.x, but you know how djb feels about forks of his projects...
Here's the go version I wrote, so there's no need for dep on Python/Ruby/etc on the target system:
setuser USERNAME COMMAND [args...]
# how to build it
go get github.com/steakknife/my_init/setuser
go build github.com/steakknife/my_init/setuser
# creates setuser exe here
you serious? criticizing systemd by promoting a totally new and un-tested software written by a single (for-profit) company.
> Also a lot of enterprise shops use daemontools and runit
provably not true. most enterprise shops run RHEL/CentOS which, to keep support contracts, runs sysvinit or in RHEL/CentOS 6.x ran Upstart. RHEL/CentOS 7 uses systemd and is not going to look back. Don't forget, the "serious" distros have used sysvinit for a very long time. Then they tried out Canonical's Upstart for a bit and decided it was not a step forward, but rather a step to the side. Now they have landed on systemd for very good reasons.
daemontools is battled tested. We used it at Stanford on thousands of boxes. I used at a lot of shops, one in SF for example had 40k boxes (CentOS) and 6 ops staff, deployed via CFEngine. Heroku uses daemontools. On and on. Daemontools is mostly used when there is no desire/time to replace the existing init completely.
runit also scales amazingly well, even though it's more work to deploy.
Upstart is too unpredictable (flapping) and sysvinit doesn't do supervising very well, which is why important services are deployed with daemontools/runit.
Runit is great as a tool to manage your own daemons. But as a general init system for distributions? Not so much. Just take a look at the /sbin/my_init system that we wrote for baseimage-docker and what kind of functionality it adds on top of Runit, to give you an idea of why Runit by itself is not enough. Runit also performs no dependency management (i.e. starting one service before another) so it's quite painful in certain situations. For example, if you have a background queue daemon that depends on PostgreSQL, then you have to manually make sure that the daemon is not started until PostgreSQL is available. Otherwise you get tons of useless error messages as your daemon keeps getting restarted.
waitport [-u] port [timeout (float)] # -u = UDP instead of TCP
go get github.com/steakknife/my_init/waitport
go build github.com/steakknife/my_init/waitport
# creates waitport bin hereA collection of individual tools that can be cherry-picked to solve nitty-gritty problems.
Agreed. This is a big worry. When the lead developers of something this important sound this callous, I start getting concerned.
Linux distros have gotten worse and worse and worse over the years. (So has Windows.) Every 3 years the old way of handling configurations is thrown out and a new one put in place.
That said, I don't know enough to say whether systemd is fixing this problem or if it is contributing to this problem (which it could do even while claiming to fix the problem).
Linux itself would have been impossible if the systemd attitude had prevailed among older unix. Linux-only software is the open source community shooting itself in the foot. Systemd will break the community, which will be worse for everyone, linux users included.
This is the free market deciding that non-Linux unixes aren't worth anyone's time. If you believe in the free market, you should either stop complaining and get on the winning team, or hole up in BSD-land rewriting Linux software until you have a plurality market share.
Demanding that open-source developers donate their time to support your particular OS is just leech behavior. Mandating "support equality" is a step in the wrong direction. Open source became great by being free; let's not take that away.
If your OS doesn't matter enough to demand support, it's well within my rights as a developer to ignore you and your users entirely. Cowtowing to a hoard of complaining users is weak behavior.
If you believe that then why use Linux at all, when windows' market share is so much bigger? And I thought boycotts were supposed to be the free-market way of changing company policy.
> Demanding that open-source developers donate their time to support your particular OS is just leech behavior. Mandating "support equality" is a step in the wrong direction.
Not supporting *BSD themselves is one thing, but systemd explicitly refuses patches to make it more portable.
Boycotts are what shrill activists on the losing side engage with. The free-market way to change company policy is to start a new company and make new policy. Doing otherwise is just trying to leech off of the success of other, stronger people.
>Not supporting *BSD themselves is one thing, but systemd explicitly refuses patches to make it more portable.
This is exactly what OpenBSD is doing with LibreSSL, so excuse me if I don't listen to the pot calling the kettle black.
The fact of the matter is that Linux won. Systemd won. Alternatives had every chance to make themselves successful, but they lost, and they have nobody to blame for that but themselves.
The Unix philosophy (loose coupling of specialized pieces) is what permits you to get things done. It is the foundational theory behind the most successful architecture on the planet.
systemd is doing things the Windows way -- monolithic, tightly coupled systems wherein, using Occam's Razor, the explanation for some of the coupling has to go into the realm of the nontechnical.
Those of us who have to manage and create large complex systems sort of scratch our heads at the idea that desktop systems booting faster is an important goal deserving of all this mess. Linux on the desktop has always been terrible and will always be terrible, and getting to it a few seconds faster is not helping you.
This statement is so utter in faultiness, I don't even know where to begin. In the first statement, you say “Regardless of the truth of it; this axiom X is true.”, and introduce a logical paradox, similar to the sentence “This sentence is not true.”[1]. Consequently, you call Mac OS X, FreeBSD and alike niche. The former is the second most popular commercial desktop OS, and the latter is incorporated into the former and also is the OS that powers PlayStation 4[2][3].
You say that “init systems need not be compatible”, and I say yes. Also, OS interfaces need not be compatible. Implementations of C library need not be compatible either, nor implementations of C themselves. Why did the size of a byte were standardised anyway[4]?
> I have deployed the same software on Debian Linux, RHEL Linux and AIX and basically had to reimplement service management scripts for every platform to have the best possible result.
You wouldn't have to if there were a standard initialisation interface, would you?
> Quoting the "Unix philosophy" as the reason to keep things like they were 20 years ago is laughable. I want to get things done, and managing processes using init scripts and daemonization is pain.
You want to get things done today; I'd guess you'd also like to keep thing happening 10 years later, when Linux is no longer as popular (Software come and go, no-one can guarantee that, say, illumos[5] will not become more popular than Linux in 10 years). Would you rather run around porting your init scripts to the new OS a cloud provider fancies, which your boss fancies, or write new bugs (which some refer to as features)? Would you rather wait for the mainstream repos of your favourite projects to catch up, or just deploy the program and enhance the experience? Would you rather read pages of documentation for your new incompatible init system, or skim the frontpage of HN?
> We start to rely docker and all sorts of new approaches to manage our services and nobody complains.
Well, Docker is a containment and distribution solution and programs need not be modified nor need to have around Docker to run. It is reminiscent of a FreeBSD jail or a plain old VM.
> Apple introduced launchd and nobody complained.
Just compare the source trees, you'll be enlightened[6][7].
[1] http://plato.stanford.edu/entries/self-reference/
[2] http://www.phoronix.com/scan.php?page=news_item&px=MTM5NDI
[3] http://www.vgleaks.com/some-details-about-playstation-4-os-d...
[4] https://en.wikipedia.org/wiki/IEC_80000-13
[5] http://wiki.illumos.org/display/illumos/illumos+Home
[6] http://cgit.freedesktop.org/systemd/systemd/tree/
[7] http://www.opensource.apple.com/source/launchd/launchd-842.1...
edit: format references
My point is, even right now with sysvinit (and aix doesn't use it afair), i have to adapt a init script to every single unix/linux distribution i want to use my software on. At least, if i want to comply with that system's best practice.
With systemd and other init replacements, it's likely a few lines of config file i have to rewrite. Its much less effort to ship or adapt to a few of these than have a init script that works everywhere.
About other unixes: calm down, this is some process that supervises other processes, this is in no way comparable to making libc incompatible. I assume we're talking about servers here that run off the shelf distributions. For (virtual) appliances and embedded devices / firmware everyone will roll their own images with whatever init they're happy with. We don't have any influence on what commercial vendors do. If AIX feels like an 80s system (i know it's modern and powerful at the core) that's IBMs decision, but i don't hear any complaints that Linux distributions don't ship ksh in vi mode as /bin/sh anymore.
So, in this particular market and with the problem at hand, i don't see how and why Linux should wait for the sysvinit replacement that is able to make everyone happy and will magically be adopted by everyone.
And if some day illumos will succeed Linux, I'm sure people will manage to port their 10 lines of service config over.
It is not ten lines of service config being hard, though, it is grokking a new, ad hoc tech, which is necessary to get the most out of it. I have not a rage against systemd in itself; it is too low level for me to care about, process management that is, yet I'd support, to the last drop of my blood, a standard to cover initialisation. If I have to write an init script/config/whatever one day, I'd rather use a standard format that I can get to work on any system, than an ad hoc, OS-specific technology that I have to re-learn every time I switch operating systems.
You seem to overlook the importance of a process hat supervises other processes. I reckon that it should be so stable, one shouldn't notice it. That is possible if and only if the thing is tested and implemented according to a standard throughout long times.
I think it's a shame most of the original page comes off as backwards thinking, Unix nostalgia and FUD like claims.
Because this one thing is actually quite important and something we should care about.
You can claim that Linux is now Unix and everything else is just niches. Great. Like Hurd. Clearly a play-thing. No point being portable enough to work there.
However back in the days, Unix was the real thing and Minix/Linux was just a toy itself. But hadn't software initially been portable, Linux could never have risen to what it is today.
When we are making an init-system with Linux kernel-dependencies, and making other core platform services like DEs dependent on this init-system again, we are tightening the bonds beyond what's useful, effectively hindering other platforms from ever gaining mass adaptation, even if they should otherwise deserve it.
SO while I appreciate systemd in general there are aspects of this development I indeed thinks deserves some more and warranted criticism.
I suspect that one issue with systemd is that it aims to solve very real problem, but they are problems that not many noticed. Most of the stuff that's highlighted as benefits of systemd are things I never experienced, either I don't thing advanced enough or the issue has already been addressed by the distro.
Most of us are just going have some daemon/process that we want to start at boot and for that purpose systemd is going to look like massive overkill and overly complicated. That might be mostly a documentation issue, systemd could benefit for a "So you want to start at process" guide.
"Since systemd is very tightly welded with the Linux kernel API, this also makes different systemd versions incompatible with different kernel versions."
I was pretty meh about the whole systemd thing, but having to change userspace when swopping out kernels is a spectacular disadvantage. Imagine having to downgrade your distro whenever you need to test against older kernels --- madness.
This is especially bad with ARM/embedded stuff where one often runs a modern userspace with an older kernel.
So, if you have archlinux tracking the latest and greatest systemd, uptrading userland can make your machine no longer bring up everything (completely). But in my case the kernel is from 2011...
Can you give an example of the "no longer bring up everything (completely)"?
[1] ArchLinuxARM-imx6-latest.tar.gz from http://archlinuxarm.org/developers/downloads
[2] Phytec PhyFlex i.MX6 http://www.phytec.de/de/produkte/system-on-modules/produktde...
Recent systemd doesn't seem to realize that ethernet and the serial console device are actually there, it's waiting for dev-ttymxc3.device and sys-subsystem-net-devices-eth0.device ... but both are statically compiled in. So there is some issue with kernel 3.0.x.
"Doing one thing and doing it well" is a fine guide for system tools, but does not apply to everything - look at the kernel, or Gnome for instance.
I can understand suggesting to migrate to BSD, but Plan 9? Seriously?
And what's the purpose of the "Open Source Tea Party" picture? This surely is not the only picture of Lennart in existence.
I've never been happier.
Seems the authors forgot to give themselves the credit they deserve.
https://forums.darknedgy.net/profile.php?id=589 https://forums.darknedgy.net/profile.php?id=373 http://billyest.es/About_Me
Can't stand upstart and it's "Oh you wanted to restart your daemon, but I won't run the pre-start/post-start/post-stop actions you've configured me to", but that's just me.
Made my day. Emphasis mine.
When the neckbeards comes around complaining about "Unix philosophy" you can always tell them to use Slackware. And then watch them go silent.
So long as I can still get syslog style plain text logs, then I have no objections. Unix and text log parsing is unparalleled. If simple text log parsing and manipulation is removed (all binary with only xml or json), then I'd be very opposed to systemd.
(the site is unreachable at the moment).
it's always good to try a disruptive way on the side before it matures and gets accepted gradually, however with the direct support from Redhat(where he is an employee) this systemd thing carries much more power than a typical open source project, sigh.
I would rather stay with sysvinit instead of something like this.
I think he should be employed at Microsoft to help them revamp their OS or whatever, make it or break it there, but please stay out of OSS.
Systemd has won by being vastly superior to any alternatives. I suppose it's all right to use something else but the community has embraced systemd as the correct solution, and you lose community support and assume all the risk of breakage if you do not stick with systemd.
Systemd is better than Upstart, but it won in no small part due to politicking and strategically merging other projects that everyone else depends on.
---
systemd was created in order to improve the speed of booting up your system. I'm serious. It was created because waiting a minute to boot up your machine once was too long.
In order to accomplish those faster boot times, they ripped out the stock init system model, and created a monolithic, non-portable, non-backwards-compatible, kernel-version-specific, Noah's Ark of API calls and custom tools which use binary formats and incompatible IPC methods to start programs that were never designed to run that way. They made obsolete virtually every aspect of the operating system which used to work with existing applications to start and maintain the running of userland programs. For faster boot times.
Of course, most of you don't care because you don't have to maintain your system, as long as it just works. What does this mean for people who do work with the system?
First off, building tools that work with the system are now more complex. It used to be you could use any i/o or ipc method to do anything you wanted. Now you have to look up and call and API call - and if the API call you want isn't in systemd's tool, or it doesn't expose it in a way you can use in your program, tough. Better become a C programmer fast.
Second, better be careful how you update your system. Every version of systemd, and any software it depends on, could crash your entire machine if a bug is introduced. I weep for the poor sysadmins who push out an update to thousands of machines only to find a strange bug which takes them all down, all because systemd decided having an enormous codebase was worth booting 20 seconds faster.
I hope you've got money for a security audit. systemd has had nine security vulnerabilities in the past four years. For comparison, sysvinit has had one CVE - in 1999. I haven't found any CVEs or security bulletins for upstart, which sounds amazing to me.
When it comes time to porting your application to Linux, you don't get to just write it in a way that would normally work on most Unix-like systems (which would, at this point, be virtually every operating system that isn't Windows or Mac OS, and now Linux). Now you have a new porting target specifically just to get your application to run, and then you get to deal with the normal porting issues.
At the end of the day, systemd is a culmination of two ideas, with one result. One idea is that a "superior design" with "advanced features" is the only benchmark in which we should design and run a system. The other idea is that we don't need to keep compatibility with legacy systems or alternative platforms, because fuck users, admins, developers, security analysts, distro maintainers and portability teams, we want faster boot times , damnit. And it's Advanced! The result? A big fucking mess of complexity that breaks everything that came before, introduces security holes, makes it more difficult to modify or maintain your system, and breaks compatibility with other systems (even Linux ones).
But aside from all that, systemd is great.
Also the cost of maintain it and adapt applications who are tied to systemd is much more larger than adopting syetemd.
The only viable solution i'm seeing right now is: Use a mainstream distro with systemd or switch to other one which maintains their own init system like Slackware or Gentoo.
I'm tired of all this UNIX philosophy crap. I have been using Systemd for more than a year now, on Archlinux, and it has been a delightful experience.
It works out of the box and it gets a lot of things right. Journald is quick & easy to use and a real help in finding problems. No more searching around in log files and grepping. Dependencies between services are handled by the init. Services start with maximum parallelism. Writing .service files is really easy.
It simply has better UX than any other init system, and it's supported by a lot of distros. This means standardization and progress. No more developer time wasted on sysvinit scripts.
The posted link is the same FUD that I have been reading for the last year on various forums. Even if systemd can be a single point of failure, it's still way more stable than anything we have used before.
Wanting to do that, it doesn't make sense that they would shill for Slackware at the top of the page.
This is a different set of people.