Ghosts in the Machine: 12 Coding Languages That Never Took Off

There are literally over 8,500 programming languages in existence, yet despite all these options, the vast majority of us all use the same dozen or so. Whether it's infighting among language creators, bad marketing, new technologies or just being a crummy language, there are almost as many reasons why coding languages didn't become popular as there are programming languages.

In this article we examine 12 coding languages that never took off, and the reasons they didn't.

ALGOL 68: ALGOrithmic Language 1968

Called "the most magnificent combination of theoretical success and practical failure in the history of programming languages," ALGOL 68 emerged from a notoriously unruly design committee (who, for programmers, sure knew how to throw around the personal attacks and backbiting) to be the replacement for ALGOL 60. Although the language itself is now virtually useless, it still serves as a model for how NOT to organize a design effort. ALGOL 68 was the first, and remains one of the few, programming languages which had a complete formal specification before its implementation. Unfortunately, the supporting specs were virtually unreadable and immediately gave the whole project the reputation for being overly complex.

Indeed ALGOL 68 was complex, cumbersome and had some of the weirdest operator characters ever. But it was also the first truly universal language, served as an inspiration for C and the Bourne Shell and simplified parallel processing to a degree that newer languages like Java and C++ still can't touch.

ALGOL 68 died before it ever had a chance. Given that nobody could keep the operator characters straight, the formal specs were incomprehensible, and the insults flying back and forth among dev committee members were a scandal, this language was dead in the water well before people could judge it on its merits.

brainfuck

Yes, that really is the name of the programming language. "brainfuck" (not-capitalized despite the fact that it's a proper noun) is potentially the most nonpractical language ever created. Developed to challenge programmers, brainfuck was designed to be implemented with the smallest possible compiler. Some have been made smaller than 200 bytes.

The entire language consists of eight commands, and a program is simply an arrangement of these commands which are executed sequentially (subject to a few exceptions). The eight language commands are as follows:

> < + - . , [ ]

What happens if you type any other character? They're treated as comments. The true tedium of the language can only be appreciated by viewing the "Hello World":

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.-------

-.>+.>.

Needless to say, brainfuck never quite reached the popularity of Java or C++ for pretty obvious reasons. If you're a glutton for punishment, try programming in brainfuck for about 15 minutes, but anything beyond that and the damage to your cerebrum might be irreversible.

Befunge

Designed to be the worst enemy of compilers, Befunge remained virtually impossible to compile until very recently. All instructions are single characters, and with Befunge 97, virtually every printable character is a valid instruction (yeah, so that's fun). Befunge differs from other languages insofar as programs are arranged on a two-dimensional grid and arrow instructions (<, >, ^, v) direct the control flow left, right, up or down. Just looking at the "Hello World" is enough to give you a headache:

vv < <

2

^ v<

v13v4

^ ^

> >?> ?>5^

v v

v97v6

v v<

8

. > > ^

^<

Befunge simply could never be more than a ridiculous mental exercise of a language because of its difficulty and complexity. Thankfully, it wasn't designed to be. So while it's unsurprising that this language hasn't been the source of any major program undertakings, the fact that it was designed for niche use makes it less tragic that it has ended up there.

REBOL: Relative Expression Based Object Language

What do "Livin La Vida Loca" by Ricky Martin, "Mambo No. 5" by Lou Bega and REBOL all have in common? They all peaked for about a month in 1999 and nobody has thought they were cool ever since.

REBOL blasted onto the scene as the ultimate universal language. It ran on 38 different operating systems, it worked really well with Internet-enabled apps and it had some initial buzz. So what happened?

A two-pronged attack killed REBOL. First, the fact that the end user had to single-handedly install an interpreter and do a good amount of legwork to get it and the application in sync ensured that the language wasn't going to be adopted by the masses. Those users that did adopt REBOL, however, then found that with the advent of .NET, many of the advantages of REBOL were now obsolete. At this point, REBOL is regarded as a utility language used primarily by programmers for in-house scripting.

Plain and simple, REBOL is an example of a solid language that was developed without the mainstream end user in mind. The fact that it wasn't widely adopted from the start meant that subsequent developments weren't as forthcoming as they might have been, which ultimately, has probably accelerated REBOL's demise.

ColdFusion

ColdFusion (aka ColdFusion Markup Language or CFML) was billed as the next big Web-development language, in the same vein as ASP.NET or Java Entrprise. ColdFusion was expected to be very popular because of its ease of use and accessibility for beginner programmers.

CFML uses tags reminiscent of HTML and need not be well-formed, which is a big help to newer (or nonmeticulous) programmers who frequently forget to close tags or confuse capitalizations.

Given its ease of use and its position as a transitionary language from HTML, it is rather surprising that ColdFusion's popularity has waned so quickly. The ColdFusion killer wasn't due to a failure in marketing the programming language, nor due to any particular language design flaw. Instead, ColdFusion has been slowly displaced by ASP.NET and PHP, which offered a MySQL integrated product in a free open-source form.

Java2k

Java2k is a probabilistic, not deterministic, programming language. According to the creator, that is because it mimics the true nature of the universe, which never provides certainty, only probability (that's pretty heady). In plain English, that means that when implementing even built-in functions, you only have a 90 percent probability that the function will do what you want it to. Every function has two implementations, and you can't control which one is chosen, meaning the program you develop will be different every time it's run.

Why develop a language that purposefully yields random results each time it's run? It certainly isn't to create anything too important. According to the language designers, they developed Java2k, "because plain Java sucks." The real reason Java2k exists is to give programmers a healthy mental workout as they attempt to develop programs within Java2k that yield predictable results.

Given that you have to code in contingencies for every function, the "Hello World" for Java2k is massive. Check it out here.

Any language that can't yield predictable results for a built-in function, not to mention a simple program, simply cannot be used for almost any practical application. Therefore, if you see Java2k in action, you know that somewhere along the line there was a programmer who was both very smart and very bored.

INTERCAL

In the movie "Windtalkers" with Nicholas Cage, the U.S. Marines use Navajo translators to communicate secret messages for them, because the Navajo language can only be spoken, having no written form. INTERCAL is sort of like that, but the opposite.

This ridiculous esoteric programming language was designed as an unpronounceable satire of FOTRAN and COBOL (yes, it's old). Everything about the language is absurd. From the form of the manual, which contains a "tonsil," as explained in this footnote:

"4) Since all other reference manuals have Appendices, it was decided that the INTERCAL manual should contain some other type of removable organ."

The language also uses modifiers such as "PLEASE," which if not used frequently enough is rejected by the compiler as insufficiently polite, and if used too much is rejected for being excessively polite. More frustrating still, was the fact that despite the existence of this feature, it was undocumented in the manual.

As a practical language, INTERCAL is Turing-complete, meaning it actually works. But if you're planning on actually trying to use INTERCAL you should first check your sanity, and you should be prepared to wait a long time. A Sieve of Eratosthenes benchmark, computing all prime numbers less than 65536, was tested on a Sun SPARCStation-1. In C, it took less than half a second; the same program in INTERCAL took more than 17 hours.

VRML: Virtual Reality Modeling Language

Pronounced "vermal", VRML was supposed to bring the graphic equivalent of Nintendo 64 to the internet via your dial-up connection. Developed by SGI, VRML promised the capability to bring 3D environments to the Iinternet via dial-up in a way that noone else could. That promise was so revolutionary, that NASA adopted the language. So in that respect, it's a little dissapointing that VRML wasn't more widely adopted. On second thought, it's a good idea VRML didn't take off; who knows if we would have survived yet another online marketing gimmick for AOL to promote the millions of free CDs it pumped out in 1997.

Unlike some of the other languages on our list, VMRL had some wide audience appeal and the potential for a lot more. At its height in 1997, VMRL was occasionally used in personal home pages and on some 3D chat sites such as "CyberTown." The real VRML killer was the fact that SGI restructured and sold the division off to Computer Associates who did not develop or distribute the software. Today, VRML is still used in education, research, and other areas where an open specification is highly valued. But on the whole, VRML is yet another example of an excellent product that was not properly marketed and distributed during the height of its usefulness, so that by the time its value was really appreciated, the technology had been superceded.

SMIL: Synchronized Multimedia Integration Language

SMIL, pronounced "smile", is a language created primarily for presenting (not streaming) multimedia content over the Internet. Real Networks created the language in order to be able to take care of some really big needs such as synchronizing text to be played with audio (gotta have those karaoke subtitles) and synchronizing Flash with audio. In effect, SMIL allows you to create a complete (though crude) video broadcast using only the bandwidth available to dial-up users.

Although there was also a competing language developed by Microsoft, SMIL remained the more powerful alternative. What ultimately ensured that SMIL would remain a marginalized language was a simple technological advancement: broadband Internet. With the widespread adoption of broadband into the average home, the need for a language that could create the poor man's equivalent of streamed video was less important when you could just stream video.

The failure of SMIL to go mainstream is really just a lesson of being in the wrong place at the wrong time. If SMIL had been introduced just as dial-up access was hitting mainstream America, SMIL might have seen the wild popularity that a language this revolutionary should have. Today, SMIL is still seeing some use in handheld and mobile devices, which has spawned the SMS (texting) alternative known as Multimedia Messaging Service (MMS).

Haskell

Yes, I know that Haskell is a relatively popular language compared to the other flops on this list. That said, Haskell has always had the feel of an also-ran language, despite its small but strong (and vocal) fans.

The fact that it is a leading functional language and a lazy one at that, means that the efficiency gains you can achieve through Haskell when creating and running different versions of a program are huge. Similarly, with unique concepts such as monads and type classes, Haskell makes writing some functions a whole lot easier than they otherwise would be.

That said, all of the things that make Haskell unique, have also led to its low adoption rate. There are a number of problems with functional programming languages and with lazy evaluation, which apply in full force to Haskell. In addition, the fact that the syntax is so subtle means that while experienced programmers can utilize the nuances, beginner programmers are left befuddled and confused when attempting to debug code.

All told, what killed Haskell was complexity. While the language has some unique characteristics to offer, the fact that there are more user-friendly, functional language alternatives available (such as MATLAB) shifts the cost-benefit analysis for any new programmer away from Haskell. Since incorporating new and inexperienced programmers is the lifeblood of a popular language, the fact that Haskell has not had many new adopters has ensured that it won't reach the popularity of other, more beginner-accessible alternatives.

Delphi

Delphi is essentially Pascal's version of Visual Basic. Given the Delphi Programming Language's past popularity, it's hardly fair to include it in our list of ghost languages. However, the fact that Delphi went from relative prominence to virtual obscurity in a very few years, means that it's certainly fair to say that Delphi hasn't "taken off" in the way most would have predicted in the mid-to-late '90s.

The Delphi programming language was the descendant of Turbo Pascal, and is often referred to as object Pascal, meaning that the tools in Delphi will seem familiar to anyone who regularly uses Visual Basic 3.0.

Given that this is an object language, which is designed to make programming in Windows easy, the decline of Delphi isn't a case of creating a language that was too complex for new programmers to get involved with. Delphi's "Hello World" isn't the most straightforward around, but by the same token, it isn't so difficult that new programmers would intentionally avoid the language:

unit hworld;

>interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls;


type


TForm1 = class(TForm)


Label1: TLabel;


private


{ Private declarations }


public


{ Public declarations }


end;


var

Form1: TForm1;


implementation

{$R *.DFM}

end.

The real Delphi killer was the advent of Visual Basic 6. Under Visual Basic versions 4 and 5, there were still a lot of things Delphi could do better and easier than under Visual Basic.

But by 2003 and the rise of .NET, Delphi had already begun its slow decline into obscurity. There simply isn't a strong need for a VB alternative, and given the strengths of VB, the continued decline of Delphi seems inevitable.

PowerBuilder

Before you start including the hate comments, yes, we're well aware that PowerBuilder (aka "PB") is still in use in hundreds of organizations around the world. But even the most devout PowerBuilder devotees would have to agree that PowerBuilder was never the same after 1996.

PowerBuilder was designed as an easy-to-use client/server graphical tool, which had the capability to communicate with the most popular relational databases, such as Oracle. On the whole, the project was a huge success, enabling the parent company, Powersoft, to go public on the growth and popularity of PowerBuilder.

The Internet boom, the launch of Delphi and the rise of Visual Basic together formed a three-pronged attack that together started the beginning of the end. As budgets shifted to Web projects and Visual Basic, and Delphi users began to outnumber PowerBuilder programmers, the writing was on the wall for PowerBuilder. There isn't much of a lesson when it comes to the demise of PowerBuilder; it was a solid language which simply got beat out by newer technology and changing market conditions.

Programming languages are not immune to the same difficulties that many businesses and new concepts face. Sometimes, the success of a programming language is just a matter of having the right combination of language characteristics and technology at the right time. But just as fickle as the success of a language can be, the reasons for a programming language's failure can be equally unpredictable. In this article we have presented just 12 of the literally thousands of programming languages which have failed to go mainstream, and now, for one reason or another, are now mere ghosts in the machine.