What 3-4 languages provide the best variety in style? [closed]

Question

I'm looking to broaden my development repertoire. Simply, if you had to pick 3-4 languages to learn that offered the most diverse variety in styles and thought processes, what would those languages be?

Answer 1

This is a very tough call, but I would pick:

a) Haskell : Functional, Strongly Typed, Lazy Evaluation - opens your mind to a lot of things other languages do not.

b) Python : An amazing object oriented, scripting language. Easy to "Get things done". Has now become my language of choice for anything that does not require super speed.

c) C: Teaches one to think close to the machine. Word align your structs, handle your own function pointers, pass around (void *)'s in your generic libraries, and know what writing platform portable code is all about.

d) Lisp: Learn to write code that writes code. Make use of its powerful macro system. Also, learn to program into your problem.

The close miss here would be JavaScript. Very dynamic, very functional, very useful, but knowing these four should make learning JavaScript easy - C syntax, Python like coding style, Lisp like lambda-functions-everywhere.

I really don't think any of the others (save, maybe Ruby) are even worth knowing, except when you are forced to program in that language. C++ C#, and Java, are almost C, with an object oriented paradigm - learning Python well should teach you this.

Prolog is of course very different. But I think knowing Lisp and Haskell should enable you to write your own logic and data driven programs.

P.S. These are the four languages I know and use on a regular basis too. I learnt them (learning them) in the order c), b), a), and d).

Answer 2

Haskell / C++ / LISP / Perl

... may Gawd help you with this one ...

Answer 3

Some really good answers so far. I'd highly recommend checking out the book "Seven Languages in Seven Weeks" by Bruce Tate from Pragmatic Programmers. He goes through 7 different languages (Ruby, Io, Prolog, Clojure, Erlang, Haskell and Scala). I've been working through it myself and it gives a great intro to each language and gives you a chance to explore different programming paradigms between OO, Prototype, Declarative, Functional and a couple hybrids.

Answer 4

A hard call, but my personal selection would be:

1. Functional: Haskell
2. OOP: Java
3. Script: Perl
4. Logic: Prolog

The choices within the categories are because they offer the most distinctive experience of the styles given within their class. Not because they are best in their class, just furthest in to them for experience purposes.

I would also recommend a Lisp/Scheme, and an assembler of some sorts.

Answer 5

1. C: because that's how machines work.
2. Python (or maybe Ruby, or even Perl): dynamic scripting languages, immensely practical.
3. JavaScript: how a great design can be atrociously implemented and still succeed.
4. LISP or Lua: unmatched elegance, rediscover the joy of creating things of beauty.

hum... I've left out any static, class-based, OOP like Java, C++ or C#... It's an important category; but I'd gladly trade it for any of the mentioned. Well, not exactly, I really hate JavaScript and really like C++; but the hard lessons of the mistakes in the history of JS are really valuable.

Answer 6

Erlang (or Lisp)
Python (JavaScript or ActionScript (prototypal inheritance)
C (or assembly)
Objective C

Answer 7

I would choose Assembly Language, Haskell and Prolog for the reasons already stated and add Eiffel (great OO language) and SQL (if that counts as a programming language).

Answer 8

I will go reading this book: Seven Languages in Seven Weeks, and then I will see which 3 or 4 languages from those I want to learn better :).

Answer 9

This is a problem, but I'm going to jump on the OP's comment about broadening experience, and assume that the OP is familiar with mainstream-style programming languages already (with C-style syntax and OO). Also, I'm only going to include languages I've been exposed to (which leaves out the excellent concurrent language suggestions).

Common Lisp is a surprisingly useful language. The fact that programs are written in parse-tree format allows a great deal of flexibility. Make sure you learn to use macros, which are nothing like C-style macros.

Haskell is good for pure functionality and a strict type system.

Prolog is a decent language, and a different paradigm. (Personally, I don't like it, but I certainly didn't waste the time I spent learning it.)

Forth is an unusual programming language, fun to play with and instructive in how a language can be built.

There are other languages I'd like to list, had I room and experience with them. Smalltalk and Erlang sound like excellent choices, but I've never done anything with either of them. Tcl is unusual, although I hated the way it made my brain feel. Assembler is good for giving a feel as to what a computer is really doing, although I hate x86 for its layered-on complexity and would prefer to use another processor, if only in simulation (the ones I've used were IBM 370, Control Data 6x00 and follow-ons, Z80, Knuth's MIX, 6809, and a little 68000).

Answer 10

Here's my take, drawn from experience of things that have progressively 'stretched' (if not blown) my mind.

• Assembly - close to the metal
• SQL - so totally not like anything else I'd used
• F# - or anything functional. Again, a paradigm shift
• C++/Java/C# - anything in the OOP field. I'd give this one less importance only because it's what most developers already have some experience in anyway.
• Something 'webby' - this isn't so much about language, but getting your head round 'what happens on the server and what happens on the client'.
• I'd quite like to try Erlang, as it seems like yet another way of thinking your code.

That's not 3-4, sorry :)

Answer 11

• Assembly Language - makes it easy to reason about computer architecture.
• C - Low level language that gives you much control of memory and hardware. A good fit for writing a Operating System.
• Java - Object oriented language that runs on multiple platforms without recompilations.
• Erlang - Concurrent language where you can create millions of "processes" on your machine, and easyli scale out to a hole cluster. Do concurrent without threads and shared memory - with asynchronous message passing. See Erlang - software for a concurrent world
• F# - Functional programming in a static typed language with type inference.

Answer 12

I'd vote for:

• A OO "C family" language - one of C++, C# or Java. If you can read one of these you can pick up just about any book on software development and follow the sample code.
• A common web scripting language - i.e. Javascript, because this is so common you can hardly avoid it.
• A "trendy" dynamicly typed language, maybe Python (Google use it a lot if that makes any difference). Not because they are trendy but because dynamic typing is very different to the alternative.
• A functional language - F# if you are a .Net person or Haskell if not. Functional programming is not just a fresh way of writing code but I think it can help in the "day job" (especially if your day job is C#).

Answer 13

1. Learn two assemblers: one CISC (e.g. x86) and one RISC (e.g. MIPS). Rationale: you will truly understand what's going on under the covers of your machine just shy of having to know voltage levels.

2. Learn a "systems language" -- a no-frills procedural language like C or Modula-2 or the like. Rationale: Here you'll be able to make more useful software while still being aware of some of the issues of underlying hardware.

3. Learn an object-oriented language: one of Smalltalk (pure OOP, dynamic), Java (semi-pure OOP, static) or Eiffel (pure OOP, static). Rationale: OOP is the Kool-Aid of choice in modern computing so you might as well drink some off the start.

4. Learn a functional language: one of Haskell, one of the MLs (F# counts) or Erlang. Haskell is the purest functional and is also very statically typed. The MLs are not quite as pure but still pretty damned pure and are also very statically typed. Erlang is nowhere near as pure, but it is pure enough to grok the concepts and it has the added benefit of teaching you a radically different way from the usual of thinking about concurrency. Rationale: I think functional is turning into the next Kool-Aid of choice as OOP's flaws become more and more apparent. Drink it now to be hip and trendy.

5. Learn a logic language, most typically Prolog. Rationale: Logic programming will radically change the way you see what programming even is. It never hurts to think in new ways about old problems.

That's five languages, unfortunately, so I've broken your 3-4 level without even having touched on learning a Lisp or a Forth to get extreme flexibility, homoiconity, etc. from two radically different directions (extreme high-level and extreme low-level respectively). You may want to boost your number a bit there. ;)

Answer 14

If forced to limit myself to four, I'd go for:

• Assembler: because it is really useful to know what all code ultimately gets translated into and it helps you understand the machine much better. Also, it's a classic example of an imperative language.
• Java - Java gets a lot of abuse - some of it fair, most of it unwarranted. But it should be on the list because it's the classic, statically typed, garbage-collected object-oriented language. Also its very significant commercially so great to have on your resume / CV. C# would also be a similar option here, but I prefer the portable Java/Open Source mentality to the Microsoft closed shop.
• Prolog - because logic programming is significantly different from other paradigms, and it's therefore a great way to broaden your horizons.
• Clojure - IMO the best modern Lisp, it's an extremely powerful and productive dynamic language that provides excellent support for functional programming and concurrency in particular. Also everyone should get a taste of Lisp-style macro meta-programming at some point, if only to marvel at the wonder of writing programs that write programs that write programs that...

Other options that would be very close to making the top 4 list:

• Haskell - notable for its exceptionally pure functional approach (would be in my top 4 if not for Clojure, which I think is a somewhat more pragmatic functional language)
• Javascript - actually a very nice language with a lot of nifty features - will teach you a lot about dynamic, prototype-based object orientated systems
• C++ - because it's a "system level" language for writing robust, high performance code close to the metal while still enjoying some powerful abstractions.

Answer 15

Smalltalk: true object oriented.
Haskell: pure functional language.
Lisp: create what ever you want.
Prolog: Logic programming.
I would like to add: Io language.

Answer 16

C - pretty assembly

LISP - lambdas, recursion

Ruby - scripting, metaprogramming

Haskell - mathematics