Forgot your password?
typodupeerror

Comment: Re:launchd (Score 3, Interesting) 454

by Endymion (#47961265) Attached to: Fork of Systemd Leads To Lightweight Uselessd

I'm not talking about *init systems* - systemd was never "just an init system". Remember, it's absorbed stuff like network management and system authentication. That kind of feature often requries linking to (L)GPL code, and you can trigger the GPL's requirements depending on how you do that.

So Poettering wants to move all those function calls to (k)dbus. In his own words, "... the primary interfacing between the executed desktop apps and the rest of the system is via IPC (which is why we work on kdbus and teach it all kinds of sand-boxing features)".

Comment: Re:Not a boycott but a confirmation (Score 2) 454

by Endymion (#47961221) Attached to: Fork of Systemd Leads To Lightweight Uselessd

That's exactly my point. I'm suggesting the goal is to avoid making a derivative work. The GPL describes various ways to recognise a project as having "derived" from covered code, and linking copyleft and proprietary code together is one of them. (with some variation depending on if we are talking GPL or LGPL).

Remember that one of Poettering's goals is, in his own words, "... the primary interfacing between the executed desktop apps and the rest of the system is via IPC (which is why we work on kdbus and teach it all kinds of sand-boxing features)".

The point is if I want to do (for example) some sort of user authentication, I may have to link against libpam.so. This is something that would be reasonably commoon in embedded systems, and linking covered code into your embedded device (and having to distribute libpam.so with your product) could easily be a derivative work. (details matter, ask your lawyer about specific projecs).

Once absorbed into Poettering's project, you avoid all that risk because you don't interface with the system features directly and instead use "local RPC". This changes the project from being a potentially infringing derivative work into something that merely uses the tool. Merely using a tool that is licenced under the GPL is explicitly excempted, as the GPL only coveres redistribution and not use. ("GPL is not an EULA") This is a major change in legal status for your typical embedded device, which often wants a minimal OS to host their embedded app. They would also really like to avoid having to deal with the handling anything GPL. Changing to "local RPC" for all system interaction neatly fixes that problem.

We don't run across this pattern with traditional RPL tools, because it's bad for performance to needlessly serialize everything when you could simply call a function directly.

Comment: Re:Not a boycott but a confirmation (Score 2) 454

by Endymion (#47959705) Attached to: Fork of Systemd Leads To Lightweight Uselessd

The traditional RPC tools don't force a chane in API for local requests - they link against the same traditional .so file that any local app would use. That is very different from forcing dbus to be the only exposed API even for local use. Apache may provide features over sockets, but apxs(1) still exists and apr.h still exposes a traditional API.

I'm not a lawyer either, but this is obviously unexplored territory for the GPL (which doesn't have a lot of court precedent regardless of the current issue.

It's not like we'll ever find some smoking gun proof. This is simply the best theory I've heard.

Comment: Re:launchd (Score 1) 454

by Endymion (#47959485) Attached to: Fork of Systemd Leads To Lightweight Uselessd

systemd is designed to replace APIs based on {static or dynamic} linking with the dbus/kdbus IPC mechanism, as a way to use (L)GPL libraries without being bound by the (L)GPL.

Note that despite uselessd's much saner approach to technical features, the exposed dbus API is still requried. Switching to the uselessd implementation still enables this new type of "tivoizaiton".

Comment: Re:Not a boycott but a confirmation (Score 4, Interesting) 454

by Endymion (#47959449) Attached to: Fork of Systemd Leads To Lightweight Uselessd

That's the whole point of all of this mess: {,k}dbus

Neither an init system nor vertical integration are the goal. The one consistent thing in all of the "systemd mess" is to leave the actual implementation officially a moving target where the trditional .so based library APIs are either hidden and undocumented or they are left out entirely. This forces you to use an IPC mechanism (dbus/kdbus) instead of simply linking to the functions you need and calling them directly. Forcing data to be serialized/unserialized so it can be sent over IPC is not nearly as efficient as calling a dynamically loaded local function. The systemd people love fast thing ("boot time!", etc), so why would they require this slow IPC everywhere?

*** if you never need to link to a library to use it, you can "link" to and distribute GPL code without being bound by the GPL. Poettering's cabal and systemd is an attempt to enable a new form of "tivoization" ***

If you are technically only "using" a library (no linking, no modifications to the library), you have not "infected" your proprietary code with the GPL. It's slower, but computers got fast enough that it doesn't really matter.

The nasty part is that by forcing arbitrary incompatable interface with systemd, to run stuff like GNOME you have to provide the key dbus features even if you don't use systemd. The end-run around the GPL still works with uselessd or any other "systemd replacement".

Unfortunatley, Lennart's cabal has everybody discussing technical features so this obvious goal isn't even addressed.

Comment: So what's wrong with systemd, really? (Score 5, Insightful) 380

by Endymion (#47926785) Attached to: Torvalds: No Opinion On Systemd

(paraphrasing a previous post of mine, becuase more people should see this)

It breaks existing promises, and makes few new promises in return.

There has been a lot of talk about the various technical problems with systemd and its developers inexperience-betraying design decisions. As bad as those are, they miss the larger point. There has also been a lot of very important talk about philosophy of design ("the unix way") that again shows how little experience the developers have and their disregard for the work people have already done and will have to do to fix the systemd mess.

These topics are valid, but miss the larger problem that systemd represents and the threat it is to Free Software in the Linux ecosystem.

## The problem with systemd's design: embrace and extend ##

As an excuse for all the vertical integration Poettering's cabal have been busy aglutenating into what they still sometimes claim is "justs an init system" has been the laughable claim that systemd is in any way "modular". They claim that "modular" is a *compile time* feature, or some property related to the fact that they build several ELF binaries. This is not modular, because it does not represent some form of stable, well-defined API.

What is an API (Application Programming Interface)? It's not a technical feature. It is not documentation that describes how to use some set of features. It is not a calling convention. So what is it?

An API is a PROMISE .

It is a social feature, not a technical one.

The functions and documentation are just a particular implementation of that promise. The key attribute that makes an API an API is that it is a promise by the developer: "If you want to interact with some feature, this is the way to do so, because while other internal stuff may change at any time, I promise this set of functions will be stable and reliable".

Binding previously-separate features into one project is bad design, by itself, the problem with systemd. The problem came when Poettering stripped down the barriers betwen features with the specific goal of removing established APIs (and breaking existing promises that developers relied on). His stuff may compile into various separate programs, but Pottering is very careful to keep various key interfaces "unstable" (despite being good enough for RHEL), specifically to not make any promise about how those interfaces will work in the future. He likes to call this hididng of interfaces "efficency" or "removing complexity". What he never mentions is that many of us used those promises, and by removing them he has at best forced others to do a lot of work to fix the breakage, or at worse made various features impossible.

A good example is logind, which was absorbed into systemd just so promises about its behaviuor in the future ("stable APIs") could be removed.

The reason many of us that have been watching Poettering's cabal for many years now suggest these changes are intentional and malicious are based on this. Occasionally removing features because of a technical need or bug or security requirement is understandable. Purposfully stripping out entire sets of features - that is, the features that allow other groups to develop with confidence that some feature they won't simply vanish - is something entirely different.

If MS acted like Poettering's cabal and removed a formerly-public API that competetors used - while promoting their own product that happens to use internal, not-publicly-promised APIs, the world would be screaming "monopoly". This happened, and resulted in several high-profile court cases.

## systemd threatens the GPL ##

It goes without saying that many people would like to distribute various GPL licenced software and not be bound by the terms it requires. The fact that some of these same people use the courts to threaten people who do the same to their software is noted, but off topic for now. The problem is the linking clauses in the GPL. Link the wrong way with GPL software, and the so-called "viral" nature kicks in.

Systemd (via kdbus) are an end-run around this. By calling function calls "IPC", you don't have to link to the GPL licenced code. A lot of players are willing to take the loss in performance for the benefit of distributing GPL software "unmodified".

You may have noticed the "systemd way" (and to some extend, the "gnome way") has been to ONLY provide access across dbus (soon, kdbus) instead of providing a local library .so and .h you can use directly. When the "local" forms even exist, they are often poorly documented and usually unstable. You may have also noticed that for "compatability" (by fiat), the "not-systemd" replacements tend to talk over dbus, as that is the mandated "correct" interface.

Embracing and extending linux with systemd is only a tool. The goal here is a new form of "tivoization" - to let proprietary business use GPL code while never opening up their part.

Is this really what you want to support by using systemd?

//now that you know this, guess what the point of systemd's control of cgroups is really about

//hint: think proprietary/GPL isolation

Comment: Re:They are pretending that they do not know (Score 1) 103

by Endymion (#47925361) Attached to: NSA Director Says Agency Is Still Trying To Figure Out Cyber Operations

Admiral Rogers,

The anonymous letter above has some good ideas about respecting the Constitution. You swore an oath to defend that social contract, and that oath is one of the most respectible American values I know. i know nothing about you and your history, so I respectfully - and hopefully - give you the benefit of the doubt and assume that has an American Admiral, you understand words such as "oath", "honor" and "duty" better than most.

  The duty to defend the Constitution is not an easy one at times, but it is something your fellow citizens will respect. The would even come to aid you if you should need them; you only have to ask. Open up the whole problem, without the usual spy-talk filled with obfuscation and dissembling, and ask the many intelligent men and women - your friends and neighbors. The internet seems help us solve even complex problem when we work together. Yes, this might require retreating from some current investigations; the investment you would gain by having support by working with your fellow citizens will more than make up for any short-term losses. Call if a "strategic retreat", if you want.

The previous anonymous letter mentioned a key point:

if You've already hinted at part of the solution -- differentiate between a cheeto-stained guy in a Guy Fawkes mask, versus a PLA, FSB, or NSA operative who's actually trying to do economic harm to America...

This is a key idea, and the NSA - or, possibly, this country - cannot last if the intelligence community is undermining the rest of the country. We have already seen billions of dollars in damage over this, and cannot take much more. As a suggestion on how to address the problem targeting your collections, you may want to consider re-hiring William Binney and Thomas Drake. Their original program known as THINTHREAD may not be the ultimate solution to this situation, but the ideas it had about encrypting all captured until an individual warrant is provided seems like a good place to start.

This country, more than ever, needs people to defend the Constitution. It's a simple document, with good ideas. Now, more than any time in the last two hundred years, has our founding document and highest law needed defending. It has threats that are foreign, and even larger threats that are domestic.

Admiral, I do not envy your position and the hard challenges ahead of you. Fortunately, your oath makes the path ahead clear. Good luck and godspeed.

/not posting anonymously, because I stand behind my words

//just like I stand behind the right to post anonymously by anybody who so desires

+ - Yet more reasons systemd is bad...

Submitted by Anonymous Coward
An anonymous reader writes "One more reason systemd is bad..."rescue mode" is NOT single user mode! If I am in "resuce" mode on a normal sysv init system...my box isn't able to boot normally and I am booting off a DVD/CD. If I am on a normal sysv init system...I use single user mode to apply patches or do something that I don't want interrupted by network users.

systemd fans, please tell me the command to see what services I can expect while in "rescue.target" — in my old sysv init system I could check a directory or even run chkconfig to see what would/should be running. Please don't try to tell me that chkconfig still works...it is a shadow of the real chkconfig on a sysv init system!"

Comment: Re:Oh well ... (Score 1) 314

by Endymion (#47870111) Attached to: GSOC Project Works To Emulate Systemd For OpenBSD

This would be hilarious if it didn't imply such a terrible future for Debian. In the infamous debian-ctte arguments, one of the big reasons the systemd advocates insisted it was so important to only use systemd was their claim that maintaining multiple options would be far too much work.

I think it was only Ian Jackson that truly recognized that this wasn't a complaint about workload - it was a threat that systemd would become a moving target should Debian fail to conform.

Comment: Re:Oh well ... (Score 3, Informative) 314

by Endymion (#47859991) Attached to: GSOC Project Works To Emulate Systemd For OpenBSD

The thing the inexperienced systemd developers (but I repeat myself) do not understand is that "modular" isn't about some technical detail such as how you compile various features. For example, busybox intentionally compiles everything into one big binary. The features it provides, on the other hand, are still very modular in the UNIX sense. The key difference is that the tools busybox provides ("cat", "wc", "mkdir", "dd", and many others) all implement well defined APIs.

What is an Application Programming Interface (API)? It's not some function you can call, or the fact that a program understands some option ("--foo"). It is not even the documentation that may or may not be provided that describes how to use some feature. So what is it?

An API is a PROMISE .

It is a social feature, not a technical one. The functions, options, and documentation are just the technical implementation of that promise. The key part of an API is that it is a promise by the developer that if you want to interact with some feature, this is the way to do so, because while other internal stuff may change at any time, the promised API will be stable and reliable.

The problem with systemd is exactly this. Pulling a n00b move and agglutinating various features into one project is annoying and not recommended, but it is not, on its ownn, a reason to avoid systemd. The problem came when Poettering stripped down the barriers betwen features with the specific goal of removing established APIs. His stuff may compile into various separate programs, but Pottering is very careful to keep various key interfaces "unstable", specifically to not make any promise about how those interfaces will work in the future. He likes to call this hididng of interfaces "efficency" or "removing complexity". What he never mentions is that many of us used those promises, and by removing them he has at best forced others to do a lot of work to fix the breakage, or at worse made various features impossible.

A good example is logind, which was absorbed into systemd just so promises about its behaviuor in the future ("stable APIs") could be removed.

The reason many of us that have been watching Poettering's cabal for many years now suggest these changes are intentional and malicious are based on this. Occasionally removing features because of a technical need or bug or security requirement is understandable. Purposfully stripping out entire sets of features - that is, the features that allow other groups to develop with confidence that some feature they won't simply vanish - is something entirely different.

If MS acted like Poettering's cabal and removed a formerly-public API that competetors used - while promoting their own product that happens to use internal, not-publicly-promised APIs, the world would be screaming "monopoly". This happened, and resulted in several high-profile court cases.

So go ahead an prove that you don't know what you're talking about and assert that systemd is in any way "modular", when non-modularity was an explicit goal behind systemd. The rest of us are choosing to not go along with Poettering's attempt to embrace and extend Linux into a cheap, buggy, feature-free windows clone.

Comment: Re:What's wrong with Windows Server? (Score 1) 613

by Endymion (#47819315) Attached to: You Got Your Windows In My Linux

Ahh, and here comes the shill, with the usual personal attacks and strawmen. Yes, go ahead and praise Poettering's cult of personality and ignore the many people in this very thread who rebutted the nonsense that there was a need to replace "init scripts". By focusing on that point alone you get to pretend that systemd is "just an in init system", and hasn't embraced and extended a long list of other tools.

Evidence? LOL. More evidence that you are either lying to push propaganda, or shockingly ignorant of what Poettering himself has said about the state and future of systemd. Or do you not consider the creator and manager of systemd to be a reliable source? Do you want to still pretend this issue is about "just an init system"? Because that would essentially be calling Poettering a liar.

I'm sure you won't bother properly understanding this... at least in public. Obviously, the goal is to simply bully the people who disagree with you. Sorry, no, we aren't going to simply shut up, and stop pointing out how Linux worked just fine, despite your unsubstantiated assertions.

You want a suggestion on how to fix things? Stop breaking everybody else's code! Any minor problem that sysvinit had has been vastly overshadowed by the breakage systemd has caused.

Comment: Re:What do we need systemd for? (Score 1, Interesting) 613

by Endymion (#47814667) Attached to: You Got Your Windows In My Linux

While the obvious answer is that Poetternig/RedHat wants a windows alternative they can sell to "big" software developers, a more cynical (and mildly speculative) answer is that systemd is an outstanding way to shoehord into linux all the things that linux users would never normally allow. PID 0 is an important spot to control; if it wants to, it can control what programs are started and under what permissions. There are a few groups that really want this capability, or at least the capability to add something optional that can later be a forced dependency in GNOME or some other popular package.

The first group that comes to mind are the people who want DRM and a protected media path. A monoculture that forces features on users whever it wants to change things is the only way you'd get around the problem of having distributions simply compiling out or otherwise ignoring your DRM. Systemd has effectively raised the costs of not using whatever future "upgrade" is mandated, because the tight integration means you have to replace all the other software you now use as well.

Another group that would really like it if a buggy, alpha-quality, horribly overcomplicated, uncommented, unproven, monolithic black-box of software was a required to use Linux is... the NSA. Simplicity is important when it comes to key services like PID 0. I'm sure it's just a coincidence that the NSA is one of RedHat's larger customers, and that the NSA - while suberting NIST, Cisco, etc - submitted various pateches through redhat. I have no proof, of course, but you don't get security by assuming eveybody is being "nice". I strongly suggest listening to PHK's talk on this subject.

Finally, I'll link a post I just made over at HN. The reason systemd is causing emotions to run high is because it is trying to do to linux what has been done to many other tools: dumb it down and hide how it works. There are a lot of people trying to do that right now, because the idea of open computing that *cannot be limited* (see: "turing complete"). Welcome to the Civil-War On General Purpose Computing.

Comment: Re:The Future! (Score 2) 613

by Endymion (#47814557) Attached to: You Got Your Windows In My Linux

The fact that systemd is causing fragmentation - arguably worse fragmentation than any previous disagreement in the Linux community - is a valid (though not particualrly interesting) argument, because a primary design goal of systemd is conformity. Poettering has stated many times that his goal is to force distirbutions to use his one-true-way, and he often uses the supposed complexity of having to write portable code as an argument for why systemd and nobody else should be the software that manages the "core system".

This fragmentation means systemd is failing at it's own goals.

Uncertain fortune is thoroughly mastered by the equity of the calculation. - Blaise Pascal

Working...