Concurrency ≠ Threads
martincmartin.com
martincmartin.com
I don't see how this solves the problem. It's true that some problems work well as pipelines where each stage does some finite, balanced amount of work before passing the data off to the next stage. But many don't.
And I don't follow the files and shared memory argument at all: those are both shared, unsynchronized-in-the-base-API abstractions just like threading. And they're subject to all the same deadlocks and race conditions. The only difference is that you use slightly different synchronization primitives (e.g. fcntl() locks instead of mutex locks).
It's correct to point out that traditional threaded code is difficult to get right. But it's naive and unhelpful to point to any kind of "secret sauce" as the solution. The difficulty of concurrency lies in the problem itself, not the API.
This article contains some interesting viewpoints about shared memory: http://nerdwisdom.com/2007/08/23/programming-erlang/
Isn't it possible that it's both? Concurrency is hard, but I think the classical threading model makes it harder. There are simplifications that really do make it easier to reason about concurrency, like doing all inter-thread communication via queues, OpenMP-style "parallelize this for loop" constructs, and pure-functional immutable data structures.
It's not something you can solve with file naming. That's just a technique for avoiding collisions.
A good way of seeing this is to look at languages that have "solved" concurrency issues, such as Erlang. I mean, sure, you won't have concurrency problems in Erlang, but that comes at the price of only having immutable variables...
I think the problem with concurrency is that certain things that we do in sequential programming are provably impossible to do reliably in concurrent programming. So we end up using traditional languages, such as C/Java/Python, which are very error prone because we can only correctly use a subset of the language features, and it's not clear what the subset is, or we can use a language such as Erlang, which explicitly enforces concurrency-correct code, but then we find programming in such languages very restrictive.
Meh. I'm not enough of a language wonk to figure this one out!
http://www.eecs.berkeley.edu/Pubs/TechRpts/2006/EECS-2006-1....? [pdf]
Using multiple single-threaded processes means you're using multiple threads.
What he's saying is true, but he's worded it really clumsily. He's pointing out alternatives to multithreaded processes, not threads per se.