Five
dollars was still a lot of money in 1969, so often the students would
go to the school store, buy blank paper tape, and duplicate the program
through their ASR-33 Teletype. Then they would sell these copies at one
USD apiece to their fellow students until they made their money back.
This was legal, since at that time there was no copyright on software,
and no software patents. We provided a service for our fellow students,
as well as lowering the cost of the software for everyone. At that
time, software was typically sold as a service.
Software as a service? What does that mean? As a person who needed
software, if I did not have the capability of writing the software
myself, I would hire someone who had that expertise (either full-time
or as a consultant). I would tell the programmer the need I had for the
software, and the software would be written explicitly for those needs.
I would pay the programmer for the time and effort they expended to
write that software. Then I would own the software. I could put the
software on as many systems as I wanted to put it on. I could change
the software to meet my future needs. I could distribute the software
to anyone I desired, for any price (including gratis). If I did not
like the original programmer, I could hire someone else. I was in
control of my own software. Of course, this was very expensive. It was
like ordering a hand-crafted coffee mug instead of going to the grocery
store and buying one off the shelf.
Nineteen sixty-nine was also the year that Unix, a new and portable
operating system, was started by engineers at Bell Laboratories in New
Jersey. Two engineers, Ken Thompson and Dennis Ritchie, started writing
an operating system "just for fun". It was not to be a big or elaborate
system, it fit on very small computers, and eventually was made fairly
portable through the use of a language that Dennis wrote called "C".
Eventually Unix made its way to universities such as the University of
California, Berkeley, where generations of students, professors, and
researchers looked at the source code, understood what was desired, and
helped to improve the system. Many years later this work evolved into
the Berkeley Software Distribution (BSD), and after a large lawsuit
with AT&T, the university was allowed to distribute the BSD source
code freely under what became known as the BSD License.
Finally, 1969 was also infamous for the birth of a baby boy in Helsinki, Finland. We will learn more of him later.
As the years went on, a computer marketplace developed. Introduction
of mass-marketed systems such as the Commodore 64, the Apple II and the
IBM PC sparked a market place for mass-produced, binary only software
sold as products. Fewer and fewer pieces of software were distributed
in source code form. Companies such as Sun Microsystems started
distributing Unix as a binary-only distribution under license from
AT&T, for this was long before the lawsuit that made BSD software
"free".
In the years between 1969 and 1990, software was subjugated first to
copyright law, then to patent law. Most people started thinking of
software as something to manufacture and sell, not to develop for their
own needs and distribute. A binary-only software industry arrived, and
fewer people shared their source code, thinking this would be a way to
make money. Most programmers became resolved to this situation.
In 1984 a student at MIT by the name of Richard M. Stallman decided
that this was wrong. Software was information, and he felt that
information should be freely available. Richard liked looking at
software, seeing how it was written, changing the software to meet his
own needs, and the disappearance of source code disturbed him greatly.
He started a project to create a complete operating system, freely
available, called GNU (which is a recursive acronym, "Gnu is Not
Unix"). GNU became a trademark of the Free Software Foundation started,
also by Richard, to complete this task.
Richard started with portable tools, such as text editors and
compliers, that would work on a variety of operating systems. This
allowed people to use Free Software without having the whole system
available. It built a loyal following of people who shared Richard's
vision, and who benefited from the rules of the General Public License
(GPL) under which the software is licensed. Unfortunately by this time
(in most countries) software was copyrighted automatically, which meant
the authors had to explicitly give it away with some type of license.
The GPL became the benchmark for free software licenses, although there
are others.
The GPL states four freedoms that Richard felt were needed for software:
The freedom to run the program, for any purpose (freedom 0).
The freedom to study how the program works,
and adapt it to your needs (freedom 1). Access to the source code is a
precondition for this.
The freedom to redistribute copies so you can help your neighbor (freedom 2).
The freedom to improve the program, and
release your improvements to the public, so that the whole community
benefits (freedom 3). Access to the source code is a precondition for
this.
To support these basic freedoms the GPL was derived, and while it
has been modified slightly over the years to meet new demands and
issues, it remains much the same.
In the meantime, proprietary, closed-source software continued to
advance in the marketplace.
By 1991, a lot of software existed for what Richard called the GNU
operating system with one crucial part missing, the kernel. The kernel
of the operating system is the part that controls the hardware,
controls which programs run and when, and manages the memory of the
system. The GNU project was working on a kernel called "the HURD",
which was micro-kernel based, but this was a difficult task, and it was
taking a long time.
Then a turn of events. In 1991 the baby born in 1969 was a college
student at the University of Helsinki studying computer science. He had
gotten a new computer, and realized that the operating system that came
with it did not take advantage of all of its hardware features. He
wanted an operating system that could take advantage of these features
(Unix), but the various commercial versions of Unix were all too
expensive for him. Besides, he could not get the source code for those
Unix versions, and he (like Richard) liked looking at the source code
of good software. So eventually Linus Torvalds started a project to
create an operating system kernel just as a hobby...."just for fun",
and in 1991 the Linux Kernel Project was born.
In 1994 version 1.0 of the kernel was ready, and by this time
various people and companies had taken code from the GNU project, as
well as code from various other projects such as the X Window System
(originally started at MIT), SENDMAIL (originally part of the BSD
project), relational databases, text editors, and many, many others and
created distributions of code, all of which had the source code
available, either with the distribution or downloaded off the Internet.
People started calling these new distributions "Linux" or "The Linux
Operating System", which ignored the contributions made by other
groups. The Free Software Foundation started calling it "GNU/Linux", to
show that it was the "GNU Operating System with the Linux kernel".
Whether you call it "GNU/Linux" or just "Linux", that is up to you. The
most important part is that you use it, contribute to it, and promote
it. Even more important is that you understand the benefits and value
of the four freedoms, and fight for them.
Today many millions of people around the world benefit from software
freedom. They can change the software to meet their own needs. Instead
of violating local laws and copying proprietary software, they can
utilize free software to meet their needs. They can become just as
expert as programmers and systems administrators as the people that
wrote the code originally, perhaps even more so. In fact, the Free
Software Community encourages this type of excellence.
I have met many programmers and systems administrators under the age of twenty-one who have done amazing things:
A fourteen year-old that made his own
distribution that installed into the FAT file system, making the
distribution easy to install on Microsoft Windows platforms without
having to re-partition the disk
A fifteen year-old that enjoyed hacking the Linux Kernel and writing device drivers
A twelve year-old that set up an entire networked set of systems for a trade show
A nineteen year-old that wrote an freely
available telephone system, later called "Asterisk", and turned that
into a business that employs thousands around the world
All of these people, and many more (including myself) owe our
knowledge and our abilities to Free Software. Not just the knowledge of
how to use the software, but how the software works.
I invite you, the reader, to join the community of Free Software
developers and users. Your future is in your own hands. Carpe Diem!
Warmest regards,
Jon "maddog" Hall, Executive Director
Linux International
I look a little like Santa Claus, but believe
it or not I was once your age. I started programming in 1969, before
there was a university degree called "computer science", and before
there were "computer stores" selling boxes of binary-only software. In
those days most software was distributed in source code form, because
there were many different types of computers, and only a relatively few
of each type. Software sold was very expensive, since a person would
write the program and only three or four people in the rest of the
world might be able to afford the computer to run it. I remember seeing
a compiler that cost more than 100,000 U.S. dollars a copy...in 1969.
This was more than four times what my parents paid for our
three-bedroom family home.
