Slashdot Mirror
New Programming Languages Come From Designers
eldavojohn writes "A very lengthy and somewhat meandering essay from Crista Videira Lopes has sparked off some discussion of where new programming languages come from. She's writing from the viewpoint of academia, under the premise that new languages don't come from academia. And they've been steadily progressing outside of large companies (with the exception of Java and .NET) into the bedrooms and hobbies of people she identifies as 'designers' or 'lone programmers' instead of groups of 'researchers.' Examples include PHP by Rasmus Lerdorf, JavaScript by Brenden Eich, Python by Guido van Rossum and — of course — Ruby by Yukihiro Matsumoto. The author notes that, as we escape our computational and memory bounds that once plagued programming languages in the past and marred them with ultra efficient syntax in the name of hardware, our new languages are coming from designers with seemingly little worry about the budget CPU being able to handle a large project in the new language. The piece is littered with interesting assertions like 'one striking commonality in all modern programming languages, especially the popular ones, is how little innovation there is in them!' and 'We require scientific evidence for the claimed value of experimental drugs. Should we require scientific evidence for the value of experimental software?' Is she right? Is the answer to studying modern programming languages to quantify their design as she attempts in this post? Given the response of Slashdot to Google's Dart it would appear that something is indeed missing in coercing developers that a modern language has valid offerings worthy of their time."
All you need to create a good programming language is a beard. The more epic the beard, the better your language will be
Not quite true. There are believed to be a very large number of possible models for computation, of which functional and imperative programming are but two.
Most of them are unlikely to be particularly useful, but there is plenty of scope for new languages which exploit them.
>under the premise that new languages don't come from academia
http://en.wikipedia.org/wiki/Guido_van_Rossum :
>Van Rossum was born and grew up in the Netherlands, where he received a masters degree in mathematics and computer science from the University of Amsterdam in 1982. He later worked for various research institutes, including the Dutch Centrum Wiskunde & Informatica (CWI), Amsterdam, the United States National Institute of Standards and Technology (NIST), Gaithersburg, Maryland, and the Corporation for National Research Initiatives (CNRI), Reston, Virginia.
Wrong premise.
http://en.wikipedia.org/wiki/Yukihiro_Matsumoto
>He graduated with an information science degree from University of Tsukuba, where he was a member of Ikuo Nakata's research lab on programming languages and compilers.
Again wrong premise.
It's also worth remembering that performance doesn't mean the same as it used to. An Erlang program, for example, typically runs at about a tenth the speed of a C program doing the same thing... when you have one core. On the other hand, it's pretty easy to write Erlang programs that scale up to 1024 processors (I've written Erlang code that, without any special effort, scaled almost linearly when moved from my single-core laptop to a 64-processor SGI machine and the profiling data indicated that the load was still pretty evenly distributed between Erlang processes so going to 512 or more CPUs would have been easy). When even mobile phones are multicore, this matters a lot more than single-threaded performance. There are lots of things in C that make it very difficult to get good performance when you go beyond about 16 threads (e.g. no differentiation between thread-private and shared data, no immutable-after-creation data types) but which were not a problem for single-threaded performance.
I am TheRaven on Soylent News
"Languages designed by academics like FOTRTAN, COBOL, C"
Were apparently desighned by academics obsessed with internal consistency and are now mostly deat tounges.
These are contrasted with languages hacked up by people to get stuff done.
WTF?
FORTRAN was the first ever language and was hacked up by someone who wanted to get stuff done because ASM was too much of a pain in the neck. It was unlike the author's bizzare assertion the easiest to use language at the time of being written. That was the entire point! While its use may be on the decline, it has been in use for 55 years! And major important packages are still written in FORTRAN.
And C? Seriously? Yet another language which was hacked up by a bunch of hackers to get stuff done. Apparently it's mostly dead. Even though it is the main implementation of 3 of the "less academic" languages listed.
I'm surprised there isn't a "c++ is dieing haha lol!1!111" in there too. I'm glad the author never tried to argue that C++ has internal consistency (I do love C++, but...).
And COBOL being an academic language? Oh dear.
Conclusion: article is crap.
SJW n. One who posts facts.
Good grief, what a profound misunderstanding of the entire field this post represents.
If you have an interest in this field, you need to spend some serious time with Haskell and LISP before you even begin to think about writing longwinded comments about how all languages are fundamentally the same.
It is trivially true that any program you can write in [language X] you can also write in assembler, and therefore C. If the entire field of programming languages could be summarized like this, why aren't we all using assembler?
The insight only comes when you understand this thing called "abstraction" and why it's useful. There is a reason I use Django templates, and don't usually write HTML-producing code in C. There is a reason I use LISP when I'm doing natural language processing. I can do more work in one line of Python than you can do in 100 lines of C. The right language for the job can make two orders of magnitude difference in productivity. If you don't understand that, please, STFU.
I have programmed professionally in more than 30 languages including machine codes, assemblers, FORTRAN, COBOL, Algol, C,C++, lisp, Prolog, and a variety of "4GL"s. I have used Java and Python since retirement and I can say one thing for sure about them all. Choose the right one for the job and you're half way done, choose (or be forced into) the wrong one and you you are going to pay for it in blood, sweat and eventually tears. On at least two projects (each being more than 50 man years of design and coding effort) it was worth devising a new language with a syntax suited to the problem and writing the compiler. For some jobs, readability of the code by non IT staff can give a huge payoff, for others raw performance is the only criteria. Real time interaction with physical systems usually needs a "lower" level, C or even assembler, Complex data requires object orientated structures and for once off "need it today" jobs, Java might be the answer. Maintainability brings another load of constraints, as does the intended "longevity" of the project, and don't get me started on the whole domain of "proof of correctness".
It is very easy to forget that a language is just a tool. If you only have a hammer you will find screwing a problem, but then you are reading this on slashdot.
nec sorte nec fato
Ideally, programming should be a playground accessible to all, not like today where it's more of a military discipline camp accessible to all.
I very strongly disagree. Good programming can't allow for lack of discipline. People who go for more "elaborate" languages, with loads of libraries available, should be forced to understand what goes on behind the scenes.
I remember a researcher in a biotech company I used to work for, who tried to get help on forums on the Internet, and published parts of her ruby code (she'd had a 4 hour lessons of ruby once at university). The code included (read-only) account passwords to a research database and her own AD password in the company. Plus the variable names left little doubt as to what she was working on at the time.
Bottom line is: she didn't know what she was doing, but someone trusted her with code, and put the company's research at risk. So no, programming is not a playground, it's a serious matter. And as far as you don't understand what a buffer overflow is (and a load of other things), your employer shouldn't allow you to code.
I disagree. For me, there are three important points to discuss programming languages:
1. Syntax
2. Access
3. Community
ad 1) We know all about and can analyse the syntax. Fine. All the discussion happens here. .NET lacks here, and massively because there is no spirit to make libraries available to others for free causing a non-availability of free libraries.
ad 2) But what does the finest Haskell help me if I can't access a CD, Bluetooth or a XMPP server, and whether it makes a difference where I want to run the code (web server, mobile phone, mainframe, laptop). In principle, all languages are Turing-complete and equivalent, and I can write wrappers between languages, but as long as I can't *practically* do all the things I need, I'm stuck. The available libraries/access methods draw a picture of what is possible. Here C due to its age, Java with it's tendency to make package that are reusable and Python are among the best (from my experience). As an aside,
ad 3) A language is also dominated by its users. This is most noticable with PHP. The background of users dominates what a language should do. Also, this determines the amount of help and easy-to-access documentation. Which again makes a language popular or not.
One individual is not capable of addressing (2). Also, whether a language is picked up by the masses (3), or whether you can build and hold this community, is not a rational, predictable process. When designing a language, you don't have full control over success.
When comparing two languages, don't just look at (1), also look at (2) and (3).
NB: The message above might reflect my opinion right now, but not necessarily tomorrow or next year.
The big advantage of C++ over C is resource management (using "RIAA").
I think you meant RAII (resource acquisition is initialisation), also known as SBRM (scope-bound resource management). The RIAA would just disable all your copy constructors to stop copyright infringement.
1) Some programming languages are great for all the code you have to write. They are very powerful, very expressive, high performance, etc etc.
2) Other programming languages are great for all the code you DON'T have to write! They have lots of _good_ well documented standard or defacto standard libraries, modules, so you don't actually have to write stuff for a lot of things.
Being a crappy lazy programmer I prefer languages that satisfy both 1) and 2), but with 2) as a priority. Because I end up having to write a lot less and it's not my responsibility to document, support and fix those libraries. Yes I may have to fix or workaround some of the library bugs, but it's not really my job...
The good libraries are written by programmers far better than me, so if I use their stuff instead of reinventing it, it means fewer bugs and higher quality.
Of course, if you are a great programmer your priority would be 1). 2) only being a minor factor.