by Jeff Vroom

This set of articles is a rather long-winded introduction to the concepts of StrataCode. StrataCode is targeted towards programmers looking to optimize the building of customizable platforms. If you are starting a long-term project with lots of customized versions of the same code, in what you are building, you should read on.

The main goals are: building resuable, customizable components, leveraging Java with additional declarative operators. Not only can you build declarative applications, you can quickly construct management UIs directly from application objects, which themselves can be customized. To accomplish these goals, I basically started from scratch and wrote code for more than eight years, about an equal mix of full and part-time, till I wanted to write code in this new environment. I'm happy to say that day is here. There's still a lot of work on the framework side, but I'm no longer running into major priority-one bugs at every turn which is only impressive when you start reading the challenges overcome in the implementation.

StrataCode's frameworks support patterns that separate framework code from application code and those that minimally require code-copies of the domain model. Code-generation is used to pre-process source code in a way that preserves static typing to build powerful, flexible frameworks and a new level of code-reuse, and deployment efficiency.

This is a long-term project, coming out of incubation stage written primarily by one programmer. It was inspired by a twenty year career of building frameworks and the desire for a set of tools, built on a healthy ecosystem of innovation, and collaboration of developers looking for and implementing the best software patterns to build efficient, customizable, and robust systems. To accomplish the goals, StrataCode took a leaner approach than most Java frameworks and has essentially no library dependencies. The goal is to create a nimble set of code so any problem can quickly be debugged, to improve security, reliability, and maintainability of code long term. To add a new model for defining and maintaining multi-process systems, using layers and synchronization to more flexibly re-factor code, without changing interfaces. When you look at a StrataCode stacktrace, log file, or error message, you should be able to quickly trace what's going on. Unlike most language projects, the primary goals are readability of the code, traceability of references. In my experience, most time is wasted searching for the answer to a problem and so we seek to minimize that by making everything easily traceable and easily debuggable, even while ratcheting up the complexity of the frameworks and applications we want to build.

StrataCode uses its own code-processing library, built in Java, that makes it easy to add new parsers, and supports easy, incremental read-modify-write of code from a single declarative grammar. To both test the platform and demonstrate the power of layers, StrataCode adds an extension to Java for 'layering' components and configuration, as well as implementations of the best patterns in the industry for templates, client/server programming to separate application code from framework code. There's a Java to Javascript conversion tool to show how easy it is to convert code from one language to another using this platform. There's an intelliJ plugin that works a lot like Java and enough framework integrations to make it usable to build applications today.

Read more in the introduction.