Sorting sucks.

Sorting and parallelization… Yeuch.

You can get significant performance gains by parallelizing various sort algorithms cleverly, but ultimately there’s some data on the left that needs to be on the right, and vice versa.

Consider: [ 42, 15, 11, 17]

You can divide this into two workloads for parallel processing: [42, 15] and [11, 17]. But they are going to take different amounts of time.

And you can’t sort the whole group until both sub-groups are ordered, which means synchronization.

So I wound up having fun experimenting with various sorting algorithms in Python using matplotlib. Until Python started annoying me. Not that Python is bad, I can see why people like it. But from a C/C++ background there are just lots of things that make me balk.

E.g. The weird Python 2.6/3.0 string formatting:

print("Some {0} over {1} is a {2}".format("where", "moon", "cow"))

This gets annoying if you remove an argument… Since you then have to renumber all the remaining arguments.

And the old format,

print("Some %s over %s is a %s." % ... how do I do this? ...)

I couldn’t figure out.

Some of it was self-induced; sorting involves a lot of element swapping, and Python doesn’t have a native “swap”, but is rather proud of the fact you can do:

list[l], list[r] = list[r], list[l]

While that syntax offers some neato possibilities, when it comes to doing the above it’s just bloody irritating and it doesn’t clearly state what you are doing.

(solution: make your own swap function, which I did, but still)

Lastly (well, last I can be bothered to ramble on about), the whole whitespace thing.

When working with short snippets of code, I like the Python style where indentation controls the extent of a sub-section of code:

if theSkyIsBlue :     # ':' in this case means 'then'
    print("The sky is blue")
    theSkyIsGreen = false  # same indent level, still dependent on the if

print("Not indented, we are back to normal")

But I find it kinda hideous if you get many levels of indentation.

def foo(work, depth):
    width = len(work)
    if width > 1:
        if depth > 1:
            if width < 8:
                return work.sort()
            else:
                if depth > 2:
                    r = letsDoSomethingElse(work)
                    if r < 10:
                        r = somethingElse(work)

                        if r > 3:
                            foo(work[:width/2], depth+1)
                            foo(work[width/2:], depth+1)

def somethingElse(work):
# ...

Noooooooo. MUST PUT FI or } or SOMETHING to indicate I hadn’t just not finished this code!

That cliff-like fall off from the final level of compound statements to the “def” on the next line … URGLE.

I find that what I tend to wind up doing is using blank lines to denote “end of compound statement”, and as a result not using it elsewhere in code (did I mean for the “if r > 3:” to be indented? I dunno)