Programming languages I know

Joey seems to have inspired a "list of programming languages you know"-contest over on planet.debian.org, so this is mine:

1. Basic (forgotten)
   I've started using Basic on the Commodore C64 and have used it considerably, apart from the intrinsics of peek and poke, which some would claim was what Basic on the C64 was all about. I also used Basic on the Apple II at school, but was spared any further need to use Basic.
   
2. Cobol (forgotten)
   I remember my old computer science teacher bringing white and green prints on endless paper and teaching us the joys of Cobol. Having used Basic before, it looked somewhat suspicious but not too alien. Fortunately, we only had to solve some simple problems on paper, as the Apple II only had .... DBase II, I think.
   
3. Pascal (forgotten)
   (Turbo) Pascal was the language of choice in the first semester at the University of Koblenz at the start of the nineties. I've did what I had to do in it, but never really liked it. From the occasional look I throw in Wirth's algorithms book I know I can still read it, but the language looks just as baroque as the copy of the book I have.
   
4. Prolog (forgetting)
   I've really done a lot in Prolog, being first exposed in the second semester to it. I remember to marvel at some guys who grokked the language at first usage in the initial course -- to me, having used only imperative languages up to then, it was a mistery. I still think Richard A.O'Keefe's book "The Craft of Prolog" is among the best CS books.
   
5. C/C++ (forgetting)
   About 1992, I somehow got interested in object-oriented programming. Free software was still unknown to me, so I bought a student edition of Turbo C++ and some Addison-Wesley book and of I went inventing another wheel. At the time, I also had to do some C hacking for some course at the university, involving MS Windows programming. I've used C over time in several smaller projects, but would never call myself a C hacker.
   
6. Assembler (forgotten)
   My first exposure to Assembler was with some book for the C64. I was very interested but understood next to nothing. I should program some I/O chip directly instead of just using "load $,8,1"? WTF? Next look was in University, of course. I still know enough bits to be able to grok more or less the output of (disassemble 'foo) of some (tiny) foo-function in CL on an i386-style machine, but that's about it.
   
7. Mercury (had interest in)
   Mercury seemed like a nice successor to Prolog, adding several features of functional languages. I read several manuals, had several installations and never used it for anything.
   
8. Life (had interest in)
   Another possible successor to Prolog, which I've learned about at a summer school for language, logics and information. That's about all I remember.
   
9. XLisp (forgotten)
   My first exposure to Lisp in the context of a course for computational linguistics. The only thing worse than the editor used in the system was the tutor giving the course. A horror of parenthesis is about the only thing I remember.
   
10. Shell scripting (daily usage)
    I think since 1992 or 93 I've been using Unix systems and shell scripts. I no longer can remember whether our Suns dumped you into csh or sh or whatever, but since I've been using Linux systems (since 94), I've been using bash and written bourne shell scripts. Of course, I've also written the occasional csh script abdomination, but "Csh programming considered harmful" was an early lecture.
    
11. Emacs Lisp (forgetting)
    I remember seeing one of my instructors doing nearly miracles with XEmacs and wondering how his fingers could be that flexible -- I know that now. I've written several small utilities in Elisp and keep using it occasionally.
    
12. Common Lisp (improving)
    When I started a student job in 1995, I also started using Common Lisp, using Steele's CLtL2. Having used Elisp before, I no longer was worried about parenthesis. I still keep finding areas I didn't know or used before. And it's a language large enough that keeps you re-learning tricks you thought you knew. Which didn't stop me from giving a course on CL, which in hindsight didn't have the right focus: instead of showing that CL is just as capable of doing whatever you expect, it's also capable of doing you won't expect.
    
13. Smalltalk (interested)
    At the computational linguistics lab in Freiburg, the parser system was implemented in Smalltalk, so when I started there I took a small course in Smalltalk. As I worked more on the knowledge representation side of the system, I only rarely used it, though, so rare indeed, that I never got to do anything serious with the language. I still can read Smalltalk despite it's somewhat unusal syntax and have to do that even sometime.
    
14. Tcl (forgotten)
    We wanted to extend a linguistic annotation written in Tcl, so I bought a book and started digging through the code. Soon enough a student took over the job (and did it rather well), so I started the tiny bits I've learned quite soon. I remember finding the concept that every thing is a string to be rather messy and still see it as a lame excuse for dynamic/weak typing.
    
15. Perl (static)
    For nearly ten years, I had been using shell and/or Emacs to solve any data mangling tasks when I finally gave in and had a closer look at Perl. I still find it amazing how quick and dirty it's possible to solve problems in Perl, but on the other hand I've given up Perl for more complex tasks that require some thought and design, since Perl's syntax and language idiosyncrasies keep leading me to programs I don't even like myself.
    
16. XSLT (improving)
    At about the same time I started using Perl, I also needed to transform a set of XML documents and XSLT was all over the media, so I had a closer look. I dislike the noisy syntax of XSLT and particular the intermix with output elements and it's fever for being a "clean" functional language. But the concept of XPath and the idea of traversing a document via axis I find very compelling.
    
17. make (static)
    For a long time the power of make didn't occur to me. A colleague of mine, however, used it to implement a nifty workflow for document processing, of which I learned a lot of tricks when I needed to mimic it for a different task.
    
18. Ruby (improving)
    When I finally was fed up with Perl, I looked around to find Ruby as a nice halfway compromise between Common Lisp and Perl. It's still fancy and geeky and with Ruby on Rails has a lot of buisness ballyhoo around it, so I hope it will see more use in my current surrounding.
    
19. Java (not interested)
    Like everybody else, I couldn't avoid looking at Java. It seems to be the Cobol of today and as such is the job guarantee today. But Java looks so boring, I can hardly stand it. And this with regard to both the language and the results produced with it. Sigh But still, it's likely that someday I'll going to buy another book (that would be my third Java book, the first being O'Reilly's Java in a nutshell for Java 1.1 in maybe 1997 or so?), since just like Cobol at it's time, avoiding Java is hard ...
    
20. Python (not interested)
    When Python 1.4 hit the scene, there was quite some bubble around it. It burst quickly and as my latest review of the language reveiled last year, it still doesn't seem interesting.
    

Missing in this list is stuff like Scheme, Dylan, Oz, Oberon, Eiffel, Haskell and probably some other "tiny" languages which I looked at at some point in time and really didn't ever took a second look. Of those, I may take another look at Haskell in the future, but currently I have no concrete plans in doing so.