What I want from a programming language (by )

I'm interested in programming languages. When I was a kid, I'd get books on different languages out of the library, and sit and learn a language. I didn't get to write code in many of them, since this was before I owned a modem; all I had at home where BASIC, Z80 assembly language, Pascal, x86 assembler, then C and C++. But I devoured new languages whenever I could. When I came across FORTH I wrote my own implementation (although at the time I didn't get the metaprogramming stuff), since FORTH is easy to implement (it's a great bootstrapping language), and later on, I implemented a kind of Lisp as a scripting language for a game engine (except I used a Prolog-esque syntax, foo(bar,baz) rather than (foo bar baz)). I really wanted to play with the rich feature set of Ada, and the parallelism of occam. I studied COBOL and FORTRAN and found they didn't look much fun. I studied Smalltalk and found that it looked like great fun. Prolog was interesting, a radical departure, but I saw it as foolish to write whole programs in it - I felt it should be used as a database query language like SQL. It's Turing complete, but a large class of programs are ugly to write in it.

When I turned 15 I received a copy of Structure and Interpretation of Computer Programs for my birthday, which I read with glee and found out that functional programming was actually quite a simple idea. I found I liked Haskell's type classes, but I found that I particularly liked Concurrent Clean's uniqueness typing (much better than nasty monads). My now old friend Faré Rideau (who I must get back in touch with, actually...) indirectly led me to the writings of Henry Baker, who gives good cases for uniqueness-typed languages, with reference to FORTH and Lisp. And for the same birthday (it was a good one for books!), I also received a copy of the Dylan Reference Manual, where I learnt the wonders of generic functions and restartable exceptions.

Slowly, FORTH, Lisp (in particular, the Scheme dialect; I didn't have any information on Common Lisp, and Clean came to embody (in their own areas) ultimates in programming language design for me. For ARGON I began to migrate towards a model where something like FORTH would form a hardware abstraction layer and low-level non-typesafe programming language, while my own Lisp dialect formed a typesafe high-level language in which application code could be reasoned about for security rather than having to be trusted, as with Java. Metaprogramming, which I finally got the hang of around this point, seemed a logical way to have a simple compiler (that I had a hope in hell of implementing, and possible to keep immune from the Thompson hack) yet still have a powerful language that'd be a pleasure to code in. But there was still a lot of possibilities for the structure of the high level language.

Pages: 1 2 3

No Comments

No comments yet.

RSS feed for comments on this post.

Leave a comment

WordPress Themes

Creative Commons Attribution-NonCommercial-ShareAlike 2.0 UK: England & Wales
Creative Commons Attribution-NonCommercial-ShareAlike 2.0 UK: England & Wales