Here's the thing with doing it with sockets, there is a bandwidth limitation and performance hit to doing it that way. Yes, it's nice with a client/server model but it can lag, and even a little bit of lag will seriously degrade the dwarf fortress. I'm willing to bet that the memory access issues you're supposing he'd have with threaded apps would be magnified ten fold in such a system.
The issues I mentioned have nothing to do with latency, and IPC latency is only an issue if your app really does rely on shared state and you need to get around it with IPC. If you need that, there are sometimes better ways of sharing state efficiently anyway, but it's not nice.
It's also nothing about a client/server model. Nor is there any significant bandwidth limitation, it's just a method of communication that involves some overhead, which goes away with time as improvements get piled on. There's nothing limiting about it in any innate sense, except the speed of light or some such thing.
Meanwhile the number of cores in single computers and even in server computers are going to continue to rise. Look for servers to have 50ish cores in the next decade and household computers to have equal numbers of much slower chips as companies seek a broader market for their technology.
Please don't repeat what we all know, it sounds patronizing, and makes me unsure as to what exactly your intent is here. I have already mentioned why threading is not necessarily a valid option for future scalability, but you repeat this without addressing my point. Why?
Personally I've been experimenting with various client/server programming techniques in order to make a MMOG server engine that is easily scalable to a network. The experiences I'm having prove that for me anyway, threading is much easier to learn and implement than sockets.
Sure, sockets are a pain. There are libraries and frameworks to abstract this away, you know. There are for threads, too, but there are problems in that it's not easy to cleanly remove shared state. And where you can't you have to mess with locks, and before you know it you might have even made your app slower. It happens.
It is absolutely definite. Even if he doesn't make the threads asynchronous (which he could easily do with weather and almost as easily with temperature), one of the threads is going to be the limiting factor, which means your fortress can do other things that by themselves would slow your game down noticeably without losing a single FPS. And if one thread is a hog, and threads take turns being the hog, if you have more threads than cores than the hog thread gets its own core and another core takes care of everything else. That means that you'd see an improvement even on just two threads.
You've said a lot of things I concur with, and yet you have not proven that threads definitely speed your app up. The fact is, they don't. Fine-grained locking can result in slow-downs. Are you aware of the architectural issues surrounding threads? It's not so cut-and dry. Nobody here as fully explored the depths of the tradeoffs that must be made (myself included-- I am no expert). Threading is not a magic bullet, not even to speed. Done badly it could drastically slow DF down; done well, it will still slow DF down on certain systems (in particular, 1-core systems).
And you have to realize that even though two cores isn't twice as fast, more than two cores IS more than twice as fast. And when the fastest core on the market is only twice as fast as the slowest, the only way to get more performance is to utilize as many cores as possible.
This is flat out untrue. It is not at all necessarily true that you pass some specific constant speed multiplier, because asymptotically the rate of change of speed when you add more threads goes to zero. When you start reaching this efficiency bound depends on your app, but it could indeed be after just 2 threads. This is basic parallel computing knowledge-- there is an upper bound so long as some tasks must be chained linearly, and in DF this is obviously true. Then this upper bound can be found by Amdahl's Law.