Most definitely! Here's the gist:
Development has seemed to stop simply because the plan is for Vertigo 1.0 to be developed on/for Vert.x 3. However, Vertigo development hasn't actually stopped at all. I just haven't committed to that repo in a while. Until very recently, too many Vert.x 3 APIs were still evolving for it to make sense to try to do the initial Vert.x 3 port. So, rather than working on Vertigo code, I've been contributing to Vert.x 3 development and working separately on replication algorithms for Vertigo 1.0.
Vert.x 3 is going to be huge for Vertigo, so I/we have no intention of abandoning it. Here's why Vert.x 3:
- Vert.x will support *automatic* language API generation for libraries like Vertigo. One of the challenges with maintaining Vertigo in Vert.x 2 was the development of separate APIs for each supported language. I certainly don't know all the Vert.x languages, so it would have taken an army to get Vertigo where I wanted it to be (able to be written in any Vert.x language). I've been contributing to language API generation in Vert.x 3 to make sure this can happen sooner than later.
- Vert.x 3 has event bus proxies which will make for a very interesting interface to the Vertigo cluster. Until now, I've had to provide separate Vertigo event bus wrapper interfaces for working with the Vertigo cluster. Vert.x 3 will allow much of that code to be moved into the Vert.x layer.
- Similarly, Vert.x 3 provides cluster-wide data structures, another feature which Vertigo has to provide on top of the Vert.x event bus with Vert.x 2. Again, more code that will be moved up in to the Vert.x layer with Vert.x 3.
One of my primary goals in the design of Vertigo has always been to delegate as much responsibility to the Vert.x framework as possible, and Vert.x 3 is a huge step in the right direction in that sense. Aside from that, I don't anticipate too much of the Vertigo messaging model changing between versions.
Most of the changes anticipated in Vertigo 1.0 revolve around fault tolerance and consistency. The tentative plan for Vertigo 1.0, aside from porting the existing API to Vert.x 3, is to provide a lightweight, configurable replication framework underneath the existing model. This framework will model Vertigo components as replicated state machines and guarantee fault tolerance and consistency both in terms of nodes and state. In order to accomplish this, I've been working on an algorithm that is fairly similar to the replication algorithm implemented in Kafka 0.8 (with some key differences that allow for better performance). Essentially, this will mean that each component *can* be represented as a log of historical events which can be replayed. The log can be configured according to performance and consistency requirements. This means that components for which state contributed to output, state can be rebuilt upon failures. But I digress.
Actually, stateful processing for Vertigo is a problem on which I've been working for a fairly long time, but it's finally nearing stability. Of course, Vertigo 1.0 will certainly be developed in such a way that these types of performance hogging features will be optional and disabling them will result in no performance impact (Vertigo is very fast in its current form). I'll post an extensive description of the new state and cluster management features here once Vertigo 1.0 rolls around.
Sorry to go on a tangent, but I guess that's all to say "yes!"