Also, you might want to check out Monty Python sometime.
The feared killer rabbit is a favorite. Encountering a killer rabbit, and being forced to defend yourself with the Holy Hand Grenade, is approximately as likely as said collision. Hence the Monty Python reference. Yet governments do indeed fight "holy wars", presumably with holy hand grenades, because nothing is too ridiculous for a government.

The point went right over your head, didn't it. The odds of that happening are astronomical, literally. Yet, it wouldn't be all that surprising if a government agency still managed to screw it up, against all odds - to snatch defeat from the jaws of victory.

For somw reason, it wouldn't surprise me if these two craft collided, despite being the only two approaching the entire planet. It just seems that any time a government spends a lot of money to do anything, it normally ends with a fail worthy of Monty Python .

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)".

Oilcan completely see how a security agent can open the lock by merely passing their forearm near the card reader as they approach the door. Wear the security card on the forearm, hip, or other appropriate place and even a relatively inexpensive reader such as many office buildings use will allow instant access by authorized personnel, while keeping unauthorized people out.

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.

It is a great fucking company. I use it for sourcing all kinds of things. The biggest problem is that their clients quite often have a poor grasp of English. Example, I'm currently looking for a small fan. I need it to ATTACH to a T8 LED and maintain roughly the same profile.

All I get are either quotes for 80mm computer fans, or T8 LED tubes. I even include a picture of the device I have in operation, with a rigged 80mm fan and plastic ducting strapped to the end of the T8 LED tube. It's like they ignore the picture, ignore everything, and only focus on key words. This leads to some of the shittiest customer service I've ever received. I want a fan, not a light. I already have the light, can't you see in the picture?

There are some foreign companies on there with excellent English skills. Those almost always get my business because the transaction and sourcing experience is so much easier.

If Alibaba could fix that one glaring issue, they'll be eating everyone's lunch.

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.

Absolutely there's no such thing as perfect security. I say that as a security professional. My wife, a childcare professional, will tell you that locking the front door is a good idea, if the house is a target. They spend a billion and half dollars every year on the secret service, who doesn't bother to lock the door. That's how government does things.

You're thinking desktop. GNOME is the leverage to force the change, not the end goal.

There are a very large number of devices out there running Linux in an embedded environment. These devices often have code running right on top of the minimal bootstrap/init tools.

Where is Boeing's reusable, low-cost, kerosene (safe) launch vehicle?

Came here to ask the same. Somebody is patent-troll threatening them from testing landings on a barge offshore which was the sensible thing to do before actual land - for safety, not ease (waves). I'm planning to drive the family down for the first land landing, and it looks like imaginary -property knaves are doing their best to screw up this trip (and retard the progress of science and the useful arts, as usual).

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".

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.

The Obama administration chose to publish the ten-year cost number, because that makes them look better than any other choice. Too short and the startup costs aren't amortized much, too long and you get into the time period where we're scheduled to actually pay for much of it. Those 12 million people wil need insurance for the next ten years, so it's perfectly appropriate to talk about what it will cost to cover them for ten years. 12 million isn't a one-time number, as if they only needed coverage for one day. The number of previously uninsured people may covered may fluctuate a bit, but not by order of magnitude or anything like that.

No, that's not a mistake I made. I made a much simpler mistake, though - I lost track of the number of zeros ehile trying to calculate trillions in my head.