You would do well to pick up different kinds of languages so you can learn their important ideas. Broadly speaking, most of the "common" languages out there hail from the Algol or Simula camps (C, Pascal, Modula 3, Ada, C++, Smalltalk, Perl, C++, Java, ...).

There's also the Lisp family (I'd probably look at Scheme or Common Lisp (which includes CLOS, with its nice support for OO)).

And then there's the functional languages (Prolog, ML, Haskell) that will provide a totally different way of looking at things.

You might also look at assembly language for a couple of processors (do something with a little microcontroller for kicks), and at Postscript, which is interesting from a language point of view (kind of like FORTH with some data types). And maybe APL or J for another completely different view of languages.

This chart diagrams the history of computer languages and has some links to other such charts.

update: clarified CLOS

I like the assembly suggestion, but it's a bit too much like work. At the moment I'm writing code for a Texas Instruments VLIW DSP. Most of it's in C but you have to be able to understand the assembly when the compiler screws up (as it often does). VLIW assembly code is a bit of a brain-melting experience.

On the other hand I can highly recommend microcontroller assembly as a fun way of learning about the opposite of high-level languages. PICs, with their 30-odd instructions, are the ones I've played with.

Lisp scares me, which probably makes it a good choice to learn next. I might even eventually be able to configure emacs!

--
Kevin O'Rourke

...Common Lisp (and CLOS (its object extensions))

Just nitpicking, but it's a little bit misleading to refer to CLOS as an "extension" to CL; after all, it's part of the standard (and one of the primary reasons that people use CL, too).

*sighs*

A given language's syntax is, well, just that - syntax. I learned how to program in Pascal. I have never written a line of Pascal since I finished CS210 at the end of my freshman year in college. In fact, I can count on one hand I've seen Pascal code since then, and that was 7 years ago.

However, I learned proper programming style, and that was much more important. Since then, I've learned 3 languages to competency on my own, each in less than a month, and have been able to edit in at least 2 others. I'm not trying to boast here (especially cause that's really not that impressive - too many other monks would beat me out without trying! *grins*) The conclusion I've come to is that a given language is just syntax - it's a toolbox. Nothing more. What's important is that you use a screwdriver as a screwdriver and not an awl. (Though, in a pinch ...)

If I were you, worried about your skill level (for whatever reason), I'd start working on crazy problems. Do a bunch of obfuscations or play GOLF. Take a project you've worked on and bloat with with a ton of feature creep. Or, get out of the procedural languages and go learn a functional one. LISP is touted by a number of monks. Or, go do some sysadmin work. I built a Linux box this weekend, in large part so I could expand not my coding skills, but my understanding of how programs are used. What makes a device driver? What makes a kernel? Why was it built that way? I can then use what I discover there to aid other programs I write.

<disclaimer>Now, while I feel that Pascal is a wonderful teaching language, seeing as it was designed as such, I'm not saying that only people who learned to program in Pascal are good programmers, nor am I saying that learning in Pascal will make you a good programmer.</disclaimer>

Lisp        You can learn this over time.  Just grab 
            a copy of emacs and hack your own commands
            as you need them.  Plenty of code comes with
            it.

Snobol/     The Perl of the 60s, as far as pattern
Spitbol     matching goes.  My grad advisor, Ralph
            Griswold came up with this.  I seem to
            remember Spitbol had a construct of
            "compiling" code at runtime similar to
            Perl's "eval".

Icon        Another Griswold invention of the late 70s
            early 80s.  Check out generators (similar
            to closures).  It had backtracking, but 
            not just when matching patterns.

The usual suspects include Python, Ruby and java.

If you want to learn languages with a different feel than than Perl you can try Lisp or Prolog, XSLT could be interesting too.

Taking that to more of an extreme, check out Intercal, a language whose whole charter is to do things differently than any other language. It was supposed to be a joke, but why do the concepts seem to be less than funny today? The way conditional execution is performed by turning off specific lines, rather than jumping over them, sounds a lot like Intel's new 64-bit chip. The way you can disable specific commands sounds a lot like "sandbox" security environments as seen both in Perl and Java. It goes on and on.

Read it and get a good laugh. But read deeper and see that the way we do things is really a very narrow, even provincial, viewpoint.

—John

LISP or Scheme, I'd say. If you really want to learn something, work through Structure and Interpretation of Computer Programs.

Christian Lemburg
Brainbench MVP for Perl
http://www.brainbench.com

C/C++: Either one, really. C++ is powerful, and its ability to make ADTs is useful; coming from perl, it should be relatively simple to learn the basics--though beyond that you're on your own(or so I figure; the other way around, C/C++ -> perl wasn't too difficult).

Assembly: Not only can this be used in C/C++ directly, via _asm(or __asm), i.e., the inline assembler, but it offers a *great* glimpse at the inner workings of the computer--not to mention that it is FAST. Even if you don't plan to program in assembly, learning it can help you write better code(boolean algebra, etc., check this site out for basics: http://webster.cs.ucr.edu/Page_asm/ ArtofAssembly/ArtofAsm.html

Befunge. It even has a cpan module.

Or just about anything on the retina-shredding Cat's Eye Language Lab.

-- Frag.

It is rather good for commercial stuff and has database access built in.

I'm currently studying a range of different types of languages:

1. LISP (bigloo)
2. Ada (gnat - available on Linux and, I think, Win32)
   IMHO, a C/C++ equivalent both in terms of what it can do and in how much you have to know to use it well. But, IMNSHO, much better than C/C++ because of its international standardization and strong type checking, among other things.
3. Ocaml
   A derivative of ML (which someone else mentioned).
4. Mathematica
   

It also provides a nice contrast to Perl since it is statically and strongly typed.

Go buy a spectrum and do some Z80 assembly.