## Grassroots computing languages hit the big time

This article points out how open source scripting languages are in vogue in the corporate world:

Scripting languages have been used to build millions of applications on the Web, but in general have not been adopted widely by corporate developers. But more and more businesses and IT professionals are looking to these languages as a way to simplify and speed the creation of custom in-house programs, thus avoiding the now all-too-common logjam of late or overbudget applications.
Personally, I think the rise of these scripting languages as well as languages like Java demonstrates that the use of new programming languages is more fluid than most are willing to admit. Of course, it also demonstrates that building new scripting languages is becoming easier and easier.

## Comment viewing options

### i think

it demonstrates that a lot of non-technical people or people without vast knowledges of computer science are building their own, rough, quick-and-dirty in-house applications that work well, develop fast and most likely are hard to mantain ( not necessarily because of said languages lack of features or something ).

### PHP: worse is better.. (are you sure?)

I am especially disappointed that PHP has become so popular. The article focuses a great deal on PHP and Zend. PHP is the worst language abortion I have used! Even Perl is preferred!

Unfortunately, I still use PHP for some web projects because PHP is the only server-side language my web host officially supports!

### indeed...

PHP is an abortion from Perl: it comes with some of the same ugly syntax, but none of the conveniences or flexibilty. It's specially bad for its lack of modularization features other than files and classes and for the "convenience" of global variables sprinkled all over your project files ( well, much of that due to stupid wannabe programmers anyway ) and the hated 1-million-inconsistently-named-and-unrelated-functions-in-the-same-namespace
thingy...

### They still have global vars by default?

I thought the magic globals were gone with recent versions of PHP. But, yeah, the 'well if you want namespaces you're going to have to manage them like you're using C' and the [some_function, smfunc somefunction] stuff is pretty ugly.

### globals

yes, automagic global variables are gone. But, in change, now php has this things called "superglobals" :)

### I take you for a glass-half-empty kind of person :-)

Just trying to accentuate the positive - programmers are willing to learn new languages. Of course, that begs the question of how adept they are at embracing new paradigms or software engineering techniques. Object Oriented programming has been 15 years in widespread use, and it's still not practiced particularly well. And, of course, the Lispers will remind us that the current batch of programming languages are just variations on ideas that were discovered long ago.

Still, I like to see the glass as being half full - new languages do have at least an outside chance of coming into use.

### yeah, i'm more of a pessimist... :)

"programmers are willing to learn new languages."

Given that the number one scripting language on the JVM these days is Groovy -- complete with java-like syntax, but less declarations -- i don't really see that as an evidence that they are willing to _learn_ anything new. Just to unlearn somethings ( think less about types, for instance ) and pretty much keep up the same boring old C-like syntax and imperative style they first learned in college...

There is Jython, there's Kawa and the list goes on. Nothing will move them, unless it looks familiar. that's sickening sad. In my job, i just quitted trying to bring a bit of creativity here and there in the Delphi code: my coworkers are copy-and-paste fanatics who just don't give a damn about clearness, expressiveness and code reuse in general. Only thing that matters are stupid hungarian notation and names as long as a road. They already standardized in stupidity and there's no coming back...

### Two words: synthetic code

While certainly not the only reason for these languages catching on, less synthetic code is one of the greatest benefits of dynamic languages. Want to append one list to another in Perl?

my @z = (@x, @y);

And who cares what data types are in there!

By allowing us to focus on solving the actual problem rather than the fiddly bits in the language itself, our productivity is increased and we experience fewer bugs. If we find that we don't need the performance that other languages give us, we save a lot of money. It's natural that the suits are going to notice this (even if they're frequently incapable of making a sound technical decision.)

### Yeah!

And if you want to get the length of a list...

my \$len = length(@foo);

Oh, I guess it does matter what type you passed to length, huh. :-)

### doh!

it matter it's a list. it doesn't matter what it is a list of, unlike in most mainstream typed languages...

### unlike in most mainstream typ

unlike in most mainstream typed languages...

I don't know if you put C++ in that category, but you can do fairly good dynamic programming with it:

list &lsaquo any &rsaquo list1;
list &lsaquo any &rsaquo list2;
list1 += 1,3.14, 'a';
list2 += "foo", myObject;
list &lsaquo any &rsaquo list3 = list1 + list2;


### yeah

with the hack on the AST processing called the template system...

### But it's such a "wonderful" hack...

Perhaps not as nice as Lisp macros (and the syntax is sure ugly), but I almost consider templates to be the biggest improvement in C++ compared to C.

Why?

'Tis much more easy to greenspun up a crude facility for dynamic dispatc than it is to greenspun up anything resembling templates.

After all, macro systems come in two flavors that I'm aware of:

* Those that work on the abstract syntax level (i.e. C++ templates, Lisp macros)
* Those that work on the pre-parsed input text (i.e the C preprocessor)

Ample evidence shows that the former is highly preferable to the latter.

### Why have the new languages become popular?

In my opinion these scripting languages have acheived fame because they meet social and human needs of programmers - the technical and functional requirements are not as critical to becoming popular.

There is a huge demand for languages that an average developer or user can be productive in quickly. Many unpopular languages are technically brilliant and extremely productive for skilled users. But they don't meet the social needs so they do not become popular. They then lack a community to help grow the language libraries, grow googleable help, and grow number of applications and code examples.

A popular language:

• Gives immediate gratification
• Gets you started on the soft stuff, but step by step gets you hooked on harder, better habits. The language doesn't just have cheap thrills, but allows you to develop serious applications.
• Has sustained geek coolness/buzz/trendiness
• Has avoided uncoolness/untrendiness
• Has a growing vibrant community
• Has a syntax that is easy for anyone who knows existing popular languages
• Syntax is human friendly (I suspect some unpopular syntaxes don't fit the needs of an average person's brain very well)
• Most anyone can have a go and get results. You don't need to be a CS major with training in 'difficult' language concepts.

Not all the above are needed, but most are. Have I missed any other important social aspects?

### Few more

• Comes with deep and useful standard libraries, so you can do things like regular expression matching, XML parsing, fetching email...the kind of stuff people need to do.
• Has one standard implementation, so you don't have the confusion of multiple, semi-compatible versions of a language (Prolog is a perfect example of the latter).
• ### Multiple versions

In addition to Prolog, you could mention the Lisp and ML families that have a multitude of implementations. The obvious advantage to dialects is that it provides language designers the freedom to experiment with new ideas without having to go through a committee (watering down any attempts at radical change). Tacking on features to monolithic languages always seems to have a kludge flavor.

As for popularity, I don't know that a standard implementation is a prerequisite for popularity. Fortran, COBOL, Basic, C, C++, Pascal, etc... never had a standard implementation and they all gained a wide audience. It's only with the advent of Java that a single vendor has tried to control the implementations, and they did that by keeping it away from a standards committee. Of course, we get C# in response to that effort.

On the other hand, the open source languages do tend to have a single implementation based on personal leadership (Wall, GvR, Matz) or just based on common interest. These languages, however, are constantly re-inventing themselves such that they have to convince the users that change is for the common good.

Anyhow, related to popularity is not only how good the language is today, but whether you trust the stewards of the language (be the corps, standards committees, or the charisma of the fearless leader).

### Single implementations

One reason that many open source languages have a single implementation is... because they are open source. (And the open source implementation is first). Not to mention that many of these languages do have "bazaar" development models FMTP. Thus, the two major motiviations towards development of a competing implementation (to make money, and to influence the design of the language) are less relevant.

If you look at, say, Common Lisp, many of the implementations are commercial. The ones that aren't commercial either fail to support certain platforms (notably Windows). In addition, many key features needed for computing are not defined by the Common Lisp standard--networking and concurrency, for instance.

A similar state of affairs exists with C/C++, one could argue. However, the primary open source C/C++ implementation (gcc) is the most portable C/C++ compiler, rather than the least; and is a robust, actively maintained, production-grade product. Furthermore, while the standards for C/C++ also are silent on topics such as networking and concurrency, C/C++ has the advantage of being the de-facto language for interfacing to both Windows and Unixish operating systems; and both OS's provide APIs for these things (POSIX, Win32) that have become de facto standards.

### open source

"One reason that many open source languages have a single implementation is... because they are open source."

I thought that would rather lead to countless forks, something the Java community always likes to point out when trying to convince themselves why having Sun as the single dictator is a good thing... :)

Personaly, i think the success of scripting languages is due to their pragmatic approach to day-to-day job programming, focusing on conveniences -- like the typeless approach and the huge libraries for interfacing with the environment -- for the programmer to achieve results fast, rather than being an academic lab for some awesome but still experimental new programming language features and techniques...

I've always been a fan of Python, Perl, Ruby and Tcl myself...

### I thought that would rather l

I thought that would rather lead to countless forks

Why? The evidence points in exactly the opposite way. The only compiler forks I can think of are a) SBCL from CMUCL, and b) GCC forking, and the fork subsequently being installed as the official version.

### sarcasm

I was just pointing out the Java community take on the issue...

### Forks are a function of the license

It's well established that copyleft licenses prevent permanent forking, wherein one party takes an existing code base, makes it proprietary, introduces useful extensions (to entice people to their camp) and gratuitious incompatiblities (to keep 'em from leaving). The multiple incompatible versions of Unix in the early 90s are the canonical example of this.

However, "friendly" forks are common and are healthy for a software ecosystem. Consider projects like Jython and stackless Python for instance. Sometimes the fork overtakes the parent and becomes the new "preferred" version (Cygnus/GCC); sometimes it is content to serve some niche. And sometimes it's just done for research or curiousity.

### "Downwardly scalable"

I wrote up some thoughts on "scaling down":

http://www.dedasys.com/articles/scalable_systems.html

The gist of it is that by making something easily accessible, it will be more valuable because more people will find it within their grasp. Because of this, it's also likely to be popular.

Your other points are good too.