Uh huh - might mean I’m stupid and don’t have anything useful to say or maybe I was trying to move some readers down a particular alley of thought or perhaps I was writing it for myself, a snapshot of some part of my thought processes or maybe there was some other reason entirely. Maybe you believe that anything vague or subjective has no value or place in the world, who knows.

“but i’m guessing for 99% of applications”

See now that’s interesting - you’ve switched from being very definitive in your first statement to apparently a guess in the follow up. Having come out so strongly I’d have expected you to continue in that vein and rather than guess, present some data to back yourself up.

“btw, we’re already writing software for scenario 4 -> a varying number of hostile processes communicating on a hostile bus”

Hmmm, you’re maybe alluding to Byzantine systems - dealing in those might make you smart by some measures or it could just be that your mind works a particular way suited to that problemspace. However the above is merely a reference so there’s no way I can make a judgement on how clever you might be.

So maybe I’m uninformed or stupid and don’t know about such things so I didn’t mention “scenario 4″ in my posting (and the fact you did makes you superior to me) or maybe I was deliberately leaving it out for another posting or maybe I didn’t feel that referencing it helped in what I was trying to say or …..

using something like quicksort (single thread, single memory, etc) right now is completely justified because your parallelization happens at a higher level. if your main goal is to sort a large dataset, then you wouldn’t choose quicksort, but i’m guessing for 99% of applications, this is not the case.

you’re trying to extrapolate the multicore ‘crisis’ (trend) into other areas. software is always built upon assumptions, and frankly the assumption of one big shared memory isn’t that big. memory can _always_ get bigger (we can always put more chips in a circuit. eventually the decoding logic would become the limiting factor, but that would be way off). memory bandwith is what you should really be worried about. and when it comes down to it, nonscaling memory bandwith is really the same kind of limit as nonscaling single core cpus.

furthermore, when you decompose software into message sends (like erlang and scala actors), you’re making enough of an abstraction for each sequential processor to have it’s own memory (a message send would then pass the message into the other piece of memory, and that could even be helped by dedicated hardware)

btw, we’re already writing software for scenario 4 -> a varying number of hostile processes communicating on a hostile bus