

Programming languages worth checking out - RiderOfGiraffes
http://www.h3rald.com/articles/10-programming-languages/

======
hassy
Learning a new language to improve your programming skills is a cliché. I
realized recently (and I'm into languages) that tinkering on a project in a
different domain is hundred times more educational and fun.

E.g. if you mostly do webapp backends, write a ray tracer in Javascript. If
you're a systems programmer, write a blog on AppEngine. Make a screensaver.
Make an iPhone app. Etc etc.

~~~
camccann
I think the advice to learn a new language is more incomplete than anything
else; it's not learning a new language that's valuable, it's learning new ways
to think about problems. Picking up a language that's very similar to one you
already use, or that differs only in matters of syntax, isn't really going to
do much for you, and it probably wouldn't take more than maybe six carefully-
selected languages to get 99% of the benefit learning new languages will ever
have.

Writing a program in a radically different domain than what you're used to has
a lot of the same value, plus the advantage of being a much less exhaustible
resource.

~~~
swannodette
"and it probably wouldn't take more than maybe six carefully-selected
languages to get 99% of the benefit learning new languages will ever have."

I don't know how you came up with these numbers- from what I've seen of the
variety language of programming languages out there this doesn't seem at all
supportable. Not unless you take a completely reductive sampling of the
various computer languages that have been developed thus far.

But yes, tackling different kinds of problems and different kinds of program
languages will certainly give you healthy and open-minded perspective about
programming.

~~~
dkersten
Lemme see, which six languages would I choose...

    
    
      * C++, Java, C# or some other imperative OO language
      * Scheme, Common Lisp, Clojure or some other lisp
      * Haskell, OCaml, Scala or F# (and maybe Erlang?)
      * Prolog or Mercury
      * LabVIEW, Luster/SCADE or some other dataflow language
      * Factor, Forth, Joy or Cat
    

This gets me imperative/OO, monitor based concurrency, Lisp-ness (homoiconic
language, real macros, DSLs), functional, strong static typing, type
inference, powerful type systems, logic programming, dataflow and
concatenative.

Yes, there are gaps - I'd also add Oz, Python/Ruby/Boo/Groovy and J into the
mix to get a more fully rounded paradigm tour and, even then, there are some
things missing, though at this point you should have a strong knowledge of
languages and paradigms and should be able to tackle most problems pretty well
- or at least, know enough to choose a good programming language for the task
at hand.

~~~
camccann
Hmm, after looking at your rather nice list, six was probably too low; I think
I'll revise my estimate to a more conservative eight. There'll always be
_some_ gap, of course, but eight ought to get closer to the point of
diminishing returns I had in mind.

Incidentally, I'd probably include some form of assembly as well, for the
whole "must understand the underlying hardware" aspect.

~~~
dkersten
Ohhh! That was certainly an oversight on my part - an assembly language should
be included.

Eight should be enough, after that, you probably wouldn't learn enough to make
the effort worthwhile (except maybe to learn a language for a particular need,
eg available libraries). I think my number seven then would be an assembly
language and my eight would be Oz, ATS[1] and J[2] (not really in the same
category, but more of a misc interesting languages category). I would then add
Python/Ruby/Boo/Groovy in with C++, C# and Java.

ATS and J are both unique in their own ways. I'm not sure what value there is
in learning either of these (since I don't know them) but they _seem_
different enough to teach you something new. J (or APL or K) do teach you
about array processing languages and point-free programming, so maybe this is
useful. ATS is interesting because of its emphasis on types in a way I haven't
seen in other languages:

[1] <http://www.ats-lang.org/>

[2] <http://www.jsoftware.com/>

PS: Turns out I spelled Lustre wrong :-D

~~~
camccann
I'd actually be inclined to get C++/C#/Java off the list entirely due to not
showcasing any one perspective particularly well, to be honest. Smalltalk or
Ruby would better illustrate OOP, and between them the OOP language and the
assembly should cover the basic procedural approach well enough, I think.
Also, plain old C could possibly stand in for the assembly, especially if you
were mostly using it "portable assembly" style instead of relying mostly on
libraries.

For what it's worth the list I had mind originally was something like:

    
    
       * C, for low-level procedural and machine-awareness
       * Ruby, for high-level procedural and OOP (plus scripty perl-isms)
       * Scheme, for distilled lisp-iness without distracting details
       * Haskell, for HM static typing and functional purity
       * Two empty slots to cover languages I'm less familiar with
    

After seeing your list, I realized I'd carelessly underestimated the number of
empty slots necessary...

------
mahmud
Bypass the whole lot and "learn" Mozart/Oz. The most elegant kitchen-sink of
programming paradigms. It's so good nothing useful has ever been written in
it. It's the subject of the second greatest text on computer programming.

Mozart/Oz, it's like programming the way the classic Vienna Musician would
have written Music, if he moved to Bondi Sydney and picked up surfing and
wild-growing marijuana.

~~~
dkersten
Mozart/Oz is, indeed, a very interesting and powerful language and certainly
one of the more complete multiparadigm languages. After reading Peter Van Roys
CTM, I told myself that I would learn and use Oz, but... it never happened.

------
dkersten
" _Factor is to Forth what Clojure is to Common Lisp_ "

I disagree. Its well known in the Factor community that, as one of the core
Factor devs stated, _idiomatic Factor doesn't use the stack; its only
superficially related to Forth in that it uses similar syntax, but it has much
more in common with lisp_.

Sure, Factor is stack based - like Forth - but Factor provides a lot of
abstractions on top of this (many of which are inspired by lisp), which Forth
does not, like macros, combinators (which help avoid manually dealing with the
stack), local variables, lisp-style lists, concurrency, generics, object
oriented programming, even infix expressions (though the use of a macro)...
and a ton more.

------
xtho
I find the list slightly disappointing. Those languages are listed in almost
every other list of that kind. Checking out new entries in the language
shootout is more informative.

------
azgolfer
He missed NewSpeak, IMO the most interesting new language

<http://newspeaklanguage.org/>

------
_dexodro
Has Io been useful in any application yet? Admittedly, I find it an
interesting language, and my experience with it has been kind of fun - but I
can't think of anything it does that most other programming languages don't do
better.

~~~
rgrinberg
"but I can't think of anything it does that most other programming languages
don't do better."

What do you mean by that? Io is slow and does not have the extensive libraries
that are present in other languages. However, as a pure prototype oo language,
it is second to none.

Read here: <http://c2.com/cgi/wiki?IoLanguage>

------
viraptor
If that list is not enough, be sure to check out <http://ooc-lang.org/> too.
Even though it's quite young now, it's exactly what I'd want C++ to be :)

------
malkia
I came to appreciate exception handling, after spending quite some time with
Common Lisp.

~~~
mahmud
Schemers have not only appreciated exception handling, they have generalized
control transfer to a first-class operation. The last 20 years of PL research
in Scheme have only been about control semantics, to the point of abuse.

