
Quicksort is the new Hello World - rmontanaro
http://blog.rmontanaro.com/2010/12/11/quicksort-is-the-new-hello-world/
======
alextgordon
This article is misguided.

Hello World serves two (and only two!) purposes:

    
    
        1. It's traditional
        2. It lets you check everything is working
    

It _isn't_ a way to evaluate or compare languages. How could it be? It only
uses a very small fraction of the language. Note that the Hello World for C is
rather long and inelegant. But C itself is definitely an elegant language. So
its predictive power is poor.

QuickSort is neither traditional nor something a beginning programmer could
use to check everything is working. Therefore it is not a substitute for Hello
World.

\- - -

If you want to get a feel for a language with one code snippet, allow me to
introduce the Trabb-Pardo Knuth algorithm:

    
    
        In their 1977 work "The Early Development of Programming Languages",
        Trabb Pardo and Knuth introduced a trivial program which involved
        arrays, indexing, mathematical functions, subroutines, I/O,
        conditionals and iteration. They then wrote implementations of the
        algorithm in several early programming languages to show how such
        concepts were expressed.
    

[http://en.wikipedia.org/wiki/Trabb_Pardo%E2%80%93Knuth_algor...](http://en.wikipedia.org/wiki/Trabb_Pardo%E2%80%93Knuth_algorithm)

    
    
        ask for 11 numbers to be read into a sequence S
        reverse sequence S
        for each item in sequence S
            do an operation
            if result overflows
                alert user
            else
                print result

------
bmcleod
Hello world is valid for checking that you have everything installed properly
and it's the fastest way to make sure you get the most basic syntax of the
program.

It's not like the first thing you're going to do is write out all of quicksort
to see if it's easy. You're going to fiddle with numbers an arrays a bit
first, particularly if your language has some kind of interactive console. In
fact, I wouldn't be surprised if the first thing you do in the language is
actually 1+2.

There's quite a bit of syntax you need to learn before quicksort becomes a
relevant test.

If you're looking for a good language to build a quick website backend in you
probably don't even care about that, you'll care more about having nice ways
of passing information around and checking that it has a decent inbuilt sort
method.

------
T-R
I don't think "Hello World" will ever cease to be useful for the simple task
of making sure everything's installed and operating correctly. Quicksort is
certainly beautifully concise in Haskell, but it's not in all languages, and I
want a low probability of errors when I'm just getting things up and running
for the first time.

------
dshankar
For a veteran programmer learning a new language like Haskell, I agree
completely.

For a novice programmer learning their first language, they probably don't
understand the quicksort algo and probably have no concept of arrays or any
data structure. Visually displaying "Hello World" is very simple and teaches
you two basic parts of a language: \- Syntax \- Printing stuff

On another note, someone learning HTML for the first time will have no reason
to do quicksort.

~~~
fleitz
I don't believe HTML is Turing complete, and thus it's difficult to argue that
it is indeed a language for computing.

------
l0stman

        qsort :: Ord a => [a] -> [a]
        qsort []     = []
        qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
            where
                    lesser = filter (< p) xs
                    greater = filter (>= p) xs
    

I know nothing about Haskell but I don't think this code implements the
original quicksort algorithm which sorts the input in-place. Moreover the two-
pass of filter over the list and the concatenations cause unnecessary
overhead. Thus, even if the sample code is simple and elegant, a real-world
implementation would surely be a bit longer than the given example.

~~~
hristov
Ok, I am still learning Haskell, but I thought I would try to fix the above so
that there is only one filter pass:

    
    
        qsort :: Ord a => [a] -> [a]
        qsort []     = []
        qsort [x]    = [x]
        qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
            where
                (lesser, greater) = foldl split ([],[]) xs 
            where 
                split (left, right) x = if x<p then (left:x, right), else (left, right:x)
    

Does this work?

~~~
l0stman
I had to look up what the `:' operator does and it adds an element to the
beginning of the list. So the last line should be

    
    
        split (left, right) x = if x<p then (x:left, right), else (left, x:right)

------
dzorz
Although this version is very simple, concatenating and creating lists at
runtime ruins performance (and it takes extra memory). Please make it a good
example by doing a version of Quicksort with in-place partition.

~~~
Nitramp
That's actually a nice nab for functional programmers. They run around all the
time telling how nice their language of choice is, showing off quicksort in
three lines of code.

But please don't have the audacity of pointing out that original quicksort was
supposed to be an _efficient_ in place sort, not a mental exercise in beauty
of a language. Then you get a Haskell version that is in place, and supposedly
fast. It's about 10 lines longer than the C version, uses Monads, ST,
recursion, "unsafeRead/Write", "rscan", "lscan", "swap", "sloop", etc., all
together about 20 concepts, built-in functions, etc.

Also, of course, if it really should be fast, you have to use several compiler
hints and macros to make it type specialize and all. Obviously.

The C version is shorter, uses nothing but array accesses, do/while, if, int
comparisons, and recursion. If you want to explain the C version to a novice
programmer, it will maybe take you half a day. The _inplace_ Haskell version?
Uhhh, yeah.

I can't help it, but things like these leave me with the impression of Haskell
being a theoretically really nice language whose utility in actually getting
things done seems somewhat questionable.

------
mwill
I still write and run Hello World in languages I am well versed in when I
start working in a new environment, purely as a sanity check. In many cases it
is the simplest starting point to ensure you have a working environment.

As far as familiarizing myself with a new language, I usually write a Hello
World, then add some variables, and some functions or whatever is relevant,
and just focus on the syntax of the language, or in the case of a platform or
framework, take a look at building trivial components.

Not a language, but a platform example: I recently explored ExpressJS (If
you're not familiar, its a framework for node.js web apps.) and my workflow
was: Make a hello world server, Add a few routes and a static handler, Add
some views, Add some middleware, Build it into a basic blog. (Because it's
always a blog first, right?)

The whole process was quite quick and gave me a very strong jumping point for
ExpressJS. Implementing quicksort or something similar as my first crack would
probably have been pretty useless. So for me its all about context; I tend to
start at Hello World and quickly grow something simple, but relevant to the
language or platform.

------
DanielBMarkham
Yet another article that completely misses the point. The point of "Hello
World" is to show a noob how to fire up the editor, compile, and see something
happen.

And btw, here's the answer in F#:

    
    
      let rec qsort = function
           | [] -> []
           | x::xs -> let smaller,larger = List.partition (fun y -> y<=x) xs
                      qsort smaller @ [x] @ qsort larger

~~~
sizzla
This looks like yet another Haskell "variant." From what I can tell this sort
does not occur in place and thus would not make a particularly good quicksort.
Memory use, number of accesses per element, etc. This style of programming is
more suitable for heapsort or maybe mergesort.

~~~
zbanks
You can't exactly sort "in place" in functional languages like F#/Haskell...
at least trivially.

------
noamsml
I think I'm not alone when saying that the first thing I write in a new
language I learn is some sort of project that requires a good understanding of
the language's function-call model, of its object model, of a few specifics
(strings, regices, data structures, arithmetic [depending on what I find
interesting]), and that requires me to use some part of the standard library
not readily available or to decompose my code into multiple files (or both).
This helps me understand better what I'm doing, what I like about the language
and what I don't. Examples of such projects include IRC bots, Lisp
Interpreters, twitter clients, etc. (The one exception is Haskell, where I
haven't gotten far enough to understand Monads well so I just wrote a
completely functional RPN calculator).

------
sgt
I'm proficient in Hello World in 24 languages. And now you say my knowledge is
obsolete?

------
sb
tl; dr, but a quick note: the presented algorithm takes the first element as
the pivot element p:

    
    
       qsort (p:xs) = ...
    

This is not recommended as it results in worst-case behavior on sorted input
lists. (Another commentor correctly pointed out that it requires extra memory
for the intermediate lists, too.)

~~~
Deestan
It is just a toy implementation. If we're going to worry about practicals,
then it's not recommended to use your own general purpose sorting
implementations _at all_. For general purpose sorting, the standard library
"always" has the best implementation.

~~~
dagw
Except it is also the canonical look-how-awesome-Haskell-is example that keeps
getting trotted out all the time. Why aren't there more canonical examples of
Haskell being both simple and awesome as well as fast and correct?

------
yoyar
Hello World is there to validate that you can setup, compile and run a program
in your new language of choice. Complicating that process by trying to write
something non-trivial defeats the purpose of the exercise. I call BS on this
article.

------
arvinjoar
Someone already pointed out that you try out "Hello World" to see if
everything is working correctly. Anyway, the author fails to make the
distinction between _is_ and _ought to be_ , it's sloppy.

------
seanmcq
This test gives an extreme advantage to lazy functional languages that they
don't enjoy in any realistic context.

Trying to come up with a single test that is good turns out to be surprisingly
hard. In modern languages I'm looking for the ability to do clean functional
code, stateful object code, async programming, a solid module system, and a
type system that doesn't get in my way. I really can't imagine a single 5 line
program that would encapsulate all of these areas.

------
pauljonas
The only way to learn a new programming language is by writing programs in it.
The first program to write is the same for all languages:

 _Print the words_

    
    
        hello, world
    

This is a bug hurdle; to leap over it you have to be able to create the
program text somewhere, compile it successfully, load it, run it, and find out
where your output went. With these mechanical details mastered, everything
else is comparatively easy.

 _The C Programming Language [Kernighan, Ritchie]_

------
_tef
It is like fizzbuzz/binary search in that most people think they can write it
and they get it wrong.

Quicksort requires careful selection of pivots, and is unstable. (Many
scripting languages (perl, python) are opting for stable sorts)

Check out Bentley&McIllroy's Engineering Quick Sort for a guide about the
problems implementing a production ready quicksort.

If you're going to teach them something easy, simple and relatively hard to
implement badly, teach them merge sort.

Then teach them adaptive merge sort.

~~~
sizzla
I would rather teach them:

1) how to write a program that guesses a number you thought of by doing binary
search.

2) solve 2-queens

3) solve n-queens

4) solve knapsacking or some other combinatorial problem requiring memoization
or DP. Of course, I wouldn't tell them any of those buzzwords that are meant
to scare them away from just hacking on it.

Their mind will be blown regardless of the language they used and they'll get
a feel for O() without even opening Cormen.

------
nkassis
After I write my "Hello World!" program I usually graduate to writing a
tictactoe game. Tictactoe has enough stuff to learn the basics of most
languages.

------
gsivil
I think your point is valid and of course interesting for programmers, but
KR's "Hello, world!" is still relevant for students and novices. Maybe
reading/writing on a file would be more useful nowadays, since it does not
demand knowledge of algorithms.

~~~
ollysb
A large part of the value of a hello world is to check that you've actually
installed the language correctly and can compile/run code. Printing hello
world is just the simplest way of proving it.

------
billmcneale
QuickSort is still a very small problem that is not going to show much about
the language.

Gosu's example code does a good job at covering a lot of aspects in ~50 lines
of code:

<http://gosu-lang.org/intro.shtml>

------
LostInTheWoods2
I usually implement a tic-tac-toe game as my first project when learning a new
language. Tic-tac-toe, properly implemented, will give you a pretty good tour
of a language. But with that said, Hello world, still serves it purpose.

~~~
sizzla
This is a great example of making something that is challenging for a novice,
yet not so challenging they give up. The reward is much higher than watching
some numbers show up in the correct order and you tend to cover more of the
language (2D array or your own abstraction of such, I/O, control flow, etc.).

------
quadhome
"For every complex problem, there is an answer that is clear, simple-- and
wrong."

~~~
sizzla
Beautiful. We really need more cynicism on HN.

------
yoshiks
Do we all agree to teach from quicksort, to complete newbies of programming,
while most experienced people had hard time to understand? Or simply just read
this thread and imagine if you are just 12.

------
eliben
Sadly, many programmers don't understand how quicksort works. This makes it
somewhat unsuitable to be a hello-world.

------
sid0
I think something simpler would be a better Hello World equivalent. The first
program I generally write in any functional language (usually as a sanity
check) is one to calculate the factorial of a number.

