blaforge

I had only 2 years of experience with Scala and was not always able to foresee the overhead of various language constructs. As this was my first project where I considered performance critical, I decided to stick with Java--with which I have decades of experience and a more in-depth understanding.

I'll admit it, the disruptor architecture was my inspiration.

I've since put together an in-memory database built on JActor that processes a million ACID transactions a second (on an i7 with ssd). https://github.com/laforge49/JFile

What I didn't like about the disruptor pattern is that it seems to require a lot of architecture, and I like to keep things as fluid as possible.

My proposal is that a high-throughput actor framwork (like JActor) is close to ideal for building vertically scalable server software.

For another perspective, you should take a look at JActor. https://github.com/laforge49/JActor

JActor is a high-throughput JAva actor framework capable of delivering up to 200 million messages per second on an i7. It achieves this by operating synchronously whenever it can.

The main innovation here is what I call commandeering, which allows an actor to process the message sent to another actor in the same thread--so long as the target thread is idle.

Take a look at JActor, a high-throughput Java actor framework. It gains its speed by operating mostly synchronously and delivers between 80 and 200 million messages per second, depending on the mode of delivery. https://github.com/laforge49/JActor

Exceptions can be quite problematic. This is why JActor has taken such pains in its exception handler. One particularly nice feature is that, since JActor supports 2-way messages, the default exception handler passes exceptions to the active exception handler of requesting actor. https://github.com/laforge49/JActor