Lambda the Ultimate

It is a strange feeling after years of thinking programming languages were something the gods handed down to some mortal on a hill.

My initial languages were Basic, Logo Writer, Visual Basic, C++, Pascal, and Java. I can say for certain that I've never been under the impression that programming languages were handed down by 'gods'. Except maybe to curse us. Perhaps if my first languages were ML, Prolog, Lisp, and Smalltalk, I'd feel differently.

I'm not sure what will be next for me and programming language hobby time. Anyone else have similar experience wondering what to do with newly acquired abilities?

There are many paths before you...

Down the discovery path, you can learn, play with, implement parts of other languages and designs. Logic programming, functional reactive programming, rules based programming, constraint programming, learning systems, cellular automata, esoteric languages like Snusp or SKI calculus, software transactional memory, concurrency, distribution, capability model security, etc. You'll probably never finish a language on this path, but you'll learn a lot.

Down the implementation path, you can learn about optimizations, compacting vs. generational mark and sweep garbage collection, just-in-time compilation, integration with virtual memory and persistence, parallelization, resource management, networking. You'll learn about transparent 'intrinsic' functions and other hidden optimizations (e.g. perhaps replacing 'lists' transparently with 'ropes' under the hood will speed things up? it might be worth trying...). You'll learn about automated code transforms, i.e. to CPS or SSA. You'll learn about threads and fibers, about cache thrashing and affinity, about allocator designs to support multi-threading without hindering GC. You'll struggle with portability vs. performance concerns. You'll struggle to make a bignum library that works well with your allocator and GC. It can be exciting to set some high goals for an implementation then work to make them come together. A lot of people with an interest in programming languages lack the inspiration or motivation to come up with a new language, but do help others implement their visions.

Down the design path, you find yourself irritated with something the languages you've used have been doing poorly, or recognize that programmer tools are insufficient for some grander plan you have, and you start banging your head pounding out pages of brainstorm (mostly drivel) coming up with a good way to solve the problem. If you're smart, you try APIs and frameworks before resorting to a new language. It helps if you've worked on discovery for a while.

The problems I'm tackling for my own design are: weak code distribution, resulting in poor locality of code to resource; data-binding and latency issues between update of a data resource and seeing said update; cache coherence for large, structured calculations after an update to a sub-expression; disruption tolerance - in particular, the need to explicitly identify and recover from disruption that gets scattered throughout code; resumable exception (Lisp and Smalltalk seem like the only languages supporting it); dangerous concurrency rife with race-conditions (not even actors model helps); persistence, and the challenge of achieving persistence in a manner suitable for distributed cross-platform computation; DLL hell and fragile coupling between versions of libraries and plugins; gathering of data scattered across code or remote resources; security against both accident and malice, and effective management thereof; and serialization for IPC (esp. with encryption).

There is plenty more out there to target. Other people focus on languages that can, for example, compile for the GPU. There are languages designed for artistic endeavors, like PovRAY and Inform 7. There are languages to describe missions and military concerns (stealth, surprise, compromise, etc.).

So, if you're interested in programming languages - if you get a 'thrill' out of implementing bits of Scheme and understanding the language design - there's plenty of things to do, plenty more language designs to grok, plenty more implementation details to understand in context, plenty more challenges awaiting both design and implementation.

I've followed each of the above paths quite deeply in pursuit of my own 'grand vision' which (in my happy, perhaps delusional mind) will achieve something far more interactive, open, and secure than the current Internet. My initial pursuit of programming languages began only upon realizing I couldn't achieve it just through programming in existing languages, so I've never been at a loss for what I want to do with the skills I gain by perusing sites like this one.

It seems to me you ark asking about the kinds of jobs language lovers can enjoy and profit from?

dmbarbour and Ehud Lamm,

Both of your replies are perfect and each seems such an appropriate length. :-)

Programming language work is so interesting that it could consume all my time. There are so many things to investigate and implement. If something is going to take so much time then perhaps I'd want it to be a job so I don't end up with two jobs: the one for pay and the one for play.

Interesting replies. Thanks for both.

The highest concentration of PL PhDs/luminaries is probably in the Google cafeteria at lunch time. Turns out PL folks make the best high-end programmers, who would have thought!?

Learning PL will develop yourself as a programmer, and you could move into higher-end code work if you want. Its not all about PL implementation, its about thinking about problems in different ways, and designing the best abstractions.

Most commercially successful programming languages come from someone who does some other systems programming task, but knows a bit about language design and implementation, and then makes a language that makes their previous job easier. Examples: C, Perl, Python, Lisp, Emacs Lisp, Erlang, etc.

-t

People often think about designing the next mainstream language, or working on a C++ compiler, but I guess most PL work is done on in-house languages and DSLs that are either part of a larger product or used in-house and are entirely unknown to outsiders. I try to mention both kinds of projects from time to time, so people not forget that these offer good opportunities for language implementation and design work.

To me, the most fun part of language design is matching your application(s) of interest to the PL. If you don't have an app in mind, it's hard to come up with a good language; that could explain your feeling of "what next."