
Programming languages worth checking out - bleakgadfly
http://www.h3rald.com/articles/10-programming-languages/
======
hanskuder
In my first job out of college, I worked for a company that built industrial
test equipment (machines that snapped airplane wings in half, shook cars
around like they were driving down a bumpy road, that sort of thing).

The tool we used to write the supervisor code and GUIs for machine operators
was a language called Alltalk. It was inspired by Smalltalk and developed by
an old graybeard at the company. Reading the description of Squeak/Smalltalk
brought back some fun memories. A few interesting highlights:

\- Alltalk ran in its own VM. You could create objects, change their state,
and save the entire stack/image back to the original VM. Running the VM again
would pick up execution right where it left off. This let someone do crazy
things like email an Alltalk image to another engineer and say, "Here's the
machine state halfway through an emergency shutdown. The actuators all came to
rest in 10ms, but it's taking way too long to shut down the hydraulic pumps.
Any ideas?" and the engineer could run the VM and debug away.

\- The Alltalk VM had its own object inspector and terminal/interpreter. So
you could walk up to an Alltalk instance connected to a live machine with
motors spinning at 20krpm, for example, open up the inspector, and code away.
Realize you need a low-pass filter on the motor speed feedback sensor? Create
the object, tweak the parameters, and wire it into the signal chain live.

Cowboy coding at its absolute finest.

------
jules
Another avenue for learning is to start from hard problems. A hard problem is
a problem that is very hard without using a known technique or solution.
Somebody who's unfamiliar with it has no clue on how to even start solving it.
Solving such a problem will add new techniques to your tool-belt for solving a
whole class of problems.

Problems that I've found worth studying:

\- Parsing. This is hard if you don't know the standard techniques: mostly
recursive descent parsing with precedence -- or a parser generator, but that
won't teach you much unless you write the generator yourself. Moreover I've
found that you quickly run into limitations with parser generators and they
don't make parsing easier in the long run, that's probably why most real world
parsers are hand written (e.g. gcc, llvm). You can probably hack something
together that sorta works, but knowing the right techniques makes writing an
efficient parser that you have high confidence in a breeze. I've seen many ad-
hoc parsers that would have benefited greatly from proper parsing.

\- Constraint solving. Examples are solving sudoku, the zebra puzzle, SAT
solving, optimal register allocation and many others. The three most important
techniques are backtracking, constraint propagation and conflict learning.
Even professional programmers can't do this if they don't know these
techniques (e.g. <http://xprogramming.com/articles/oksudoku/>).

\- Interpretation/Compilation. In addition to being a hard problem, writing an
interpreter and a compiler makes you understand how programming languages
work. This is sometimes seen as a black art, but it is quite easy once you got
the pattern.

\- Numerical algorithms. The speed and the simplicity of numerical algorithms
is astonishing. Newton's method is particularly amazing. In about 10 lines of
code you can solve equations, do state of the art numerical optimization or
solve differential equations. It can even handle problems that are usually
considered to require specialized algorithms, like max flow and linear
programming. It can also perform arithmetic operations, like division and
square root.

\- Machine learning. This gives you a different perspective on problem
solving. Many people when presented with the task of spam filtering or
determining the language a snippet of text is written in will respond with a
hard coded scheme based on a lot of rules. A much better approach is to take a
data set of known text and analyze the statistics of the data set and compare
that with the snippet of task text. The same applies to many other problems.

What should be added to this list?

~~~
swannodette
Of course with some languages those problems are no longer "hard":

    
    
      - Prolog w/ Constraint Handling Rules simplifies constraint solving
      - Prolog simplifies parsing
      - Lisp simplifies interpretation / compilation
    

That leaves numerical algorithms and machine learning, which I agree are
useful to understand anyhow and different programming languages offer little
leverage ;)

~~~
jerf
Haskell and parsing combinators takes an enormous bite out of the parsing
problem, too. I won't call it "solved" but it brings it down to the point that
writing a parser for a custom minilanguage is more like "a day's work" than "a
month's work".

------
majika
Most languages are "worth checking out." Every language offers something
unique, by definition. The question is: which languages are "worthier" than
others? Or, rather: how should you prioritise your learning queue?

I don't think the author's list provides much variation. They're all important
languages, to be sure, but I believe you can get better mileage for your time.

My ten recommedations, in recommended order, are:

    
    
        - Racket (nee Scheme - why did they have to change the name!?)
        - Haskell
        - Java (reading the GoF)
        - C, and the POSIX libraries and system calls
        - Go
        - Javascript or Lua
        - Smalltalk or Squeak
        - Erlang
        - Forth
        - Prolog

~~~
razzmataz
Scheme's name didn't change, only PLT's implementation of scheme changed it's
name and called itself a new language.

~~~
samth
PLT Scheme was always a different language -- the name change merely makes
that clear to everyone else.

------
marcelcor
This is from end of 2008. It would be great to see an article like that for
today. Or maybe things didn't change?

~~~
stonemetal
As far as I can tell not too much has changed in the language landscape since
then. IO, and Factor seem to have stalled a bit. Scala and Clojure seem to
have picked up a little steam. In the time since then Go is the only language
to make enough of a splash that I would give it any thought. For me at least,
F# is the only older than that language that has become interesting enough to
learn.

~~~
minikomi
Io always looks so tempting but it seems like just a "play" or learning
language... Is it worth diving into regardless?

~~~
phaedrus
I'm using Io in a serious project, it is the scripting language I chose to use
for my games. Io's expressiveness and reflection has allowed me to make lots
of mini-DSLs to simplify game scripting tasks. I'm very happy with the
performance of its garbage collector; it's pauseless and I have profiled it as
using only 10% of the cpu time while running a game. I think the vm code has
been stable for some time now and the move to cmake cleaned up the build
process. The only disagreement I have is over coroutines - they do weird
things to the stack and they dont play nicely with C++ exceptions if you throw
one and let it cross a coroutine boundary. I've started a project to port Io
l's C code to C++ and replace the coroutines implementation. Most of my
projects on github are related to Io in some way:
<http://github.com/dennisferron>

~~~
minikomi
Interesting thankyou. I will have a dig.

------
cppsnob
The thing I never understand about these articles: why aren't C, Java, C++,
C#, Ruby, Python and other mundane languages "worth checking out?"

I don't think you should assume people have used all of these, and they're all
worth "checking out". Millions of people use these languages every day to
create 99% of the software you're using right now. Maybe it's worth a shot if
you don't know one of them to learn one and maybe even get a job with it.
There's a lot more opportunity to learn Ruby and get a job in it than there is
for Scala.

~~~
varikin
I think it is more assumed the many programmers know or are familiar with
those languages. I know Java and Python. I have some limited experience with
C, C++, & C#. I looked at Ruby. I would assume the majority of current
programmers are in a similar situation.

The draw of these other languages like Factor, Io, Erlang, Haskell, and the
other is that they are different. Erlang focuses on concurrency in a way that
is not seen in the common languages listed above. Haskell is strongly typed
functional language with lazy evaluation (I think I have that right). I don't
know where Factor and Io fit it. By learning these other languages, I would
hope to learn different ways to solve problems or to think about things. I
would argue it isn't about learning them for more opportunities, but for a
broader perspective in general.

------
vilya
There are a couple of languages I'd add to the list:

    
    
      * Mozart/Oz - will (probably) change your thinking about concurrency.
      * Clay - really pushes the idea of generic programming.
      * Rust - typestate makes assertions part of the type system.
      * Cilk - concurrency again.
    

BitC was looking quite interesting too, but I haven't heard anything about it
for some time now; I hope the project hasn't died off.

~~~
patternexon
This is a more interesting list than the OP's. Thanks !

------
Dn_Ab
fogus links to his list <http://news.ycombinator.com/item?id=3083561> which I
think is one of the better lists of this type since it covers the paradigm
space more thoroughly than most such lists.

The only type of language I rarely seen mentioned are dependently typed
languages like agda or epigram. maybe it is because they are not yet
practical. They are an interesting directions things could take though.
Fortress is another interesting one.

Another interesting language is Aldor. It's unique in that it has a weak form
of dependent types and is a statically typed Computer Algebra/general
programming language. Going through the types of the language is an education
itself and a reasoning helper. While some take issue to the hierarchy it
defines, it is the only one I know that has tried and is useful. The type
provide some scaffolding for reinforcing the novice math person trying stuff
out.

------
ElliotH
Haskell at the top of the list was one that I really enjoyed. It has a pretty
scary learning curve but its wonderful having a language that feels so
consistent.

~~~
viscanti
I disagree. I think a lot of uninitiated potential haskell users are turned
off by hearing about the "scary" learning curve. The key is to forget
everything you know about imperative programming going in. There's a
temptation to compare each Haskell idea with the similar idea in whatever
language(s) you already know. Approaching with an open mind turns that "scary"
learning curve into an easy and rewarding journey.

~~~
qx24b
The scary learning curve isn't really a bad thing, I was never turned off by
it, the main turn off for any programming language for me is going to be
resources which is why I chose python over ruby (as python has in my opinion
much better documentation and community).

As a disclaimer I've never really learned haskell yet, I do go through
tutorials and solve some problems with it and everything now and again but I
haven't fully grokked the language yet.

------
natural219
If you're interested in actually checking these out, 7 Languages in 7 Weeks
([http://pragprog.com/book/btlang/seven-languages-in-seven-
wee...](http://pragprog.com/book/btlang/seven-languages-in-seven-weeks))
covers five of these (Haskell, Scala, Io, Clojure, Erlang) as well as Ruby and
Prolog (Prolog is my favorite language from the book, oddly missing from this
list). Apart from being a very good introduction to syntax, it teaches you the
unique features of each language and why you should care about it. Highly
recommended.

------
raminf
I would add Falcon (<http://falconpl.org/>) to the list. It's a pretty capable
language, but for some reason nobody's heard of it.

~~~
gtani
Also not getting mind share but should: Mozart/oz, fantom, gosu, nemerle. And
what happened to the language that

 _stole the show at 2009 JVM Language Summit_

<http://www.javaworld.com/community/node/3440>

------
fletcher
"Io" sounds like "the next SELF". I'll try it out for sure.

~~~
soapdog
Try it. Io is really a joy to use. I don't use it for any professional work
yet but I've used it to craft some little tools for my personal use. Really
fun to use.

------
hugh3
I skimmed the headings and was briefly interested in reading about this
"Epilogue" language that I hadn't heard of before, but it turns out it was
actually just an epilogue.

------
SoftwarePatent
On an iPad 2, the text appears, and then dissapesrs. I can read the comments
only.

------
whatgoodisaroad
I totally expected the section titled "Epilogue" to be about a Prolog variant.

------
dextorious
The aricle is OK, but I had to laugh with this starting quote:

"“The most obvious common ‘personality’ characteristics of hackers are high
intelligence, consuming curiosity, and facility with intellectual
abstractions. Also, most hackers are ‘neophiles’, stimulated by and
appreciative of novelty (especially intellectual novelty). Most are also
relatively individualistic and anti-conformist.” – Eric S. Raymond, The Jargon
File"

Which reminds me of that immortal Reservoir Dogs line: "let's not start
sucking each other's dicks quite yet"...

~~~
jgrahamc
Any article that starts with a 'call to authority' where the authority is Eric
Raymond is likely to be poor. And lo the article is quite poor.

~~~
mkr-hn
But it also invited this comment:
<http://news.ycombinator.com/item?id=3083782>

So I'm conflicted.

