Great Works in Programming Languages (2004)
cis.upenn.edu
cis.upenn.edu
SPJ is one of the most relevant programming language researchers of the past 20 years, but maybe his work is "too new" for this list. Reading his books and papers taught sparked the interest in programming languages in me.
http://research.microsoft.com/en-us/um/people/simonpj/papers...
Here's a newer book that covers similar subjects: "Implementing functional languages: a tutorial" http://research.microsoft.com/en-us/um/people/simonpj/papers...
This is incorrect. Looking at his list publications [1], a good deal of his publications are about programming language theory and a lot fewer are about practical implementations. Some of the theory papers are quite Haskell-centric (or use Haskell as an example language) but others are more general.
[1] http://research.microsoft.com/en-us/um/people/simonpj/papers...
See: http://www.infoq.com/interviews/simon-peyton-jones-about-mai...
http://research.microsoft.com/en-us/um/people/simonpj/papers...
A public vault of this articles so we can all learn easily instead of having to go through journal publishers.
EDIT: Why thank you, Lazyweb!
C. A. R. Hoare. An axiomatic basis for computer programming.
http://sunnyday.mit.edu/16.355/Hoare-CACM-69.pdf
Peter J. Landin. The next 700 programming languages.
http://www.cs.cmu.edu/~crary/819-f09/Landin66.pdf
Robin Milner. A theory of type polymorphism in programming.
http://courses.engr.illinois.edu/cs421/sp2012/project/milner...
Gordon Plotkin. Call-by-name, call-by-value, and the λ-calculus.
http://homepages.inf.ed.ac.uk/gdp/publications/cbn_cbv_lambd...
John C. Reynolds. Towards a theory of type structure.
C. A. R. Hoare. An axiomatic basis for computer programming: http://sigpl.or.kr/school/2005w/slides/2_17_1.pdf
Peter J. Landin. The next 700 programming languages: http://www.thecorememory.com/Next_700.pdf
Robin Milner. A theory of type polymorphism in programming: http://courses.engr.illinois.edu/cs421/sp2012/project/milner...
Gordon Plotkin. Call-by-name, call-by-value, and the λ-calculus : http://www.sciencedirect.com/science/article/pii/03043975759... (PDF link at upper right of page)
John C. Reynolds. Towards a theory of type structure: http://repository.cmu.edu/cgi/viewcontent.cgi?article=2289&c...
Pretty great works:
Luca Cardelli. A semantics of multiple inheritance: http://lucacardelli.name/Papers/Inheritance.pdf
Luis Damas and Robin Milner. Principal type schemes for functional programs: http://web.cs.wpi.edu/~cs4536/c12/milner-damas_principal_typ...
Edsger W. Dijkstra. Recursive programming: http://oai.cwi.nl/oai/asset/9253/9253A.pdf
Edsger W. Dijkstra. Go to statement considered harmful: http://www.massey.ac.nz/~kahawick/159331/Goto-Harmful-Dijkst...
William A. Howard. The formulas-as-types notion of construction: http://www.cs.cmu.edu/~crary/819-f09/Howard80.pdf
Robert Kowalski. Predicate logic as programming language: http://65.99.230.10:81/collect/computer/index/assoc/HASH0183...
Peter J. Landin. The mechanical evaluation of expressions: http://ropas.snu.ac.kr/lib/dock/La1964.pdf
John McCarthy. Recursive functions of symbolic expressions and their computation by machine: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.111...
Eugenio Moggi. Computational lambda-calculus and monads: http://pdf.aminer.org/000/267/711/lazy_lambda_calculus_theor...
Greg Morrisett, David Walker, Karl Crary, and Neal Glew. From System-F to typed assembly language: http://staff.ustc.edu.cn/~xyfeng/reading/p527-morrisett.pdf
George C. Necula. Proof-carrying code: http://www.utdallas.edu/~kxh060100/Papers/necula96.pdf
Gordon D. Plotkin. LCF considered as a programming language: http://www.sciencedirect.com/science/article/pii/03043975779...
Gordon D. Plotkin. A structural approach to operational semantics: https://www.alice.virginia.edu/~weimer/2006-655/reading/plot...
Guy Lewis Steele Jr. RABBIT: A compiler for SCHEME ftp://publications.ai.mit.edu/ai-publications/pdf/AITR-474.pdf
OK, I think the first two sections are plenty. You can search for the rest yourself on Google Scholar (I found most of these as the first hit on Google Scholar, one or two took looking through a few hits or doing a Google search as well)
'Conventional programming languages are growing ever more enormous, but not stronger. Inherent defects at the most basic level cause them to be both fat and weak: their primitive word-at-a-time style of programming inherited from their common ancestor—the von Neumann computer, their close coupling of semantics to state transitions, their division of programming into a world of expressions and a world of statements, their inability to effectively use powerful combining forms for building new programs from existing ones, and their lack of useful mathematical properties for reasoning about programs.'
Thankfully, 30+ years later these problems are widely fixed ;)
http://www.thocp.net/biographies/papers/backus_turingaward_l...
The majority of the ones in the first two sections were written before I was born; only three were written in the 1990's.
The only one from the 21st century (published in 2000) is in the least-prestigious third section.
Does it take time for good ideas to accumulate the recognition needed to be included in this list? Or was all the low-hanging fruit quickly picked in the early days of the computer age, and only hard problems remain on which little progress has been made?
Haven't any new ideas been introduced by the innovations of modern languages like Python, Lisp, Haskell and Ruby? Or even C++, Java and JavaScript?
Or is language implementation, almost without exception, a series of engineering refinements that happen in a decades-long process after theoretical foundations are first published?
Yes, most of the ground breaking theories were researched and documented decades ago. And some of that stuff has yet to make itself to mainstream programming languages (e.g. type inference).
> Haven't any new ideas been introduced by the innovations of modern languages like Python, Lisp, Haskell and Ruby? Or even C++, Java and JavaScript?
Apart from Lisp and Haskell, the "modern" languages you mention are rather boring when it comes to programming language design and there isn't too much research behind them. There has been a lot of practical work and research in garbage collection, run time systems, compiler back ends, just in time compilation and virtual machines. But when it comes to language design, the mainstream programming languages are really conservative.
A language like JavaScript might be interesting because it is simple and ubiquitous and embedded in a powerful application platform - but that does not mean it is of much interest from a theoretical CS perspective.
JavaScript theoretically uninteresting? Are you kidding?
What about its unusual prototypical inheritance? JSON-style literals? Its notation for anonymous functions? The approach modern JS frameworks take to single-threaded asynchronous execution?
IMHO, JS is not the best language for getting work done [1], but it has lots of innovations which are worthy of study.
[1] If you need to do Web frontend stuff, obviously JavaScript is the only game in town, unless you're into Flash, Java applets, or compilers with JS backends.
Notation is for the most part boring. The way you write function literals has no effect on the semantics of the language.
The prototype inheritance is also boring, the small step semantics being two inference rules[1].
JSON-style literals are what. A way of writing a POD. Who cares. It is boring.
Asynchronous execution is also boring. It was novel in the 1960s, it is not novel now.
[1] - http://www.doc.ic.ac.uk/research/technicalreports/2008/DTR08...
Unless, of course, when your work involves using the notation a lot.... then people get really picky about it.
In reality, notation is in the eye of the beholder. Some people like brackets and braces to split up the flow, where as some prefer whitespace as delimiters. There are papers out there on this (which I can't find right now).
> unusual prototypical inheritance
It was the language Self (as far as I know) that introduced prototype based programming. The initial definition of Self happened in the mid-80s if I remember right and there were a ton of papers formalizing various aspects of the language including theories for prototype inheritance.
Bib for Self: http://selflanguage.org/documentation/published/index.html
> notation
Must say that I don't consider notation as theoretically interesting. It is practically interesting obviously. (And things like anonymous functions have existed since Lisp)
> single-threaded asynchronous execution
There is an incredible amount of research in concurrency models. It is a little hard to point to a single source; but the theories of CSP and the actor model have been around for a long time and it has been incorporated in to various languages in more or less the Node JS style.
Don't get me wrong. Javascript has many interesting things to it practically. But the theory has been around for a long time.
Of course, the measure for academics is "can I get something published on the topic somewhere respectable" - it (mostly) doesn't have much to do with whether something is cool or useful.
Those modern languages are all older than 2000. Some of the papers cited in this list are indeed related to Haskell, Lisp (do you really consider lisp modern?). And Compiling works that will have a lasting impact needs some time to reflect on the importance of new works.
This list is essentially centered on logic in programming languages (lambda calculus, types theory, semantics, monads), hence the absence of python, ruby, javascript: those languages picked a lot from this theory but did not bring much novel material.
http://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=213...
I found that pretty interesting and it caused a lot of discussion.
I know when I was writing my thesis I was pretty disgusted that he ruined it for all of us mere mortals. ;)
"A Symbolic Analysis of Relay and Switching Circuits", 1938, proves that you can use electrical switches to do boolean algebra! He basically invented the digital computer, as a master's thesis.
http://james-iry.blogspot.com/2009/05/brief-incomplete-and-m...
It's a masterpiece!
[1] http://web.eecs.umich.edu/~bchandra/courses/papers/Igarashi_...
My second remark is that our intellectual powers are rather geared to master static
relations and that our powers to visualize processes evolving in time are relatively
poorly developed. For that reason we should do (as wise programmers aware of our
limitations) our utmost to shorten the conceptual gap between the static program and
the dynamic process, to make the correspondence between the program (spread out in
text space) and the process (spread out in time) as trivial as possible.
From Dijkstra's "Go To Statement Considered Harmful"It is in the top 5 and yet none of the go developers will acknowledge that it exists.