Where's their mailing list/forum?
I wonder if other complicated debates, especially political, could be presented in such a format, and if this would have a positive effect for informed democracy?
EDIT: You're right. Pressing each statement yields more dialogue, but without evidence, you can't progress.
I'd say the discussion is a good/fun thing to present in this form, but abbreviated.
Who made this (and part 2)? How can I find out if any more parts are made?
For anyone wondering, 4 votes are enough because Bdale's vote (the chairman of the Technical Committee) count as two votes in case of a draw.
EDIT: see this (https://news.ycombinator.com/item?id=7203479) comment below - if the other 4 members of the TC vote F, then systemd would not win.
So far one of the four remaining committee members has done this, another is expected to, leaving the decisions of the remaining two to determine whether the vote completes or not.
Are you referring to the "Technical Committee makes decisions only as last resort." paragraph of the Debian constitution? It's a bit cryptic for a non-native like me, so I'm not sure that I'm reading it right.
In this case F (further discussion) is the default option, and this stage in the voting process precedes the casting vote.
I too think it's unlikely that both Colin and Andi will block the decision, but we've known it's likely that systemd will win for some time now. It's still not yet official.
edit: actually there are other possible outcomes, see https://lists.debian.org/debian-ctte/2014/02/msg00309.html
For those unfamiliar with Pulseaudio development, it's a third-generation audio subsystem (after OSS and ALSA with JACK forming two previous ones, and ESD being the beginning of the third) that is famous for overcomplicated, non-human-writable barely human-readable configuration procedure, development marred with huge number of bugs that ruined audio on Linux until recently, and suffering from immense number of internal interfaces and system being presented as a huge monolithic piece of software that can not be used in a modular manner except as modules that only talk among themselves.
systemd seems to suffer from the same problems, plus it tries to "integrate" init, udev and syslog into a single "product", with arcane internal interfaces and formats -- just as non-human-writable as Pulseaudio.
The Lennart hate is ridiculous. This time, even Linux kernel hackers think systemd is a good idea. What are your credentials?
There are other hackers around that are not "Linux hackers" who might have a different view about the quality of Linux space. I tend to agree with them.
When I put this next to the half-success that PulseAudio is (which was similarly promoted and blindly embraced by all major distributions out there), I find questionable the idea of systemd being the next best thing since hot water.
First of all, Pulseaudio was not the biggest success, true, but can't someone learn from their mistakes? Both are also living, moving software products that continue to improve, as you said, "development marred with huge number of bugs that ruined audio on Linux until recently" - key words: "until recently".
Secondly, about the technical aspects:
http://www.freedesktop.org/wiki/Software/systemd/ -> "The systemd for Administrators Blog Series"
Lennard Poettering said it better than I ever will.
Judging by his work and his writings, Lennart probably sleeps with a copy of "The Unix Programming Environment" or other such classic under his pillow. He probably knows Unix 10x better than you or me (feel free to point me to your resume/bio if my assumption is wrong :) ).
Just say that you don't agree with his design.
That's fine and it's acceptable. It also turns this debate into something kind of like Linux versus Minix. Working code (his) wins for now ;)
In my opinion, there is no replacement for true modularity, simple, future-proof interfaces, and clear, human-readable and human-writable formats.
I've been running systemd as my init system for at least a year. It's also used in Fedora. It is working pretty well by now.
> In my opinion, there is no replacement for true modularity
Systemd is an ecosystem. It contains a number of different binaries. They may be part of the same codebase, but so what?
>, simple, future-proof interfaces, and clear, human-readable and human-writable formats.
You mean, like systemd's unit file format, which is both more readable, and more specified, than the sysvinit boilerplate? If you mean journald, if you have rsyslog as well, you get your usual /var/log/syslog. Best of both worlds.
"Ecosystem" == vendor-managed closed system.
True interoperability does not produce "an ecosystem", it produces standards with (at least potentially) multiple implementations.
> It contains a number of different binaries. They may be part of the same codebase, but so what?
So it's contrary to the idea that modularity is achieved through clearly defined interfaces, so "the same codebase" is an unnecessary luxury for lazy designers.
I'm sorry, but you're not making any sense. If a closed system is a project you can fork on github, with ~ 260 contributors and libraries like python-systemd, I don't know how you define "closed".
> So it's contrary to the idea that modularity is achieved through clearly defined interfaces, so "the same codebase" is an unnecessary luxury for lazy designers.
Right. So, the systemd Debian package on my machine has 21 separate binaries. Who in their right mind would want to have 21 separate repositories to keep in sync?
As for "cleanly defined interfaces", I don't know how having several different systems in the same codebase prevents that. Which parts of systemd do you feel are not well-documented and prevents you from writing code to interact with it, or replace part of it?
 never encountered a single issue with systemd since archlinux pushed it as default, even on hybrid sysvinit scripts and naked systemd installs, compared to PA which may crash far too regularly, but that's just me.
If the downsides are so severe, it must have some really good upsides, otherwise no one would use it.
My personal anecdote is that Debian installed it for me on my long running system and that I've never touched a config file or otherwise looked at it at all and that my audio always works...
For the most part it can get confusing for a non day to day system administrator when I am trying to get a program to "run on boot". Between rc.local, init.d, run levels, etc. sometimes it is just frustrating.
systemd: dependency based init system. A service is written by declaring which services need to be started for that service to start. It is also a syslog like program (journal) and a cgroups writer (cgroups are a cointainment feature of the linux kernel). It also features socket activated and bus activated services, where the init system watches for a socket or dbus bus to be accessed, and then starts the job then. It is criticized for being too invasive and too tied to linux kernel features (like cgroups).
Upstart: an event based init system. Jobs start and stop on a certain event (or events). These events can be socket events, dbus events, udev events (network-device-added, removed, changed, etc.) or job events ($JOB-started, stopped, starting, stopping). There are also other events, but those are the basics. It suffers in two areas: socket activation is limited to one tcp or unix socket (no UDP, no tcp6, no DGRAM), and it unreliably stops services. The former is a simple problem that would not be too much work to fix (the developers of Upstart did not want to use socket activation, so they decided to stop efforts on developing it), and the latter is a fundamental code problem. Upstart uses ptrace to track daemons, while systemd uses pidfiles and cgroups. Because Upstart does not use cgroups, it can not kill all of a services children (just that service), and so zombie services might be problematic.
from my (very limited) experience with upstart, even the upstart scripts themselves can get into a unrecoverable zombie state, where the only workaround is to do one of the following 1) reboot ; 2) run some crazy-ass script that forks processes until the right pid is grabbed to then kill it ; 3) rename the upstart script
launchd is the init system used by Mac OSX and has been ported to FreeBSD a few years ago with a recent resurgent effort for improvements . It has been suggested that launchd could one day be the new FreeBSD init system due to speed and feature improvements, but many FreeBSD users think that the init system is a non-issue and efforts could be better spent elsewhere. launchd has also been criticized as to have been developed for OSX and not BSD (e.g. it depends on CoreFoundation features).
There is growing concern that applications will become more reliant on systemd and therefore Linux-only features , reducing or eliminating portability to the BSDs. Unfortunately, most conversations about init systems and FreeBSD degenerate into flame wars .
It features service dependencies, log collection, fault detection and much more. One of the biggest differences is probably the usage of config files. SMF uses XML files to describe the service and its variables and a program called svcprop to edit variables and create new instances of the service. These can then be managed with svcadm.
sysvinit/bsdinit - Starts daemons in serial (i.e. synchronously). Considered slow and outdated by today's standards.
upstart/launchd - Starts daemons in parallel, based on which daemons depend on each other (If B depends on A, A is started first. If C doesn't depend on anything. C is started at the same time as A. If D depends on C, D is started at the same time as B, and so on).
systemd - Creates all the necessary sockets for each daemon beforehand, and starts nearly all processes in parallel.
Aside from that, they're all configured differently, but if the competition is primarily over speed, systemd wins every time due to its clever design. the newer inits also include a lot of handy tools that aren't part of a traditional init, but that's a different story.
upstart doesn't have dependencies thats systemd. Upstart you have to specify when a service should start based on events or combinations of events like "start on started avahi and started nfs". Theoretically this make upstart more flexible though complex event handling is mostly broken. This system also means upstart ends up trying to start everything it can it might start a service which is not needed but because it's start on event has activated it starts. systemd differs in that only required services for that .target are started (and services required by those.
systemd has Require/Wants to specify dependencies as well as the socket activation features. Socket activation requires a compliant daemon as well so a lot of services still use explicit dependencies. Socket activation does give you a lot of other stuff for free, listening on privileged ports as user, restarts without dropping connections, delayed start (not starting until requests come) etc.
Linux systems traditionally use "SysV Init", the init system from AT&T UNIX System V (1983). It's the one that has: 1) run levels; and 2) a pile of shell scripts in /etc/init.d that run on run-level changes. Run levels probably make most sense if you think of Ye Olde Mainframe booting: first it initializes core services, then it enters multi-user mode, then it initializes network services, then (optionally) it enters full application mode. These are supposed to be discrete, semantically meaningful boot levels that you could purposely initiate: boot to runlevel 1, boot to runlevel 2, drop back to runlevel 1. Dependencies are handled by a mixture of those runlevels, and scripts that are run in alphabetical order within run levels. That ordering (unlike runlevels) is not supposed to be meaningful to the sysop, but just necessity-based: some stuff depends on other services already being started, even if conceptually you want them all "at once". The convention is to prefix startup-script filenames with numbers that effectively serve as priorities within a runlevel.
BSD systems traditionally use their own "BSD init". There are no runlevels, though there is still a separate "single-user mode" for maintenance. In classic BSD startup was just one very large shell script in /etc/rc. In later versions it was augmented by an /etc/rc.local script that allowed local modifications to be made without mucking with the main script. Modern BSDs (starting with NetBSD, later adopted by the others) modularized it, with an /etc/rc.d directory (base system) and /usr/local/etc/rc.d/ directory (ports). This differs from SysV init in that it still has no run levels, and rather than explicit ordering via filename sorting, has dependency-resolution ordering via semantic comments at the top of each script that are parsed and resolved by rcorder(8) (http://www.freebsd.org/cgi/man.cgi?query=rcorder&sektion=8). Afaik this system, originating in NetBSD, was the first dependency-based startup system on a free Unix (I believe commercial Unixes like Solaris also moved to dependency-based init in the 2000s).
Many Linux vendors have decided that SysV Init is not such a nice system nowadays, because it involves maintaining fairly complex scripts with edge cases that have to be handled in every script through error-prone boilerplate, and an explicit global startup ordering: all programs that can be installed on Debian and need startup must be assigned an integer that fully specifies their position in the startup sequence relative to all other programs that might also be installed. Runlevels as a mechanism also seem pretty unhelpful for most uses people have nowadays. Instead there is a hope for some kind of dependency-based startup. But the big disagreement is over what to replace it with. It is also complicated by other changes that are happening in parallel and which are caught up in it. For example, Linux's 'cgroups' resource-control mechanism has long been in the kernel, but not widely used by userspace tools, and there are moves to sort out this situation by essentially letting the init system also own resource assignments, which would more tightly couple those components. This is probably where the big philosophical differences come in.
You are correct. Solaris 10 introduced SMF (http://docs.oracle.com/cd/E23824_01/html/821-1451/dzhid.html...), which kicks quite a bit of ass.
Services are defined in XML files called manifests, which specify dependencies (including filesystems and network connectivity), the user and group to run as, timeouts for start/stop, and a bunch of other stuff.
The cool part is that, while the manifest files are static, SMF doesn't actually use them directly. The service definitions get slurped into a DB, and you can change properties (such as the whether or not the service is enabled, the user to run as, and pretty much anything else the manifest author thought of) on the fly, without editing a manifest or mucking with symlinks.
SMF also starts services in parallel (Solaris/OpenSolaris boot really, really quickly), and services that die are automatically restarted (so long as they're dying again too quickly).
Congratulations on a very well-written summary!
The way it was supposed to be?
Personally (perhaps being the system I used) I think it's great - very easy to work with, and I've had no stability problems with it whatsoever.
Pretty unfortunate it took this long. Even as a casual observer it's looked like they'd eventually pick systemd a month ago. Hopefully this vote is the last one.
Steve Langasek objected to the wording of the "tight coupling" and "loose coupling" options, and several others on the committee decided to vote Further Discussion first in response to that. It turns out that Steve (upstart maintainer) and Russ (primary systemd advocate on the committee) both agree fairly closely on that issue, in that the committee really shouldn't be ruling on that question in that way.
Ian is speccing it out so that nothing may ever rely on capabilities provided by a init implementation unless the Debian developers add that functionality to every possible init system in the archive. That is a very odd position, to put it mildly (you couldn't e.g. ship a GUI tool to manage upstart. You'd have to rewrite it to support systemd, as well).
I was rooting for upstart for years but it's hard to take seriously as a project when basic sysadmin tasks are still gratuitously hard / unreliable.
What are you talking about?
They should have copied prior art from launchd or some inetd implementations where the delay has a back off mechanism with some configurable min/max limits.
Moreover systemd has defined a bunch of stable interfaces; one could choose to expose equivalent interfaces in the HURD rather than port. Upstart seems to be in the "implementation = interface" camp.
Edit: Upstart was a great sysvinit replacement, at least during those years before systemd appeared.
I'm honestly not sure if you are making fun of upstart or if you're trying to say that having to keep a sysv compatibility mode around because upstart is not able to handle an extremely common daemon is somehow acceptable.
For what it's worth, Docker containers are generally not complete running machines with their own init system. Instead, they're typically a single top-level process running in an isolated container. Basically, they work more like a Heroku app than complete EC2 machine image.
For an example how you should build a Docker container, take a look at http://phusion.github.io/baseimage-docker/
More on the Debian debate:
And the Phoronix has a good overview of how this is playing out:
I found this explanation of systemd interesting (though more suitable for a wannabe hacker than a 5-year-old (though I suppose the two sets may not be disjoint)): http://0pointer.de/blog/projects/systemd.html
tl;dc: systemd replaces the bash scripts you're used to grepping through with unix .conf files that fit on the screen.
And that's what technical (sub)committees are for.
PS I would vote for "further discussion" in a very Debian style.
Writing my first Debian package, on the other hand, took me a day. Documentation is horrible. All tutorials are outdated. All the documents throw tons of jargon at me and just expect that I understand them. The tooling consists of 300 different tools with a lot of overlapping functionality, mostly for historical and backward-compatibility reasons. Debuilder, pbuilder, dpkg-buildpackage, debhelper, cbbs.... what? Learning all this stuf was a nightmare, while RPM was pretty straightforward.
Furthermore, Debian packaging tools don't have a preprocessor. It seems they really expect me to repackage my app separately for every distribution version. RPM on the other hand has a builtin preprocessor so that I can customize my specfile on a per-distribution basis with only a single file and a single tool. I ended up writing my own preprocessor for Debian packages, but something tells me I shouldn't have to.
On the other hand, RPM does not support "Recommended" and "Suggested" dependencies which are very useful. Neither does it support OR statements in dependency specifications. This latter sucks, a lot.