Lambda the Ultimate

I am a graduate student in mechanical engineering at Stanford University. Due to some years of experience writing computational fluid dynamics codes, and a fair bit of self-teaching to bridge the gap between a lack of formal programming instruction and a need to write (relatively) large maintainable codes for my research, I have become interested in computer science as an intellectual pursuit.

Much of my interests can probably be summed up in the observation that my two great language loves are Fortran and TeX, and that I have a crazy notion of writing a language which is a hybrid of their best parts.

My programming needs are often quite different from those that are taken for granted in most discussions of practical programming, and so I've become interested in languages that make "different" assumptions in general. In particular, I am interested in things that involve crunching of vast numerical arrays such as those found in fluid-dynamics simulations.

I like TeX because its blurring of lines between "program" and "data" is refreshing, as it makes it easy to write self-modifying code and code that generates other code, and also reduces the problem of I/O to a pleasant triviality.

I like Fortran because it is at what is (for me) an optimum point between a language that is evolving rather than remaining stagnant, and yet is established enough to have reliable commercial compilers that produce optimized code as fast as that written in any other language. (There is some considerable truth to the claim that, in a hundred years, the programming language of choice in numerical applications will look nothing like today's programs, and it will be called "Fortran".)

I am also interested in programming-language concepts that are applicable to the process of writing efficient parallel code for large-array number crunching, where breaking the problem up into process-sized problems is often an unnatural perspective.