One of the nicest things about BeOS is its elegant support for symmetric multiprocessing. With SMP, it's easy to write programs that take advantage of the combined power of two, four, or even eight CPU's running on the same computer. But why stop there? Wouldn't it be great to run your program on 16 CPUs in parallel? Or 128? Or 512? Sure it would! With that much CPU power, you could write programs to do things that were never possible before. However, due to the memory bandwidth limitations of SMP, you're not likely to see BeOS running on a 512-CPU (or even a 16-CPU) machine any time soon.
But there is nonetheless a way to achieve such massive parallelism under BeOS. All you need to do is network a group of BeOS machines together, and have them all act as part of a single "virtual computer", with each computer running a different part of your program. Instead of paying an arm and a leg for some monstrously expensive 64-CPU machine, you could just buy 16 4-CPU machines, and some Ethernet cards. Cheap(er) and easy, right?
Well, it should be easy. Until now, though, it hasn't always been so. The idea is straightforward enough, but software inflexibility and mundane implementation details get in the way, making development of programs that span multiple machines difficult, tedious, and error-prone. Before you could even start working on your program's real task, you'd have to write networking and synchronization code to link all the machines together, and very likely during development you'd run into mysterious problems because the various machines weren't quite compatible, or some of the machines were still running an old version of your software (because you had forgot to update them after your last compile), or your network would become a bottleneck, robbing you of performance, or...
SockHop
SockHop is a package which solves these problems for you. You just install and run libsockhop.so on each machine on your network, and after that your programs(*) can use all the BeOS machines on your network almost as if they were one single gargantuan machine. SockHop automatically starts, stops, and manages processes on each of the various machines for you, handles the inter-computer message routing and broadcasting, automatically propagates the newest versions of your code and data to the computers that need it, and even allows you to run your program on a mix of Intel and PowerPC BeOS systems at once. Furthermore, SockHop is designed in such a way that your virtual machine can scale geometrically in size, from one machine to dozens, hundreds, or even thousands. But if you can't afford to buy thousands of PCs just yet, you can develop and debug your multi-CPU program on just one machine, and when it's done you will be able to deploy it on a large scale, with almost no changes to your code. All this is implemented using a simple, powerful, easy-to-learn BMessage based API, and an internal architecture that takes full advantage of Be's state-of-the-art multithreading, networking, and run-time code linking capabilities.
*(Programs that are written to use libsockhop.so, that is)