The Fatal Error of Depending on ‘Proprietary’ Software

The title of this post comes from a comment in an article about the roll of FLOSS in the real world, the UK.

Rather than sticking to the UK, about which I know little except for some history and my ancestors escape from the place 150 years ago, consider the world. It is hard to find numbers about one country but M$ files these wonderful summaries about the world…

In a year lately, M$ will take in $20+ billion in licences for that other OS on client machines. An OS manages the resources of a computer or IT system, something GNU/Linux can do for a lot less. The typical PC with that other OS involves about $100 being paid for the licence to use the software with severe restriction. GNU/Linux costs something and that cost is easily recovered in the benefits of using it. Essentially it costs about what it costs to install it, a few minutes of labour. Globally, wages are between $0 and $100 per hour depending on the person, location and kind of work. On average people asked to do installations probably cost only a few dollars per installation if that much. Installations can also be automated so the world who have been buying PCs with that other OS has been wasting $100 or so per PC, for years. This is not getting good value for money or labour, paying for licences that are unnecessary to manage the resources of a PC.

Arguments are trotted out that we must use proprietary software because it’s necessary or better and because it only runs on that other OS we must have that other OS. This is a circular argument because it assumes the statement is true, that we must have proprietary software. If that is not true then we don’t need the proprietary OS upon which proprietary software runs. Nothing prevents the world from creating FLOSS that does whatever we need done in IT. There is no magic in M$ or Oracle or any other company that produces non-FLOSS. The world can do the same or better just because there are more of us and the cream rises to the top. M$ and others don’t make programmers. The world does that and can do without M$ and its partners.

The amount of money spent on non-free software is astounding. Some reports even recount tales where a business or government pays for licences that remain unused. It can’t be any less efficient than that. Because used software does the same whether it is FLOSS or non-free the entire budget of the world spent on licences is a waste. Unfortunately the world’s take of licensing fees for non-free software makes M$’s take for its OS small potatoes. Someone who spends $100 on that other OS will gladly spend $thousands on AutoCad or some other “must-have” applications. The error in assuming that it is the application rather than its function that is “must-have” is huge, probably hundreds of $billions annually.

IDC estimates that by 2014 Software as a Service will constitute 14.5% of global spending on software and will amount to $40 billion annually. That implies that $280 billion per year is spent on software. If you divide that kind of money by the average salary of a programmer, you find an awful lot of jobs are lost by using non-free software. In my world programmers earn $30K to about $100K for fairly routine stuff. Exceptional people and circumstances could give a higher result, such as owning the business. Many people in China earn far less. Suppose the average is taken to be $30K. $280 billion comes to about 9million jobs. By allowing only those programmers who work for purveyors of non-free software to work in the trade we seriously cost the world many paying jobs.

Objections will be raised that this calculation neglects all the “spin-off” jobs by salesmen and IT-people but those guys may well have similar jobs with FLOSS as well. Ubuntu has salesmen. So does Suse and RedHat. Even Debian GNU/Linux has unaffiliated people like me acting as “salesmen”. Much of that is volunteer work but still useful in the world’s economy. Businesses can sell services just as well as they can sell licences. The service is something productive and useful in the world. The licence being over-priced because it’s a “must-have” and single-source does nothing for the world except pay for some salesmen and programmers.

You can account for that in M$’s 10Q. Only about 1/8 of the money paid for M$’s licences goes to pay programmers. So, you have a very inefficient systems where one pays too much for the licences (because software can be produced at much lower cost) and where M$ does not put the money where it will do the most good as far as the end-users are concerned. This is the most expensive way of obtaining software imaginable. If the world needs software it should just hire programmers and make it happen. If the software an organization needs is beyond their means they should share what they produce with others who will do the same and Free Software will happen.

The fatal error in depending on non-free software is that FLOSS will happen just because sufficient numbers of people in the world exist who need the software. It is a completely wasted effort to support a small number of monopolists. In a few cases the number of users of a particular software might be small but in that case a business or organization can just hire programmers anyway. There is no need for some corporation to save us by selling us restrictive licences to use software we can create by other means. It is certainly true that for widely used software like KDE, or Mozilla FireFox or GNOME, GNU/Linux there is certainly nothing to be gained by using non-free software and a lot to be lost: jobs for programmers. M$ does not need all the OS programmers in the world and does not hire them. Should they be unemployed or underemployed? No. They should be working on a diversity of projects so when a real need arises the software or the ability to create it will exist.

“Fatal” is a strong term. No one actually dies using that other OS and non-free software perhaps but who knows the opportunities lost and the unnecessary malware and re-re-reboots that resulted from this crazy monoculture? It is an invention of monopolists, not programmers, not computer scientists, folks who just want to get on with the job of creating, finding, storing and modifying information.

About Robert Pogson

I am a retired teacher in Canada. I taught in the subject areas where I have worked for almost forty years: maths, physics, chemistry and computers. I love hunting, fishing, picking berries and mushrooms, too.
This entry was posted in technology. Bookmark the permalink.

9 Responses to The Fatal Error of Depending on ‘Proprietary’ Software

  1. oldman says:

    “The world can create its own software. The world does not need any monopolies in doing that. Is the free market dead? Why encourage monopoly?”

    The world DOES create its own software Pog. However in the case of personal desktop computer market, it chooses to create that sofware for the windows platform. The reason for the ISV’s is simple – its where the market is!!! People like myself want the features that they offer and have no problem paying a fair price for them.

    Whether this encouraging or discouraging so called monopoly is not even a consideration to the would be commercial software users (like myself) who simply wish to use software not write it. You are going to get neither sympathy nor interest if you attempt to convince the vast majority of would be software users that they should forego a commercial package that both meets their needs and fits their budget, for a piece of FOSS that needs work by someone (them or some unspecified other) to make it work for them.

  2. The first comment was about creating software not buying licences. The world can create its own software. The world does not need any monopolies in doing that. Is the free market dead? Why encourage monopoly?

    Just as you might do with scripts and application consists of creating some data structures and performing some operations on it. At a fairly high level, a few lines of code invokes many thousands of lines of code existing in libraries to do routine things like reading a file, moving data, sorting data and such. One does not need to code all those gory details, just call on the procedures that already exist. When done properly, one person can create a large application doing amazing things rather quickly. I built a control system in a few weeks once. I only needed to write something like 1000 lines of code to replace an application that my predecessors had put 40000 lines into. The programmes did the same thing and took about the same time but mine was much easier to implement, modify, debug, etc. It’s just a better way to do software.

    Here is an example, iceweasel:
    Installed-Size: 3976
    Maintainer: Maintainers of Mozilla-related packages
    Architecture: i386
    Version: 3.5.16-7
    Provides: gnome-www-browser, www-browser
    Depends: libc6 (>= 2.3.6-6~), libgcc1 (>= 1:4.1.1), libglib2.0-0 (>= 2.16.0), libgtk2.0-0 (>= 2.10), libnspr4-0d (>= 1.8.0.10), libstdc++6 (>= 4.1.1), fontconfig, procps, debianutils (>= 1.16), xulrunner-1.9.1 (>= 1.9.1.16)
    Suggests: ttf-lyx | latex-xft-fonts, xfonts-mathml, ttf-mathematica4.1, xprint, mozplugger, libgssapi-krb5-2 | libkrb53

    Iceweasel is FireFox, a huge programme that does a lot. The package only involves 4 MB of code. The rest of the bulk is libraries.

    see, for example, libc6:
    Package: libc6
    Status: install ok installed
    Priority: required
    Section: libs
    Installed-Size: 9356

    And it goes on. libc6 has some dependencies so FireFox is actually a small part of the code that eventually makes up the programme when it runs. This is an important force-multiplier. You can do the same thing with non-free software but you have to pay someone, obtain licences, observe restrictions, etc. It’s a huge cost and totally unnecessary.

  3. oldman says:

    “If there are more than a few thousand users of some software or potential users, they can easily create their own software by modifying or adding to FLOSS.”

    SO one is to ignore the commercial applications that meet ones needs now and instead embrace a long term communal software project in which one stops actually getting work done, and start programming the tools to get the work one needs done.

    You really don’t get it, do you Pog?

    “I can dash off a few pages of code and have a specific application written to do complex tasks.”

    I’m not sure what you could possibly be doing in a few pages of an archaic language like pascal, but then again there are those who wonder at my move from Perl to Powershell

  4. I have adapted a lot of software, good, bad and ugly. The software most likely relevant to the example I proposed would be library stuff, well-documented and widely-used. For example, I use FreePascal. The manuals come in machine-readable form and can be indexed with every routine and data structure in the system. With that, I can dash off a few pages of code and have a specific application written to do complex tasks. I have been doing stuff like that for ages. It’s not like the old days when one had to actually read the manual/take courses to use any software. Everything widely used is well-documented because in FLOSS anyone can tweak the documentation and ship the change upstream.

    How many users are there of a particular software? If it is only a few then those few likely have to get together to hire someone to make software (which may result in a business selling licences). If there are more than a few thousand users of some software or potential users, they can easily create their own software by modifying or adding to FLOSS. It works. That explains why the number of FLOSS projects is exploding and why there are so many packages available in the Debian GNU/Linux repositories.

  5. oldman says:

    “The other way total control goes through some layers of lawyers and rigid licensing etc.”

    These are your issues and bugbears Pog. The reality of dealing with larger commercial ISV’s in my experience is far less of a hassle that you paint it, especially if a service contract are in place. Once you get above a certain level of applications, vendors are generally responsive, especially if it made clear that their a-ses are on the line.

    “It is more efficient/faster/cheaper to adapt existing software than to write everything from scratch.”

    If you had ever actually tried to adapt someone else’s code, you would never make a statement like this. Code that is poorly documented or badly designed is more of a headache than it is worth, and there is a lot of it in FOSS.

    “To get the job done ASAP, the group if wise will not reinvent the wheel and will use FLOSS off-the-shelf stuff to script everything”

    Actually the group if wise will purchase a business application that has a base level of functionality and supportability which can be customized for a particular business needs. IN my experience as someon who has been involved in many large enterprise projects is that the time to customize a pre built system is almost always less the time it would take to build the entire system from scratch.

    Beyond this, you have done NOTHING to answer my comments. As far as I am concerned, the fact remains that, for example, for me it is cheaper to continue to maintain my license for Finale and the Garritan products that it would be to hire and then manage a programmer whose job it would be to cobble together a pile of FOSS packages and then write debug and integrate the disparate pieces into a coherent whole.

  6. oldman wrote, “Nope. If the software or feature isnt fun or cool to write, it wont get written.”

    There are two kinds of programmers in FLOSS. One is doing it for kicks, young folks mostly, learning by playing around. They will seek out fun things to do. Another is a generic programmer working on some project probably in self-employment or for an employer. It is more efficient/faster/cheaper to adapt existing software than to write everything from scratch. They will use FLOSS in many cases. e.g. hardware makers love Linux because most of the mundane work is done. They just have to write a few drivers and they have a working system on some hardware. The same strategy applies for any software project, not just the fun ones.

    For example, suppose some business of size has 1000 employees and the boss wants to keep track of everything so he will know what deals to make and who to hire/fire. There are business information software packages that do that kind of thing but there is no “generic” business so that one app works for them all. They have to be configured. The front-end that the bosses see is all shiny but the back-end has to be plugged into every business unit somehow. That either means the business that has grown from small to medium size has to change everything to fit into the proposed system, or the business has to write software to collect and catalogue all the information. It’s a lot of work either way. One disrupts the business and the other hires a small staff to work on the bosses’ project. To get the job done ASAP, the group if wise will not reinvent the wheel and will use FLOSS off-the-shelf stuff to script everything together to get in into a database. That’s easy with FLOSS. The result will be perfect for what the bosses want and will incur mostly a one-time cost to develop the project. With the other approach, the new system will likely need a support contract forever with extra expense every time the business evolves. We have read of many such projects that go down in flames with non-FLOSS because the work grows exponentially having to go through the bottleneck of the supplier (support or throughput or uptime…). The in-house solution may seem risky and businesses may avoid it but it is more sure because total control comes to the boss. The other way total control goes through some layers of lawyers and rigid licensing etc. There are two ways to get the job done and the FLOSS way is certain, open and efficient. One does not re-invent the wheel in software. One does not throw away flexibility. One does not pay someone to access one’s own data.

    One may argue that my “example” is vapour but we have seen UNIX operating systems developed by AT&T and the world to do things just like this in a secure manner. We have seen GNU/Linux adopted by diverse businesses around the world to do almost anything on the back end and we have seen GNU/Linux produce easy to use GUI stuff for the bosses. FLOSS can do this job. Munich has found that 80% of what they do with IT can be done with FLOSS and the other works well enough with that other OS that there is little need to change it, but it makes sense to do as much as can be done easily with FLOSS.

  7. oldman says:

    “FLOSS costs less to develop. If there is a need for some software it will be written.”

    Nope. If the software or feature isnt fun or cool to write, it wont get written.

    Imaging hiring a programmer to retrofit OpenOffice calc with a work alike of Excel’s Data/Remove Duplicates feature. By my own estimate the programmer time to do this would easily cost me more than the past 10 years of office updates. Then there is the cost in my time to manage the programmer, and to regression test the new function, etc. etc.

    Its just cheaper to purchase a pre made package Pog.

  8. Read The Cathedral and the Bazaar.
    “The fundamental problem that traditional software-development organization addresses is Brook’s Law: “Adding more programmers to a late project makes it later.” More generally, Brooks’s Law predicts that the complexity and communication costs of a project rise with the square of the number of developers, while work done only rises linearly.

    Brooks’s Law is founded on experience that bugs tend strongly to cluster at the interfaces between code written by different people, and that communications/coordination overhead on a project tends to rise with the number of interfaces between human beings. Thus, problems scale with the number of communications paths between developers, which scales as the square of the humber of developers (more precisely, according to the formula N*(N – 1)/2 where N is the number of developers).

    The Brooks’s Law analysis (and the resulting fear of large numbers in development groups) rests on a hidden assummption: that the communications structure of the project is necessarily a complete graph, that everybody talks to everybody else. But on open-source projects, the halo developers work on what are in effect separable parallel subtasks and interact with each other very little; code changes and bug reports stream through the core group, and only within that small core group do we pay the full Brooksian overhead.”

    FLOSS costs less to develop. If there is a need for some software it will be written.

  9. Linux Apostate says:

    “There is no magic in M$ or Oracle or any other company that produces non-FLOSS.”

    Ah, but the “magic” is in the definition – “non-FLOSS”. Being able to use a commercial software development model, where source is not released and binaries are protected by licenses, is itself an advantage for certain sorts of software development.

    The thing is, you need people to pull together to develop some things. They are too much for one person to do in his spare time. If it’s something fun like a kernel for 80386 computers, then this collaborative process might happen naturally. But if it’s something not fun, then it probably won’t. You will only get programmers to write it if you pay them and project-manage them. And if you do that, then it probably doesn’t make sense to give the results away as FLOSS. Better to charge for the program and reinvest the money to fund future development.

    Making software is really not that different to making physical objects. You can do it for fun and you can do it for free, and sometimes this works really well, but not always. Some things require an industry.

Leave a Reply