5 languages with no programmer

Some programming languages ​​though well designed experienced no success. Why?

This is a question that must be asked before creating a new language, as we see that it appears several new ones each year, but will they be adopted by programmers?

The following five languages ​​all have interesting features, high-level functions, a clear syntax unlike Perl or PHP. But apparently, it missed them something to become popular.

Icon

The idea was to combine the pattern-matching capabilities of SNOBOL with the structure of a universal language such as ALGOL. Its syntax is similar to Pascal and C, it has the simplicity of scripting languages​​, with generators and other innovative functions for the time of its creation.
It wanted to be special with goal orientation: "if condition then action" becomes this: if action (trying the action), then action (if it succeeds another action, otherwise it continues with the next instruction). This could be achieved with the classic if.

Sample code:

procedure disp(s1)
   while i: s1[i] do {
      c = s1[i]
      write(i)
   }
end

s = "hello"
disp(s) 

All this has had no success, few followers came to worship the icon. This did not deter a group of academics to write an object-oriented version named Unicon. Unicon has not been more successful although there are new versions each year.

Oz

It wanted to bring magic, which is why the reference to the Wizard of Oz. Concurrency is integrated to the language with the reserved word thread that opens a block to be executed in concurrency with others.
It incorporates multiple paradigms, such as functional, logic and constraint programming next to imperative code. As Python which appeared the same year, it added Tcl/Tk for GUI building.
The basic syntax is clean, but it can easily happen to cryptography as seen on the Sieve of Eratosthenes algorithm written in this language:

fun {Sieve Xs}     
   case Xs of nil then nil     
    [] X|Xr then Ys in        
                thread Ys = {Filter Xr fun {$ Y} Y mod X \= 0 end} end
        X|{Sieve Ys}
   end
end

Its implementation in Mozart runs on a virtual machine that makes it rather slow, its main drawback.

Appeared in 1991, this comprehensive language was maintained until 2008, but the magic did not operate so the partition has been closed.

Pike

This version of C makes it a modern language featuring object-orientation without the complexity of C++. It has a garbage collector. Thus it provides a conventional syntax without the disadvantages of C as manual memory management.
But the disadvantage of a C interpreter, even augmented with objects, is that we no longer have access to libraries compiled from the C language and also it loses the original interest of this language: portability.

A Pike class:

class Car
{
  inherit Vehicle;
  int speed;

  void setSpeed(int s)
  {
    speed = s;
  } 
}

Appeared in 1994, it is still maintained. A pike is the logo of language but very few programmers have put the fish on their plate.

Seed 7

It is a language that wants to be of higher level than Java. It supports multiple dispatch and is object-oriented. It is also extensible: we can develop the language itself and add new language instructions in the program.

Example showing an advanced control structure ...

for a, b
where a.name = b.name do
   writeln( a <& " and " <& b <& " are same object");
end for;

But where could be replaced by if.

Wanting to be more strict, it removes the break and continue considered hidden gotos. In my experience, this is a big miss.
Appeared in 2005, it is updated until now. Seed has not sprouted, few programmers have come watering it.

Euphoria

Designed in the euphoria apparently it is simple and allows easy programming. It immediately appealed to BASIC programmers. It has dynamic variables such as Python and is also interpreted or compiled, has a garbage collector and runs on Linux, Mac and Windows. It has interfaces to several GUI libraries and databases. Besides that, it has strange types atom and sequence which bring no discernible benefit.

function disp(atom str)
   for i = 1 to str.length
     puts(str[i])
   end for
end function

atom str="hello"
disp(str)

It was developed from 1993 to 2010 before the euphoria turns into boredom, due to lack of followers to participate in the party.

Some lessons can be drawn ...

Each of these languages ​​provides new sort of types or syntax. But one should not change what programmers are used simply because it looks better: there must be a real practical advantage.
One should not to create a language only to be different but to bring something more. Thus, Niklaus Wirth has not created Pascal for creating his own language, he first proposed a modified ALGOL to correct its defects. An since ALGOL W was ignored by the profession, he then created a language that totally eclipsed ALGOL, proof that his ideas were correct.

Some ideas seem interesting on paper, but when put in practice, seem less. For example, making an extensible language. Reusing code becomes difficult if each program has specific sorts of instructions!

Another lesson is that to become popular, a language needs above all a large library of functions. Python for example, established in 1991, although very simple to use, has been widely adopted only in 2001, once augmented with all the useful libraries in all domains. Julia as Oz offers many possibilities, but it is becoming popular due to its scientific libraries. PHP and Perl, both having a more than questionable design, are widely used because the language in reality, it is the API.

So it is useless to create a new language with a simple code that allows to write 10 times faster, new data structures and new capabilities to easily transpose reality into code, if one has not all functions that programmers need to make their applications and that actually allow a program to be produced 1000 times faster.

Finally, if you want to create a new language, you must ensure two things:

  1. It brings a unique feature that makes it indispensable in a domain.
  2. It can readily access a wide library of functions, allowing to create applications usable in production.

It is not necessary that it has a "killer app", it just needs to have a potential killer app. It is not necessary that it be supported by a great brand, but without that it will take several years before expecting widespread adoption. The list of the most popular languages ​​confirms all that.