books-programmingLanguages-programmingLanguagesChDynamics

Table of Contents for Programming Languages: a survey

Chapter: The dynamics of programming language design and adoption

The process of designing a programming language

"Even if you’re designing for professional programmers, in the end your programming language is basically a user-interface design." -- Alan Kay, queue.acm.org/detail.cfm?id=1039523

"Choosing the best notation is the entire problem of programming language design, and this problem is neither mathematical nor scientific. A programming language is a user interface for programmers, and if you can reduce UI design to math, science, or any formal process, call Apple, not me." -- http://unqualified-reservations.blogspot.com/2007/08/whats-wrong-with-cs-research.html

Design by committee

There is a general sense that languages that are 'designed by committee' adopt an 'agglomerative' style and turn out too big (see below for discussions of 'agglomerative' and 'big' languages).

Some hypothetical reasons for this could be:

Evidence:

Counter-evidence:

Generally the antithesis of 'design by committee' is thought to be languages designed by one person, however languages designed by a small number of people, say two or three, are often not said to be 'designed by committee'. In addition even languages purportedly designed by one person often in reality have a small community of designers after the initial proposal is publicized but before a practical implementation becomes available, with one person having dictatorial control.

Later changes in a programming language

some languages get very conservative: the language is standardized, then new verisons evolve by asking the compiler writers, "what non-standard things are you already doing that we can all agree on"? If this is the only type of change, then many kinds of change are unlikely to occur ( https://lobste.rs/s/ts266k/single-member_structs_for_type_safety_in_c )

The dynamics of adoption of programming languages

Why some languages succeed

aside from the stuff covered in the chapter Criteria

Lack of buginess

Perhaps the most important attribute for a programming language to be adopted (in my opinion) is a lack of bugs; the language implementation should not crash, and it should behave correctly.

e.g. D has had some problems with this https://news.ycombinator.com/item?id=6532806 , https://news.ycombinator.com/item?id=6534390

libraries are the next most important thing

todo find quotes

"I have yet to meet a language feature that's more important than library availability, profiling, autocompletion, documentation, debugging, etc." -- https://news.ycombinator.com/item?id=7110629

(note about libraries; libraries are tied to languages: "Unfortunately, you can't just port your existing API to the new, higher-level language and runtime and expect it to be pleasing. One of the biggest benefits of moving to a higher-level language is the elimination of the most awkward and warty conventions, concepts, and entities from your previous API. " -- http://arstechnica.com/apple/2010/06/copland-2010-revisited/2/ )

budget

libraries, dev tools, marketing

e.g. java, c#

OS blessing

e.g. C and Unix, C++ and Windows

http://stackoverflow.com/questions/580292/what-languages-are-windows-mac-os-x-and-linux-written-in

"For instance, Basic would never have surfaced because there was always a language better than Basic for that purpose. That language was Joss, which predated Basic and was beautiful. But Basic happened to be on a GE timesharing system that was done by Dartmouth, and when GE decided to franchise that, it started spreading Basic around just because it was there, not because it had any intrinsic merits whatsoever." -- Alan Kay, http://queue.acm.org/detail.cfm?id=1039523

network effects (the rich get richer)

e.g. C

the elitist perspective

" One could actually argue—as I sometimes do—that the success of commercial personal computing and operating systems has actually led to a considerable retrogression in many, many respects.

You could think of it as putting a low-pass filter on some of the good ideas from the ’60s and ’70s, as computing spread out much, much faster than educating unsophisticated people can happen. In the last 25 years or so, we actually got something like a pop culture, similar to what happened when television came on the scene and some of its inventors thought it would be a way of getting Shakespeare to the masses. But they forgot that you have to be more sophisticated and have more perspective to understand Shakespeare. What television was able to do was to capture people as they were.

So I think the lack of a real computer science today, and the lack of real software engineering today, is partly due to this pop culture. .... I think there’s this very long lag between what you might call the best practice in computing research over the years and what is able to leak out and be adapted in the much more expedient and deadline-conscious outside world." -- Alan Kay, http://queue.acm.org/detail.cfm?id=1039523

worse is better

"Let’s say the adoption of programming languages has very often been somewhat accidental, and the emphasis has very often been on how easy it is to implement the programming language rather than on its actual merits and features." -- Alan Kay, http://queue.acm.org/detail.cfm?id=1039523

worse is better essay

open source

For example, the language D has been criticized at times for not having a reference implementation that was sufficiently open. (e.g. https://news.ycombinator.com/item?id=6532481 ).

Since open-source became popular, it is rare to find a new popular programming language which does not satisfy at least one of the following:

The dynamics of adoption of programming languages: how long does it take?

" Scott Lawrence 8/14/10 Re: [go-nuts] Re: GO Vs D OTOH, taking a few quick glances around (http://www.complang.tuwien.ac.at/anton/comp.lang-statistics/ mainly), it looks like most popular programming languages of today spent a good deal of time in obscurity. In 1997, 8 years after the python project was begun, it was at level of obscurity comparable to ada today (if these statistics are to be trusted). Java did better - it was announced in 1995, and JDK1.0 was released in 1996. It rose out of obscurity within the next two years. C seems to have done about as well/poorly as python - it was working well in 1973 (when the Unix kernel for PDP-11 was written in it - I'm reading from http://cm.bell-labs.com/cm/cs/who/dmr/chist.html, I wasn't alive then), but C wasn't "spreading widely" until the 1980s (again, semi-quoting). Of course, B was around for a good bit before C (two years at least), and the BCPL description was around in 1969, 4 years before any part of it was ready for handling the Unix kernel.

So counting the years elapsed seems a poor predictor of language adoption. "

Why do some language communities fragment less than others?

Lack of powerful metaprogramming

http://www.winestockwebdesign.com/Essays/Lisp_Curse.html

A single person or organization in charge

cite http://programmers.stackexchange.com/a/143240

A single implementation

http://programmers.stackexchange.com/a/147481

Young languages fragment less

cite http://programmers.stackexchange.com/a/143344

Free tools

http://www.ianbicking.org/where-smalltalk-went-wrong.html claims that commercial tools don't count towards the adoption of programming languages because many individual hackers don't buy them, and most corporations, who do pay for tools, don't use new/small languages.

Evolution in the programming language landscape

Over time, higher level languages become more popular

e.g. in the past we see machine language, assembly language, fortran/C/etc, C++, Java

probably because over time hardware becomes more capable, making the expense of stuff like automatic memory management more tolerable (e.g. machine time becomes less valuable compared to developer time)

however there are still places where this doesn't hold, generally in embedded systems

others who agree with this hypothesis:

.