Fried rice on the blackstone griddle

Tragedy is "a form of drama based on human suffering that evokes an accompanying catharsis or pleasure in the audience. Benno Rice drew inspiration from this definition in his talk at the 2019 linux.conf.au conference. His talk focused on the history of systemd, which has had its fair share of suffering. And the audience definitely enjoyed it, so it all adds up. All in all, it's a sympathetic and subtle look at one tumultuous chapter in the history of Linux systemd.
Rice was also inspired by an article by Aurynn Shaw on the so-called "culture of contempt." According to Shaw, people show contempt (for example, for developers who use a different programming language) as a social sign, a way of showing that they belong to the right group.
Certainly there is a culture in this story: large groups collectively show general contempt for systemd and for those who use it. Hence the concept of change or resistance. Yes, familiar things are convenient. But they are not necessarily good, especially if nothing has changed for years.
According to Rice, the origin of systemd stems from the roots of the Unix system itself, which was a "happy accident"-a reaction to the external complexity of earlier systems. Unix was radically simplified in every respect, including the loading of user space. An init subsystem took care of the whole "household", including the mount of file systems and the launching of daemons. Although these are quite different tasks, they were combined into a single process.
In those days the important daemons were few and far between: cron, update (whose job it was to occasionally write out file system superblocks), and the init process itself. By the time 4BSD came out, Unix had a proper getty daemon, network daemons like routed and telnetd, and the "super daemon" inetd. This is where things started to get interesting, but for a while it all worked quite well.
And then the Internet happened. Although inetd handled small amounts of traffic fine, it could not create a new process for each incoming connection. Meanwhile, websites had acquired databases and other stateful systems between connections. The notion of a daemon shifted toward "service", which is a different beast altogether. The old init could only start a service, but after that it became almost useless.
Part of the problem was combining services and configuration. Tasks such as mounting file systems are of the latter variety; they are usually performed once at boot time, after which they are forgotten. But this approach is not enough for automated service management, which requires constant attention. This is how service-oriented systems such as Upstart and systemd were born. Here Unix followed a path beaten by other operating systems. According to Rice, Windows NT had a strong service model from the beginning, and Mac OS still has it in the form of launchd. Other systems had to catch up.
Apple released launchd in the Tiger version, where it replaced a whole series of event processing daemons, including init, cron, and inetd. Thus, systemd was an attempt to borrow from the good ideas implemented in launchd. When Lennart Pöttering started to solve this problem, he first looked at Upstart, an event-driven system. It still worked on scripts, but Pöttering came to the conclusion that he could do better. In his article Rethinking PID 1, he lists launchd as one of the samples to work with. He thought about improving boot speed and the need to tune the init system to hardware and software changes in a running system. When init was created, systems were static, but today's environment is much more dynamic than it was then.
Classic Unix-like systems are divided into two main components: the kernel and the user space. But kernels have become more dynamic and changeable over time, adapting to the hardware on which they run. This led to the need for a new "service layer" between the kernel and the user space. This layer consists of components like udev and Network Manager, but systemd aims to provide a comprehensive service layer; that's why over time it has incorporated functionality from components like udev. The process was quite successful and was accepted by most (but not all) Linux distributions, although it was often accompanied by acrimony from the community.
The same arguments are often used against the systemd daemon: that it violates the Unix philosophy, for instance. Rice suggests that this argument is based on the notion that systemd is a single monolithic binary. In fact, systemd is structured differently: it is many separate binaries maintained within a single project. As a "BSD man" (he was one of the main developers of FreeBSD), Rice finds merit in this unification of related concepts. Systemd is not at all bloated and monolithic, as some critics believe.
They say that systemd has a lot of bugs. "It's software," of course it's going to have bugs, Rice said. The notion that, unlike any other system, systemd must be perfect raises the bar too high. At least systemd almost always has a reasonable failure mode, he said.
One complaint often repeated in one form or another can be summed up as, "I can't stand Lennart Pöttering." Rice refused to defend Pöttering's communication style, but said one couldn't help but admire Pöttering's strength of will and determination. Not everyone can go through all that. Systemd does not seek portability to systems other than Linux, which leads to a separate class of complaints. If systemd becomes the standard, there is a risk that operating systems outside of Linux will become even more isolated. Many people want systemd to stick to standard Unix interfaces, but Rice has a simple answer for them: "Unix is dead. Unix was once an exercise in ultimate portability and had real success. But now we live "in a Linux world with few rounding errors" (which it pains the FreeBSD man to say), and it makes no sense to stick to classic Unix interfaces. The current situation is a "pathological monoculture" where Linux can dictate the terms.
Systemd has gained a lot in such a situation. For example, control groups are a highly efficient and interesting process control mechanism, without them it would be much more difficult to solve these problems. They are much more powerful and detailed than the FreeBSD jailbreaks. Developers of systems like FreeBSD may see the intolerance of systemd as a threat. But this situation also gives them the freedom to work and find their own solutions to these problems.
So, what conclusions can be drawn from the history of systemd? One conclusion: the message transport should not be underestimated. Systemd makes heavy use of D-Bus, which gives it a lot of flexibility. Rice is not a supporter of D-Bus, but he is a big supporter of buses for messaging between processes. He used to lobby for such a native bus on BSD systems, preferably built into the kernel and with better security than D-Bus. On top of this you can make a proper remote procedure call system where kernel components and userland work at the same level. In a properly designed system, the process will simply send an API request without worrying about where and how that request will be handled.
Other lessons include the importance of maintaining a proper service lifecycle without having to install additional service management systems. It's important to set up service automation through APIs; and systemd provides much of this. Container support is also important: it is a useful way to encapsulate applications.

I got my boy 3 months ago, and we have either been battling an ear infection or digestive issues for the whole time. It's been draining for me and him and was causing me so much worry. BUT FINALLY, everything is looking on the right track. The third food switch was to Purina Pro Large Breed Puppy Salmon and Rice and that (hopefully) is doing the trick. Poops look great. Also he has SO much more energy now. I feel bad that he was feeling bad for so long (probably his whole life - 8mo) but so happy that he's feeling better now. :)