Designed originally at least in part as a way for children to use computers to learn. The syntax is simple enough to describe in a paragraph. It, like LOGO, exemplifies the "low barrier to entry, high ceiling" principle.
Smalltalk's a pure OO language in the sense that "everything is an object".
It also teaches many functional techniques, particularly in its Collection API: chaining messages, higher order functions, map, reduce, and so on.
The Squeak community is vibrant and welcoming. You'll also see many discussions of advanced techniques: much like the lisp community, there are many very experienced Smalltalkers on the mailing list willing to share their knowledge. (It doesn't hurt that the Squeak community has a large sub-population of professional educators.) There's also another list for beginners.
A logic programming language that will give you a very different view of computation to just about any other language. Prolog is also highly declarative (but not completely so: the
! or cut operator can have a significant semantic effect on a predicate).
3. Common Lisp
Substitute Scheme here if you like. Common Lisp is supports multiple paradigms, especially OO and functional. It also has a long history (Lisp is the second oldest still-widely-used language: only FORTRAN's older).
(Caveat: I've only just started learning it.) Probably the purest functional language on the planet. It has a very advanced static type system. Handy intro books exist.
5. C or Delphi
You need to know how computers work. You need to know how memory and CPU actually function. Both of these are traditionally "close to the metal" and have communities that encourage thinking of how their language compiles to assembly.
Why this order?
Smalltalk's very easy to learn, so you can quickly start concentrating on solving problems rather than fighting a compiler ("low barrier to entry"). Once you start programming, there's also no artificial limit on what you can do - "high ceiling".
Once you have a fair idea of how OO works (and - with the proviso that there are MANY different understandings of what "OO" means - it's fair to say that OO dominates the marketplace), moving onto Prolog ensures that you don't start thinking that OO is the only way. Prolog is very different to most languages, and will stretch your mental muscles so you don't start thinking that you know everything.
Common Lisp, in turn, is a grown-up's language. It has a mature standard, it has been leading language design for decades (along with Smalltalk) - all those fancy new features your favourite language just acquired? Chances are the ideas incubated in either Lisp or Smalltalk. Common Lisp's also a bit warty, and you'll find wartiness everywhere you go.
Haskell's fourth on the list because (I'm told: I've only just started learning it) its purity means that some very common things (like I/O) are more difficult to do than in less purely functional languages. The Haskell folks also use some fairly exotic terminologies (words like "catamorphism", say), and you'd probably be better off with some programming experience under your belt before tackling it. (But I must re-iterate, I've only just started learning it! Take this opinion with a pinch of salt!)
And why C/Delphi last? Because unless you work in embedded systems, you really shouldn't have to learn programming thinking that manual memory management's all there is. Garbage collection worked well enough for a 1980s level machine. Your phone is that powerful!
Finally, I haven't put Erlang in the above list even though I really should.