What are important languages to learn to understand different approaches and concepts?
Question: When all you have is a pair of bolt cutters and a bottle of vodka, everything
looks like the lock on the door of Wolf Blitzer's boathouse. (Replace that
with a hammer and a nail if you don't read xkcd)

I currently program Clojure, Python, Java and PHP, so I am familiar with the C
and LISP syntax as well as the whitespace thing. I know imperative,
functional, immutable, OOP and a couple type systems and other things. Now I
want more!

What are languages that take a different approach and would be useful for
either practical tool choosing or theoretical understanding?

I don't feel like learning another functional language(Haskell) or another
imperative OOP language(Ruby), nor do I want to practice impractical fun
languages like Brainfuck.

One very interesting thing I found myself are monoiconic stack based languages
like Factor.

Only when I feel I understand most concepts and have answers to all my
questions, I want to start thinking about my own toy language to contain all
my personal preferences.


Answer: Matters of practicality are highly subjective, so I will simply say that
learning different language paradigms will only serve to make you a better
programmer. What is more practical than that?

_Functional, Haskell_ \- I know you said that you didn't want to, but you
should really really reconsider. You've gotten some functional exposure with
Clojure and even Python, but you've not experienced it to its fullest without
Haskell. If you're really against Haskell then good compromises are either ML
or OCaml.

_Declarative, Datalog_ \- Many people would recommend Prolog in this slot, but
I think Datalog is a cleaner example of a declarative language.

_Array, J_ \- I've only just discovered J, but I find it to be a stunning
language. It will twist your mind into a pretzel. You will thank J for that.

_Stack, Factor/Forth_ \- Factor is very powerful and I plan to dig into it
ASAP. Forth is the grand-daddy of the Stack languages, and as an added bonus
it's [simple to implement](http://github.com/fogus/rforth) yourself. There is
something to be said about learning through implementation.

_Dataflow, Oz_ \- I think the influence of Oz is on the upswing and will only
continue to grow in the future.

_Prototype-based, JavaScript / Io / Self_ \- Self is the grand-daddy and
highly influential on every prototype-based language. This is not the same as
class-based OOP and shouldn't be treated as such. Many people come to a
prototype language and create an ad-hoc class system, but if your goal is to
expand your mind, then I think that is a mistake. Use the language to its full
capacity. Read [Organizing Programs without
Classes](http://labs.oracle.com/self/papers/organizing-programs.html) for
ideas.

_Expert System, CLIPS_ \- I always recommend this. If you know Prolog then you
will likely have the upper-hand in getting up to speed, but it's a very
different language.

_Frink_ \- Frink is a general purpose language, but it's famous for its system
of unit conversions. I find this language to be very inspiring in its
unrelenting drive to be the best at what it does. Plus... it's really fun!

_Functional+Optional Types, Qi_ \- You say you've experience with some type
systems, but do you have experience with "skinnable* type systems? No one
has... but they should. Qi is like Lisp in many ways, but its type system will
blow your mind.

_Actors+Fault-tolerance, Erlang_ \- Erlang's process model gets a lot of the
buzz, but its fault-tolerance and hot-code-swapping mechanisms are game-
changing. You will not learn much about FP that you wouldn't learn with
Clojure, but its FT features will make you wonder why more languages can't
seem to get this right.

Enjoy!

