The Blog From Hell

The very first proper graphical browser ever released was NSCA Mosaic, a browser for Unix on the X-window system it was released less than a year after the first Linux kernel was released. Within a few years the browser was comercialized and became the netscape browser. Gaining a port for Microsoft Windows 95 it became the first browser of choice on that platform and while the Unix version persisted it was rather neglected in those years. 

Netscape on Windows took a major hit when Windows 98 shipped with internet explorer built-in, and around this time something else very importantly changed in the Free Software world. It was in this time that Eric Raymond wrote "the Cathedral and the Bazaar" the first study of free software as a technical development methodology rather than just an ethical stand-point. While there is nothing wrong with such a study it would ultimately lead to a rift between those whose primary motivation was ethical (like Stallman) and those who cared only about practical advantages.

Back in 1998 however, this was hardly an issue yet and it would begin a major change. Raymond's book caught the eye of Netscape's executives and it was from one of them that the phrase "open-source" came. Netscape saw a shot at survival there and began a process to release their source code.

The initial model had netscape kept as a commercial browser with extra features built on top of the structures produced from the open code-base they called Mozilla. Mozilla in those days was a much needed tool – and every developer's nightmare. The codebase was notoriously ugly, absolutely gigantic by Linux standards and frequently very badly written and designed. The mozilla foundation and their largely volunteer developer base knew it would take years to refactor and improve that code, and thus chose to release incremental process through what was known as milestone releases.

Most hardcore geeks would regularly download and build the latest mozilla milestone, a task which on the computers of the time would easily ran overnight and into the next morning – and was fraught with risk, many times it would fail after many hours due to a new bug that had not been picked up upstream. 

Distro's would get the best build they can and include those and then released binary builds incrementally as updates on a much slower pace (mostly because it was jut not practical to do more) and this is what we browsed the web with. By then IE6 was the dominant browser on the web, and mozilla's market share was tiny – the result was that most web designers simply didn't care to follow standards (especially since neither browser did that well) and just developed their pages to work in IE. Even major banking and government institutions often didn't work. It could get worse, at one point South Africa's independent electoral commission's website did a browser-check and if you were found not to be running IE6 would redirect you to a page instructing you to get "a real browser". Alistair Otter of tectonic news had a field day with that one ! 

That state would last for several years as the mozilla code-base was improved and slowly trimmed down. Mozilla as a browser would not ultimately survive but from it's core code base and gecko rendering engine would ultimately come Mozilla Firefox (a side story – this new browser project designed to be a fast low-resource browser using the gecko engine was originally called FireBird, but the then long established developers of the free FireBird SQL server complained about this bad form among fellow FOSS developers and the name was changed – this was the start of several such events, later issues about trademarks from Firefox led to many distributions making minor forks that only changed the name and branding – debian being the first, and ultimately the FSF themselves created a major fork stripped of non-free bits and it's own addon site that only allowed free software addons – this version is called IceFox) , from Netscape Mail would come Thunderbird, and even Eudora persists.

In fact the list of Mozilla based applications has gotten quite huge and the mozilla corporation is one of the flagships of the free software world today.  Looking at the ease with which we can load up multiple standards compliant free browsers today (Google's Chromium, Firefox etc.) and be quite confident of almost never finding a site they can't handle is a stark contrast to those early days when we frequently felt the annoyance of a website refusing to play nice, when most of us changed our user-agent to try and convince the sites we were running IE6 so we could get around browser-filters and when getting an update for security and features meant downloading a source package larger than the kernel with a hugely complex (and atypical) build process that was truly fragile and took a very long time even if it work.

But we did it anyway – and it paid off.

Finger despite the naughty name was in many ways the precursor of modern social networking sites – facebook statusses and twitter both have have significant similiarity in both their purpose and their use to what finger once was.

Unlike these sites however, finger did not rely on any central database, finger was a unix (and linux) concept comprising three pieces beautifully working together. If you remember my earlier post about mail systems then you will see how it was used before the internet in the same way, but with the internet finger became network aware.

The first part then was fingerd, the server daemon which a unix machine could run to allow finger to function. It listened for requests coming in from the finger command, and responded to them. Finger ran on a privileged port – so it had root privileges (for it's operation, this was important as well) and the finger command took as it's parameters the host to contact (or the local machine if none was specified) and the username of the person you were checking.

Upon receiving a request the finger daemon would look in that user's home directory for a file called .plan – and if found, would send it's contents back to the finger client, which would then display it.

So users could write status updates in .plan, and other users could read it by fingering them. The crucial difference between this and later social network statusses of course is that it was demand based updates only, using a pull technology as opposed to the push-to-all-followers approach of modern social networking systems.

Finger was used professionally (employees would write about what project their working on so their manager could quickly check what everybody was busy with), socially (much like twitter is used now) and even as a marketing tool. For many years ID founder John Carmack kept his .plan on ID's public Linux server regularly updated and gamer geeks avidly followed it to keep track of development on the current work happening in the latest doom and quake installments. One of the most famous updates he ever posted was right after the doom 1 source code was first released under the GPL in the very late 90's – it concluded: "I did it because Linux gives me a woody*".

Finger however was designed in the early days when the internet had no need to be secure. It's original designs were, frankly quite attrociously insecure. Later versions improved a bit, for example dedicated finger daemons could give up root privileges once they had the port (though this relied on .plan files being world-readable it was better than having a root-privileged user randomly scrounging in people's home directories) but even then it was a high risk service to run, a brute forcing client could easily use finger to get a list of valid users on a server, which then meant that it could limit it's password attacks only to users that actually existed.

Companies like ID that deliberately ran public finger servers kept them in DMZ's later, but ultimately the program went from a default installation on any unix server to an obscure tool that was rarely used since hardly any server had it, none enabled it by default and no prudent sysadmin would willingly enable it unless he was very sure of his network security on the other end of the link.

So finger went the way of the dodo because people were concerned about it's privacy implications, and because it left one open to attack by cybercriminals. Ironically neither twitter nor facebook has relieved either of these concerns (if anything it has aggravated them) but the internet community of today is not the community of the late 90's when it first started to swell and things like corporate internet connectivity began to go mainstream – it was in that era when most people's internet was still being managed by skilled sysadmins sitting between them and the net that finger for all practical considerations died, it took nearly ten years for twitter to replace it. 

There are still finger servers and clients in development today, and simple ones are frequently still used as the default "how to write your first network-capable program" example in many text books but the phenomenon it once was is long over. Nonetheless it did leave a legacy,  the memory of it remained – and a new generation of programmers would remember that people had once enjoyed looking to see what their friends were up to – and bring that back to the internet in a new form.**

*In case it wasn't obvious, this was probably the most polite slang for an erection he could think of.

**I have no evidence that either twitter or facebook's developers ever used or were consciously influenced by finger, though I'm sure they would know about it – this is not meant to be a claim of direct origin but rather an extrapolation of a basic idea, invented and reinvented. Whether the reinventers knew, or cared, that they were not the first doesn't change that they weren't.

I have to admit that I have never been a huge fan of emacs as a program – as the classic joke goes, emacs is a wonderful operating system, too bad the editor sucks. Having said that, emacs cannot be underestimated for it's incredible contribution to computing – it sparked a revolution that is still going on and from a historical perspective it may be the single most important piece of software ever written.

EMACS had it's origins while a young Richard Stallman was working as an operating system developer in MIT's AI lab, originally written as a developer's text editor for the ITS operating system, Stallman had written the program in a high-level language making it portable and since the program and source code was freely available it very rapidly became extremely popular among academics working on various operating systems – in particular Multics, VMS and Unix. 

Part of what made it so popular was that the program was developed at the A.I. Lab – and had exceptional support for LISP – the AI language of choice (a language which also happens to be almost identical to lambda calculus – and one of the strongest arguments in favor of the idea that software is just mathematics). EMACS didn't just support lisp – it was extensible through lisp and before long some very powerful extensions would come to be written. A web browser and an e-mail client would ultimately be included and there was even a powerful LISA program that sounded like a Freudian psychologist and really could fool people for a while.

It was there, that Stallman did something incredibly important. In deciding how to deal with all these extensions – Stallman came up with the EMACS-community agreement. This document, simple as it was, was a truly crucial step in history – because that agreement would later become the model for the GNU/GPL.

That was emac's biggest contribution to the history of free software – in a very real sense it was the first ever program to be copylefted. While the academic notion of sharing was alive and well in software from it's inception right up to well after EMAC's was first written – EMACS took that notion outside of just academic circles into the wide world of software as a whole and formalized the ideals with a written (if simplistic) agreement. 

It was the start of what would become the free software foundation and the GNU operating system – one variant of which I am using to write this post, and the foundation of the GNU/GPL – the license that governs the vast majority of free and open source software including the MySQL database behind this site and the wordpress platform that is showing you this post – if you are using firefox to view it then your browser is under a license directly derived from the GPL, if you're using Chromium then it's under the LGPL – and even closer derivative.

That's a pretty impressive legacy. But the emac's legacy doesn't end there. Shortly after leaving the AI lab to begin his work on the GNU operating system,  Stallman recognized that quite a lot of potential users of his program at that time 1983) didn't have internet access to easily download emacs. So he packaged it on tapes (then the most widely used portable mass-storage system, equivalent in the computing era of the time to memory sticks or rewrite-able DVD's today), and sold those tapes for a nominal fee.

This was the first ever free software business. With it Stallman proved that not-only was free software an ethical force – it created lucrative market opportunities that could be profited from. It paid his bills and much of the early GNU development costs for quite some time (the first of several FOSS businesses ran before a MacArthur Genius Grant removed any need for him to ever earn a living again so he could devote all his time to the FSF).  This business of collecting and prepackaging free software was a fore-runner of the later business model of creating free software distributions to be sold – which in the early nineties was what gave birth to the GNU/Linux distribution concept – a concept we all still use today. Ultimately Ubuntu has it's roots in Debian which alongside RedHat, Slackware and a few others were doing exactly that to make money in the early parts of the 1990's when internet access was still rare and expensive.

It's still the primary business model for Slackware in fact, and devoted slackers usually buy a copy of the distro (even if they have already downloaded it) to support Patrick Volkerding's work.

And that was emacs. It's history was not without controversy however, it was also at one point at the heart of one of the most unsavory bits of FOSS history. Major projects forking is a very rare thing and when it happens – mostly one fork completely wins out, in rare occasions you will find both appealing to strong but non-overlapping groups of users and existing for a long time in conflict. There were only really two major times this ever happened and Stallman's software was involved on both occasions. EMACS and XEMACS was the first – and Stallman still doesn't like the mention of the latter, the other one was gcc vrs egcs. The latter after several years worked out their differences, the egcs code was folded back into gcc and it became one project again. The former one was a bitter feud lasting nearly a decade before xemacs ultimately died a quiet death.

EMACS is still around and included in the repositories of almost every distribution though almost none include it in their default installation anymore. It's a huge program (quite possibly one of the largest text-only programs every written) and a dedicated group of users (mostly developers) continue to deem it their editor of choice but it's days as one of the mainstream programs in the Unix/Linux world is long over in this day when hardly anybody uses a text-only text-editor anymore the spot for the occasions when you need it was won mostly by VI in such incarnations as VIM and Elvis – or for the ubuntu users – the default text editor on their distribution which is nano – itself a clone of the older pico editor which was once created as an easier to use text-editor than the standard options of vi or emacs.

Stallman is quite unbothered about VI, though he is no fan of it, it holds a prime spot in his St. Ignutius of the Church of Emacs sketch when he states that using a free version of VI is not a sin in the church of emacs but a penance.