“Free Software”: An idea whose time has passed?

[Danny Spitzberg]

   Interesting perspective, worth engaging with. It covers everything from
   the term free/libre and beer, to Microsoft and IEC 62304, to not
   getting credit and reactionary attitudes.



“Free Software”: An idea whose time has passed

   [1]Robert M. Lefkowitz

   Almost forty years ago, in 1985, the idea of “Free Software” was born.
   That is not to say that the idea of sharing software with colleagues
   and making source code available was born. Ten years before the GNU
   Manifesto and the Free Software Foundation, I worked at a cloud
   services company (only we called it “timesharing” back then), and in
   order to encourage people to use our offerings and pay us for renting
   computer time and disk space and network bandwidth, we curated a
   collection of software libraries that customers could freely use. We
   called it the Public Library, of course. The software therein
   was public software. The idea of public software was software that
   anybody could freely use. What happened in 1985 was the birth of the
   idea that creation of software was a political act. And that when the
   creation of software was motivated by politics, it should be
   called free software to differentiate it from software created for
   other reasons. This became clear to be when I attended my first
   O’Reilly Open Source Conference, where I watched Miguel de Icaza debate
   Richard Stallman — and the question on the table was whether or not
   there was a difference between “free software” and “open source
   software”. The conclusion was that there was no detectable difference
   from examining the software or the license or any artifact. The
   difference was the intent of the programmer. If the intent was
   political (i.e. a concern for freedom), then the result was free
   software. If the intent was industrial, the result was open source
   software. I use the term industrial because the motivation of the open
   source crowd is to use what they believe to be a superior method of
   producing software.

   My interest in free or open source software has never been either
   political or industrial. My interest has always been educational. That
   is, access to the source code provided the opportunity to learn from
   it. So, in the same spirit as the Open Source / Free Software
   distinction, I coined the term Liberal Software to refer to software
   where the intent of the programmer is educational(liberal as in
   education). Any one of these three intents can produce software for
   which the source code is available — and that is often called FLOSS,
   meaning Free, Liberal, or Open Source Software.

   I prefer to think about these categories in terms of intent, because
   that opens the door to reflecting about effective strategies to
   implement that intent. So, for example, if it were to turn out that,
   all other things being equal, providing source code for libraries could
   be shown to produce software of inferior quality (and there is much
   evidence to support such a conclusion), then someone with an intent to
   produce industrial software might choose to pursue a course of action
   that did not involve making the source code available. The availability
   of source code is certainly invaluable in Liberal Software, and there
   are several scenarios regarding industrial software that require access
   to the source code. But that is a discussion for a different time.

   Today’s topic is political software. I think it is clear that the Free
   Software Foundation has failed to move the needle on the political
   issues relating to software. Those of us who are interested in issues
   of freedom and ethics and social justice related to software must
   explore alternative stratagems to achieve those objectives. The tactics
   of the Free Software Foundation (the insistence on copylefting software
   and fighting software patents) have become more and more ineffective.
   The world of software has evolved and changed in the years since 1985:
   we need to let the past die and build a better future.

   The first sign that free software is intellectually bankrupt is that
   the Free Software Foundation seems unable to develop new generations of
   leadership. Free societies are usually lukewarm to the practice of
   “dictators for life”. After around a decade, it is a healthy sign if
   new leadership emerges. It is a sign of growth and innovation. It is
   healthy. Seeing the same people in the same places pursuing the same
   failed tactics decade after decade is evidence of a lack of broader
   acceptance.

   Secondly, I am reminded of Harry Truman’s quote:

   It is amazing what you can accomplish if you do not care who gets the
   credit.

   The Free Software Foundation is famously fixated on insisting that it
   be given credit for Linux. Caring about who gets the credit more than
   successfully creating change is not a good look. It is, of course,
   consistent with the ego required to cling to power and smother the
   growth of the next generation. Linux is perhaps the child that
   succeeded where GNU failed.

   Thirdly, the rhetoric of Free Software devotees is awkward and
   unconvincing. The inflexibility (or inarticulateness) that has failed
   to evolve the talking points to make them more effective is a failure
   of politics. To take my own pet peeve, it is unarguable that inanimate
   objects cannot have freedoms. People have freedoms. Frying pans, as an
   example, cannot have freedoms. If one were to talk about Free Frying
   Pans, the only way to interpret that statement is that one is referring
   to frying pans that one needn’t pay for. When one uses the phrase “free
   press”, one is not suggesting that the pile of metal and wood that
   constitutes a printing press machine is entitled to freedoms. The word
   “press” in that phrase is a figure of speech known as metonymy. It
   refers to journalists. “Freedom of the press” is talking about the
   freedom bestowed on journalists. Most people understand that “the
   press” refers to the journalist collective. So when one says “free
   software” or “software freedom” we know that the freedom is not given
   to an executable file. The expression (unless we are referring to
   software that we needn’t pay for) is referring to freedom for some
   group of people that we know as “the software” (y’know, like “the
   press”). And who are those people who are members of “the software”?
   That was a rhetorical question. Please don’t try to explain it to me. I
   was pointing out how nonsensical this framing is. Rhetoric is a
   discipline that has been around for over two thousand years. We have
   two thousand years of scholarship that inform us that the phrase
   “software freedom” is meaningless gibberish. It can only sow confusion
   — and the confusion is only exacerbated by explaining that you used the
   words to mean something else entirely. That was Lewis Carroll’s point
   in Through the Looking Glass:

   “I don’t know what you mean by ‘glory’”, Alice said.

   Humpty Dumpty smiled contemptuously. “Of course you don’t — till I tell
   you. I meant ‘there’s a nice knock-down argument for you!’”

   “But ‘glory’ doesn’t mean ‘a nice knock-down argument’,” Alice
   objected.

   “When I use a word,” Humpty Dumpty said, in rather a scornful tone, “it
   means just what I choose it to mean — neither more nor less.”

   “The question is,” said Alice, “whether you can make words mean so many
   different things.”

   The Free Software coterie is fond of insisting that words mean what
   they say they mean, and that is a profound misunderstanding of the
   nature of language. Such linguistic naïveté is not an asset in pursuing
   political goals.

   With all that said, the intent of the adherents to the term Free
   Software is to seek to promote certain freedoms for the users of
   software, by depriving the creators of software (at least in the United
   States) of the rights afforded them by Congress under Article I,
   Section VIII, Clause VIII. Many programmers are under the impression
   that “software freedom” is meant to increase the freedoms of software
   producers. Nothing could be further from the truth. The GNU manifesto
   and Free Software Foundation take great pains to explain that their
   intent is to increase the freedom of computer users — at the expense,
   of course, of software producers. “The Software” is a metonym for
   software users. The difficulty is that the freedoms that the Free
   Software Foundation insists on giving software users are freedoms that
   most software users do not want, and the freedoms that they wish to
   restrict for software producers are freedoms that most software
   producers would rather retain. The so-called Free Software coterie
   might make more headway if it took the trouble to find out what
   freedoms “the software” (a/k/a software users — see how awkward this
   metonymy is) actually wanted. Instead they invest most of their energy
   trying to convince “the software” of which freedoms they ought to want.
   In that vein, the intent of the programmer who selects the license
   makes it “free software” or not — the intent of the user is not
   considered. If a user uses software with political intent, but it is
   not licensed in a way that the Free Software Foundation approves of,
   can “the software (meaning the user)” be exercising freedom?

   Prior to 1983, (two years before the Free Software Foundation was
   founded), all computers sold by IBM (which in those days meant pretty
   much “all computers”) came with the source code to the operating
   system. Like Linux (although you usually have to download the source
   code separately nowadays). Every company (because computers were so
   expensive that individuals couldn’t afford them) had a “data
   processing” staff which might make changes to the source code should
   the need arise (fixing problems, adding features). Many companies,
   however, were not large enough or sophisticated enough to have the kind
   of staff which could do this effectively. They would prefer to contract
   out the maintenance of the operating system software to the vendor
   (IBM). IBM, however, was unwilling to take this on, since everybody had
   the source code, and might have made modifications. IBM had no way to
   know what modifications might have been made, and consequently would be
   unable to accurately estimate how much work might need to be done.
   Eventually, due to persistent customer demand, they came up with their
   OCO (Object Code Only) program — in which you could receive the
   software WITHOUT the source code. In that case, IBM could provide a
   service contract for their software as they wouldn’t have to contend
   with individual local modifications. It turns out that computer users
   mostly wanted freedom FROM source code, rather than the freedom to use
   the source code to modify their operating system. Two years later, the
   Free Software Foundation was founded to try to foist the source code on
   people who didn’t want it.

   If your counter-argument to that is “but that was the 1980’s and the
   nature of software has changed since then — so that situation no longer
   applies” I have two responses. Firstly, the GNU manifesto was written
   in the 1980’s, and the nature of software has changed since then, so it
   no longer applies. Secondly, the largest Free Software business, Red
   Hat, has always had “freedom from source code” as its business model. A
   business pays Red Hat with the same licensing scheme as they would for
   any proprietary commercial operating system, in exchange for which Red
   Hat frees them from the inconvenience of needing to be exposed to the
   source code.

   Discussions of Free Software often start with the origin myth about
   access to the printer software source code at the MIT AI labs. Being
   denied the ability to get a notification when the network printer jams
   is fairly low down on the list of human rights violations. When
   discussing why Free Software partisans think “software freedom” is of
   any use or interest, the canonical answer is some form of the argument:
   fear the “bad actor”.

   This conspiracy theory goes something like this: If you can’t examine
   the source code, then some bad actor might provide you some executable
   software that has evil baked in, and you wouldn’t be able to tell —
   whereas the bad actor would not be able get away with such
   nefariousness if you had access to the source code. As with all
   conspiracy theories, two things are true. 1) If repeated often enough,
   people will start to believe it. 2) It is nonsense.

   Free-softwarists are right on their fundamental premise: this is a
   political issue. Protecting myself from bad actors is not my job. It is
   the government’s job. Americans like to perpetuate the myth that it is
   everybody’s job by pretending that the right to bear arms is somehow
   related to protecting one’s family. Somehow, we still need to spend
   close to two trillion dollars a year to hire government employees to
   protect us (military and police and border patrol and firemen and
   sheriffs and marshals and immigration agents and intelligence
   services). If owning a gun were sufficient to protect ourselves, we
   could save those two trillion dollars. But the same people who proudly
   display the weapons that they own (to protect themselves) are the first
   and loudest to insist that we need to spend trillions of dollars on
   government-employed protectors.

   Free-softwarites like to use beer metaphors (free as in beer). Let me
   suggest that if one were concerned with bad actors, one wouldn’t drink
   purchased beer (or free beer). One would brew one’s own beer, because
   bad actors might have poisoned the beer. And one would have to grow
   one’s own hops, (as bad actors might have poisoned purchased hops). And
   what might one use for water to brew the beer? Bad actors might have
   poisoned the water supply. One would need to dig one’s own well
   (unless, of course, the bad actors had polluted the water table). This
   way lies temperance.

   The alternative, of course, is to believe that you could safely
   purchase beer, because it is the government’s job to keep you safe.
   There might be government inspectors who inspect breweries. There might
   be laws against selling poisoned beer, and courts and district
   attorneys to go after beer poisoners and jails to incarcerate people
   who poison beer. There might nevertheless occasionally be a tragic
   instance of beer poisoning, but having a government agency whose job it
   is to keep the beer supply safe might be more effective than having
   each household test the beer they purchase to determine if it is safe —
   with the only punishment for the purveyors of poisoned beer being that
   some people might notice that the beer was poisoned and organize a
   boycott. The “bad actor” conspiracy theorists need to believe that many
   commercial actors are evil and all government actors are ineffective.
   And although I believe that there is the occasional evil entrepreneur
   and the occasional ineffective bureaucrat, in general, we must live our
   lives as if people are trying to do what they believe to be the right
   thing. Airplanes won’t usually fall out of the sky, restaurants won’t
   usually serve poisoned food, automobiles won’t usually explode, bridges
   won’t usually fall down when we drive over them. Software vendors won’t
   usually be inserting spyware into their wares. Q is not prescient. The
   evils are likely to be petty; misdemeanors rather than felonies.

   And on those occasions when bad actors are engaging in nefarious
   activity, a much better solution than having everybody auditing every
   line of source code for every bit of software they use, is to pass laws
   criminalizing such behavior and having a government cybercrime division
   tasked with punishing people who do that. And in this regard, free
   software is one of the bad actors. In the GPLv3 (and it was there in
   GPLv2 and v1) clauses 15 and 16 are the Disclaimer of Warranty and the
   Limitation of Liability. To be fair, proprietary software licenses have
   the same clauses, but the free-softers cannot claim the moral high
   ground here. These licenses assert that if the software causes any
   harm, the people who wrote it aren’t liable (limitation of liability).
   And also that the software is completely useless and it would surprise
   the author if it worked at all (disclaimer of warranty). UNLESS
   REQUIRED BY LAW. The paragraphs are in all caps to make extra sure you
   understand that GPL software is guaranteed to be broken by design and
   that nobody is responsible for the damage it causes. The
   free-softwarian defense of this “it’s OK to do evil” posture is that
   since the people writing the software aren’t charging money for it, you
   shouldn’t be able to sue them for any evil they might have accidentally
   baked in. And this is, of course, after arguing that programmers can
   make money with free software by charging for the labor of writing and
   packaging and distributing the software, but not for licensing it. In
   summary, the Free Software Foundation asserts that a) you can
   definitely make money writing free software, and b) you shouldn’t be
   held liable for any harm your software causes because you can’t make
   money writing free software.

   Of course, there are those five fateful words (in all caps): UNLESS
   REQUIRED BY APPLICABLE LAW. It seems that the intent of the GPL (and by
   extension, Free Software authors) is to be permitted to be as evil as
   possible (accidentally), brought up short only by applicable law. That,
   of course, is freedom. So, naturally, they assume that other (non-free)
   software authors will be equally unscrupulous. Put me down as being in
   favor of additional legislation to hold software authors liable for any
   damages they cause. And also of additional legislation to require them
   to warrant that the software is merchantable and fit for some purpose.
   I would like to see specific legislation that makes the person who
   provided me the software assume some risks as to the quality of the
   program. The existing free software license specifically states that
   “should the program prove defective, I assume the cost of all necessary
   servicing, repair or correction”. The existing free software license
   specifically states that “in no event shall any party be liable to me
   for damages for losses sustained by me for using the program”. As it
   turns out, there are many jurisdictions in which the applicable law
   voids the entire disclaimer — you can’t limit your liability by
   disclaiming it. The problem exists in those jurisdictions that allow
   the kinds of freedom-limiting licensing provisions embedded in the GPL
   to be enforceable. I wish that free-softies would aspire to emulate D J
   Bernstein, who offered, in 1997, $500 to anybody who found a security
   hole in his software qmail.
   ( [2]https://cr.yp.to/qmail/guarantee.html )

   As a software user, as a member of that group of people known as “the
   software”, for whom “software freedom” applies, the freedom that I
   would like is the freedom to seek recompense from people who create
   damage to me via software. I would prefer software insurance to
   “software freedom”. When the GPL was written, when the term “Free
   Software” was coined, software was used for accounting software and
   text editors and printers. Nowadays, it is used to run MRI machines and
   radiation therapy machines and surgical robots and nuclear power plants
   and drive cars and fly airplanes, and so on. When the GPL was written,
   when software failed, it meant I didn’t get notifications about printer
   jams. Today, when software fails, it means I get a lethal dose of
   radiation. Maybe I would have been satisfied by the freedom to see the
   source code to the printer driver to deal with the paper jam. Today,
   however, the freedom that I want is not the freedom to see the source
   code to the radiation therapy machine. The freedom that I want is the
   freedom not to worry about receiving a lethal dose of radiation because
   the programmers who wrote the radiation therapy software took extra
   care because they know they would be harshly punished if they screwed
   up. That would make me feel much safer than a copy of the source code
   that I could peruse before being hooked up to a machine running
   software that was written by programmers who knew that nothing would
   happen to them, even if it killed me. I want the freedom to not have to
   audit every line of software of every software system I ever use, or
   which is used on me. That might have been possible in the 1970’s. It is
   not possible today. ( For those of you who think I’m concocting
   hypothetical scenarios for fear-mongering … I refer you to the
   incidents with Therac-25. [3]https://en.wikipedia.org/wiki/Therac-25.
   The result being an international standard (IEC 62304) for medical
   device software. The authors of IEC 62304 identify a set of criteria to
   determine whether the software is sufficiently safe to be included in a
   medical device. Availability of the source code is not one of them.)

   The free-softwarians make the argument that without access to the
   source code, one would not be able to detect the nefarious intent of
   the bad actors. Let me digress briefly to reminisce about an incident
   during my career. I was employed by a large investment bank who had
   asked for (and received) a copy of the source code for Microsoft
   Windows. This bank then proceeded to make modifications and compile
   their own custom version of Microsoft Windows which they distributed to
   tens of thousands of employees. Furthermore, we also wrote custom
   applications which relied on features of this custom version of MS
   Windows. You’ll never guess what happened next. Microsoft came out with
   a new version of Windows! Which, as it did not have our custom
   modifications, meant that our applications couldn’t run on this
   version. Unfortunately, none of the new versions of the Microsoft
   applications (like Microsoft Office), nor any of the applications
   written by software vendors who wrote applications to run on the
   publicly available Microsoft Windows would run on our custom version of
   Windows which did not include the new features available in the new
   version of the operating system. What could we do? Well, for starters,
   we could choose to not upgrade any software for a few years. That
   worked for a while. Then there was yet another new version. And plenty
   of demand for new versions of commercial applications. So we bought
   tens of thousands of licenses for VMWare so that every employee could
   run two virtual machines: one running our custom version of Microsoft
   Windows, and one running the publicly available version. For all I
   know, they are doing this still.

   The point being: large corporations and government agencies have always
   had the ability to get access to the source code of commercial
   software, and modify it if they wish. And if they have a good reason,
   they will do so. But usually, they don’t wish to. The GPL (or other
   such licenses) will only assist in foiling bad actors if the
   expectation is that individual hobbyists are responsible for regulating
   cyberspace and preventing cybercrime. The government and regulated
   utility companies and large corporations do not need special copyright
   licenses in order to audit proprietary software. They have plenty of
   existing mechanisms for doing that. After all, it’s not as hard as
   tracking every telephone call on the planet — an activity which you or
   I might not be able to engage in — but rest assured that it is not as
   challenging for a certain government agency as it would be for you.

   And while we’re on the subject of preventing bad actors from harming us
   with software, I read recently that the losses from cybercrime in the
   US exceeded the losses from all natural disasters combined. That’s a
   worrisome bad actor situation. And do you know what would make a big
   difference in that fight? Ubiquitous code signing! And does the Free
   Software Foundation come down on the side of those in this fight who
   would deter the bad actors? No they do not! The unimpeded access to
   source code and running software (like the unimpeded access to
   unregulated assault rifles) is more important than the peace of mind
   which comes from reducing the threat of criminals breaking into your
   computer (or shooting up your school).

   Next point (I’ve lost track of the numbers): why does copyrighting
   software provide more freedom than patenting software? The stated
   intent of Article I, Section 8, Clause 8 of the United State
   Constitution, is to “promote the progress of science and useful arts”
   by striking a bargain: inventors would document their inventions in
   exchange for an exclusive right for a limited time. That “limited time”
   for copyright is the remaining life of the author plus 70 years. That
   “limited time” for patents is 20 years. It seems to me that there is
   more freedom sooner with a patent than a copyright. If we eliminated
   the ability to copyright software, we could have more software in the
   public domain sooner. That sounds like increasing freedom. There is a
   fruitful area for proposing legislation to advance things on this
   front. Software patents could be of shorter duration. Software patents
   might require the source code to be part of the filing (which, not
   incidentally, provides the same “bad actor” protection as the GPL).
   Then the government would be enforcing universal access to the source
   code, as opposed to now, where that function falls to a subsidiary of
   Microsoft (Github). If there is a political dimension to software, then
   the mechanisms to enforce that freedom properly belong to government,
   not multi-national corporations. Yet the Free Software Foundation does
   not have a great record of proposing and lobbying for legislation to
   increase the rights of “the software”, relying instead on a single
   counter-intuitive quirk of copyright law. Sometime in the early 2000’s,
   I was invited by a telecommunications lobbying group to attend an event
   in Washington D.C. to lobby on behalf of free software to a collection
   of congressmen and senators. I remember the event because it was there
   that I met Bruce Momjian (who was the most interesting free software
   advocate) and Joe Biden (who was the most interesting politician).
   Unfortunately, the politicians did all of the talking, because the free
   software contingent did not have a legislative agenda. I doubt I’ll get
   another opportunity, but I sometimes ponder the hypothetical: if I did
   get another meeting with Joe Biden to lobby him for legislative changes
   to improve “software freedom”, what would I ask him to implement? If
   the Free Software Foundation has a legislative platform, I don’t know
   what it is. It seems to be an organization that focuses on litigation
   rather than legislation. It is against laws that others have proposed,
   rather than for laws that it has proposed. It focuses on products
   (boycotting them or building them) rather than governance (proposing
   legislation and regulation). The Free Software Foundation seems to be a
   collection of programmers who want to write software and talk about
   software and boycott software. It seems to be uninterested in proposing
   political solutions to issues it cares about — but willing to attack
   proposals that others have made that it disagrees with. As a political
   organization, it is profoundly ineffective, apparently by design.

   Before so-called “free software”, there was public software. We could
   return to public software. As there are public libraries for books,
   there could be public libraries for software. Interestingly, a public
   library does not give people the right to make their own copies. They
   can check books out of the library and read them for a time, then
   return them so that others can read them. The activity is funded by the
   government. There is no reason that this activity could not be mimicked
   with software. It need not be “free software”. It could be licensed
   commercial software (using floating network licenses), funded by the
   government, providing software licenses to its citizenry to check out,
   use for a time, then return for others to use. This would increase
   access to software to our citizenry — increased freedom for all.

   Freedom of the press is the freedom to publish without government
   interference. However, the existence of a “free press” does not mean
   that I can copy an article written by a journalist, print my own
   copies, and distribute them myself (whether I charge for them or not).
   Specifically, we are all agreed that a free press can healthily exist
   in a regime where copying or modifying the published work of that free
   press is not allowed. Is, in a word, illegal. (Illegal, incidentally,
   according the same regulatory regime that the Free Software regime
   employs to “keep software free”.) That prohibition against copying
   apparently, does not infringe on the freedom of the press. Similarly, I
   think it is manifestly obvious that freedoms of “the software” do not
   require the ability to make copies or even to make modifications. If we
   are going to use the “free press” metaphor to understand “free
   software”, then programs which are “free software” can be restricted
   from being copied or modified without impinging on any freedoms. Which
   is a long winded way of saying that I can easily imagine a world in
   which the GPL has been abandoned, but other policies and regulations
   and legislative actions have created a world with considerably more
   freedoms for “the software” than we enjoy today.

   These are people who are so invested in their cultish conspiracy
   theories that they literally have no idea how software works today. The
   funniest part of the recent Stallman announcement about his return to
   the FSF board was the admission that they couldn’t figure out how to
   make a video of the announcement and distribute it. We are way beyond
   new board members, or a new organization to keep the flame of “Free
   Software” alive. It is time to admit that all the tropes and rhetoric
   and conspiracy theories of the so-called free software movement are an
   impediment to making any actual progress on making
   positive political change with regards to software. I believe firmly
   that we need to have better engagement from government to improve the
   positive impact that software can make on society. Regulations and
   legislation and governmental programs and non-governmental
   organizations need to keep pace with the evolving nature of software. I
   also firmly believe that so-called “free software” is the greatest
   impediment to making real progress on any of these fronts. The Free
   Software clique is rooted in the deep past, and committed to endlessly
   rehashing the software controversies of the 1980’s — when mainframes
   were battling with minicomputers for supremacy. The leadership is
   morally and intellectually bankrupt. The organization is morally and
   intellectually bankrupt. The “movement” is morally and intellectually
   bankrupt. It was an idea that had resonance and a potential future in
   the 1990’s. Back then, I was a believer.

   That time is passed. Let the past die. Kill it, if you have to. That’s
   the only way to become what we aspire to be. A society with a rational
   governance framework for software and its effects. I’m willing to
   support a Public Software Foundation that advocates for that.

   In the future, should I use the phrase “free software”, I will be
   talking about software that I don’t have to pay for. Otherwise, I’ll be
   talking about “digital autonomy”, or open source software, or liberal
   software, or, as most publications have been doing for the last few
   decades, “liberally licensed software”. It’s from the Latin “libre”
   (referring to freedom), or perhaps from the Latin “liber” (meaning
   “book” — a metonym for education).

   [4]https://r0ml.medium.com/free-software-an-idea-whose-time-has-passed-
   6570c1d8218a

References

   1. 
https://r0ml.medium.com/?source=post_page-----6570c1d8218a--------------------------------
   2. https://cr.yp.to/qmail/guarantee.html
   3. https://en.wikipedia.org/wiki/Therac-25
   4. 
https://r0ml.medium.com/free-software-an-idea-whose-time-has-passed-6570c1d8218a