Slashdot Mirror
Linux Foundation Chief: Businesses 'Will Fail' If They Don't Use Open Source Code (techrepublic.com)
The luminaries speaking at the Google Cloud Next conference had some strong words about the importance of openness, innovation, and a rich developer community. An anonymous reader writes:
First Vint Cert said there's a "thread of openness" that runs throughout the internet, adding that "the internet, itself, has open characteristics" and thrives on "permissionless innovation." And Eric Brewer, vice president of infrastructure at Google, touched on the same themes, according to Tech Republic. "Linux, Brewer said, won some of the early internet wars because it was open, but also because it was the most innovative of its time. He also said that companies should work with open source for the value of the ecosystem and community, not just the value of the code." Then Linux Foundation executive director Jim Zemlin told the audience that business models were already changing to include open source, and ultimately made the argument that organizations that "don't harvest the shared innovation" of open source "will fail."
After seeing how GNOME 3, systemd and PulseAudio have destroyed Linux's usability for me, and after seeing how Firefox has gone way down hill, I have to question the involvement of large organizations, profit-driven or not, when it comes to the development of open source software.
The best open source software I use on a daily basis is developed by a single individual, or perhaps a small team at most. This software is usable and pleasant to use, perhaps because the creators are often among its heaviest users.
The worst open source software I have had to use has been developed by corporations or large organizations. In some cases this software has been supremely disruptive, especially when it has been forced on unwilling victims, like in the case of systemd. It's really strange to talk about the "ecosystem and the community", when software like systemd has, in my opinion and experience, inflicted great pain upon both of those things.
Those things Google mentions-- like "Permissionless innovation" and the like-- those frighten the shit out of businesses who revolve around gatekeeping.
You see, to stay relevant in such an atmosphere, one has to actually be innovative, stay innovative, and be among the most innovative. That costs money and effort. Innovating early, then stagnating the market with gatekeeping and patent abuse allows them to reap big financial rewards for years while doing nothing but placating shareholders. (See, EG, the likes of Oracle.)
Google is *really* telling them that their market abuse strategy is doomed to failure, because innovators will not be discouraged by their heavy handed attempts to stop them, and the internet amplifies that innovation.
Expect lots of denial, gnashing of teeth, and doubled-down litigation in the near future.
Gnome3 and its ilk, are the result of developers (and especially designers) not listening to their userbase.
"But the menu based metaphor systems are so... OLD!" is not a justifiable excuse for not respecting user feedback about your choices as the dev team/designer.
The same same is true for things like Pottering's systemd.
"Script based inits, like found in sysv init, are just so OLD!" is not a justifiable excuse for its removal.
If you are a developer/designer, and you disagree with my attestation that just because something is old does not mean you should remove it (or replace it with something else), take this to heart:
The air you breathe now is several MILLION years old. Why not replace that old, ancient air with something new, and edgy-- like ionized plasma freshly born from inside a star!? No, you don't like that idea, because your lungs aren't able to handle highly energetic plasma? Fancy that-- your end users have systems that are not able to handle having the init system changed willy-nilly either.
Gnome3 and its ilk, are the result of developers (and especially designers) not listening to their userbase.
The Gnome 3 designers aren't entirely to blame for the mess. Experimentation is a good part of innovation, or we'd be stuck using the teletype terminal. The problem is the speed with which the experiment was mainlined or adopted by the major distributions as the one and only true path to desktop nirvana. If they had allowed, say, a five-year phase-in period where features are added gradually then maybe users will get used to the new supposedly touch-friendly interface. Also a "classic" interface should have been available from day one even if it wasn't the default.
A good example of how this could be done is the evolution of the Google home page. Without Googling for screenshots, who can actually tell the difference between the Google home page now and then?
Deja vu: In the 80s we had a 70ish actor as POTUS, a woman PM in the UK, and a bald leader of that other nuke superpower
Please elaborate on what you mean.
One problem for large banks is that they are tied down in systems written in Cobol a long time ago where only few persons have a good grasp of what the system do and with parts that nobody dares to touch because it works but nobody knows why since the person who wrote that stuff once has passed on to the afterlife.
If builders built buildings the way programmers wrote programs, then the first woodpecker would destroy civilization.
that if you are a software company whose software doesn't fall under the "blessed trinity" then it would be SUICIDE to go FOSS as you won't be able to make enough to keep the lights on!
Ever wonder why no FOSS game has taken game of the year? Why after all these years the only "competition" to Photoshop that is FOSS is literally some kid's school project? Why all those niche applications like medical diagnosis and billing are never FOSS, or why programs like GnuCash are a bad joke compare to commercial products like Quicken and Quickbooks from a decade ago? The answer is actually quite simple which is FOSS works on the blessed trinity and if your software doesn't fit that model you have no chance to survive and your company will go under. We've seen it happen time and time again, in everything from Windows to Linux game converters to repos for commercial software to OSes themselves, if it doesn't fit the trinity model? It has zero chance.
This is why FOSS will never become the dominant license, why despite MSFT doing everything short of making a high res Goatse as the default wallpaper Windows 10 continues to grow while Linux is flatline, it all comes down to the trinity simply not working for the vast majority of software out there and without the software people want and need to do their jobs? You might as well be offering to trade their PC for a potato. For those that do not know what the blessed trinity is, its 1.- Selling services, 2.- Selling hardware, and 3.- e-begging. And if your software, which more than 95% of the software used daily by hundreds of millions qualify, doesn't work under this model? Then FOSS is suicide because you simply cannot make enough money to keep the lights on in FOSS if you don't fit the trinity model.
I really wish it wasn't so, Windows 10 is such a nightmare it actually makes the thought of the return of the Ballmernator look like the return of Steve Jobs to Apple, and Google and Apple are racing to see which one can become the most Stasi like when it comes to gathering data, but as long as FOSS is so politicized and rigid that an individual or company cannot sell more than a single copy of their software before someone else gives it away for free? Then FOSS will stay exactly where it is, a niche tool mainly used by multinationals as a way to avoid licensing fees on their servers and to not have to pay for the software which they use on their hardware...which is of course #2 on the trinity..
ACs don't waste your time replying, your posts are never seen by me.
> The best open source software I use on a daily basis is developed by a single individual
From a business perspective that would be risky unless it is not in any way business critical.
It's not so much about the paycheque, it's about the layers of indirection between the developer and the user. For a very small open source project, the developer and the user are the same person. The project grows and gets more users, then the developer is one of the users, but still directly in contact with people who have other use cases. Then the project grows a bit more and there are multiple developers, but they're all still users.
Then it grows a bit more, and now other people are paid to work on the project. They're paid by companies that are using the software though, so even though they're not users then their pay check depends on keeping at least some users happy. It's not ideal, but it's better than the next step.
The final step mirrors proprietary off-the-shelf software development. A company like RedHat or Canonical (or Moz Corp) starts paying developers. This company may not be using the software much, but ships a product that incorporates it. They have customers that use the software and so need to provide features that those users need, but they also need to justify why those customers should buy the new version or keep paying the support contract, so they have to demonstrate change. Once this happens, there are two layers of indirection between developers and users and the incentives are no longer aligned between the two. Software generally goes down hill at this point.
There's a related issue with open source software that's less common in COTS proprietary software: the fame issue. Once a piece of software is popular, there's a big ego boost for some people in contributing to it, because stuff that they did is widely used. There's an even bigger ego boost if a change that they made is one that everyone knows about. This gives a big incentive to change things that users will notice and those changes are not generally because the user wants them.
I am TheRaven on Soylent News
A lot of banks run FreeBSD. Quite a lot still use OpenVMS. Back end stuff varies hugely and includes Linux, FreeBSD, OpenVMS, Windows, and even some more esoteric things.
I am TheRaven on Soylent News
But the other side of the coin is that with openness you get interoperability - people can build their own applications interacting with your platform. The sum of the parts is greater than the parts themselves. The alternative is a lot of manual labor moving information between systems with the result that either the job isn't done or it's prone to error as well as being a lot slower.
However it didn't really take off until Linux came around where people discovered an OS that could be adapted to their solution with no heavy strings attached in the form of licensing, just navigation around the GPL constraints which aren't that cumbersome compared to Oracle or SAP licenses.
Here's where I like to bring up a metaphor -- I see two roles to software development: the first is to raise the ceiling -- innovate and create something better than anyone else before you, setting a new "maximum" that all software can aspire to; the other is to raise the floor -- set a new "minimum" that all software should be better than.
For instance, the existence of free implementations of quicksort, bubble sort etc raise the floor, because now everyone can write software that sorts data with the same efficiency. Meanwhile, a custom-coded adaptive sort for an accountancy system raises the ceiling, because competitors have to try to improve the performance of their sorts to be seen as being as good.
I mostly like the GPL, but the problem is that it rarely if ever raises the floor, because copyleft licenses are not completely open in the same way the C standard libraries are. Yet there are components within most GPL projects that could be used generically and could be part of the common floor, but it will never be part of the common floor until all contributors have been dead for 70 years, and given that many contributors are pseudonymous or have incredibly common names, there's no way of doing due diligence on that... not that it is likely to be relevant by that point.
Imagine if the GPL was replaced with a copyleft license that expired after 10 years -- imagine how big a common floor we'd have. All the code released would be so old that it wouldn't be of particular interest to big companies, but people would be able to revive long-dead projects as commercial packages or as labours of love. We could go back and build libraries out of the proprietary code of older projects. A higher floor.
Got them moderator blues I blieve I walk out the do', With these mod-points I been gettin', I 'most never post no mo'
Or you are prepared to take over should that individual decide to retire from the project (not usually an option with proprietary software) or the software is sufficiently mature that further development is not needed (actually fairly common in business software). Again, advantage to Free software since licensing extra copies isn't an issue.
But it's a lot cheaper than starting over from scratch if a proprietary vendor decides to cancel the project.
UX is a very useful term. HCI people who know what they're talking about don't use it, so anyone who claims to be a UX expert has helpfully self identified as someone that it's safe to ignore.
I am TheRaven on Soylent News