- Jeff Vroom, the author of StrataCode has built three successful platforms. He has a passion for creating innovative, forward thinking software patterns including:
- A data binding system in '92 (AVS/Express)
- A layered IOC framework with ORM in '96 (ATG dynamo, nucleus, jhtml)
- A declarative, data sync framework in 2005 (Flex Data Services)
- StrataCode is a second generation design for most major features
- Goal is to create a community of developers who build, maintain and benefit from the efforts to build a high quality set of tools with robustness, flexibility, and long lasting. Highly customizable by end-users leveraging the power of great developers.
Bill Wright has done a number of interesting things in his life, including service in the Marine Corps, fifteen years playing rugby around the world, and being considered for the host job on the Wheel of Fortune. He also has an extensive IT sales, marketing and business strategy background.
- He first met Jeff at ATG, where he ran Global Accounts such as Vodafone, Sun Microsystems and Hewlett-Packard. He was given an annual ATG award for sales and global strategic leadership in 2001.
- He worked on business strategy and alliances for VMware, and was responsible for identifying and building new verticals (Wireless Infrastructure, Unified Communications, Manufacturing and Business Intelligence). He was also VMware’s Global Strategic Alliances Executive of the Year in 2011.
He co-founded and sold an application company called Cremote, which featured one of the first home electronics remote control applications for the iPhone.
Jeff has had help from many people. Natalya Hung for advice on the syntax, help debugging and writing many of the early samples. Bill Wright for advice and help making StrataCode a sustainable reality. Laena Wilder for inspiration on too many levels to list them all. Todd Rein for help understanding how much help I need with developer marketing. Nathan Abrahamson for many conversations in the design of ATG's software platform. Rollin Crittendon has provided lots of insight and contributed the CSS parser, written samples, and helped with the documentation.
There are still a couple of high priority bugs that need fixing for the project to reach "preview" maturity. Even after that we will need your help refining concepts and names of things.
Here are the open bugs.
The compile times are fairly good - about 25 seconds to compile the program editor and a small sample including all of the framework layers, for both server and client runtimes from scratch. It is faster with incremental recompilation but that is still buggy. When you change leaf classes, the incremental times are pretty fast. When you change classes which are used by lots of other classes, it right now compiles all of those dependent classes but probably does not have to in most cases.
You can pre-build a group of layers, then reuse those files for layers added. This keeps build times small, even as the code sizes grow large.
Use the -a option to build all files for a clean build.
There are limited components in the UI, though they are easy to build out of Java, JS, SCHTML and data binding. Let us know what your needs are and we will help out so there's a shared standard set of great UI components.
StrataCode supports an IntelliJ plugin for Java develpment and you can debug the client-generated Java code directly in Chrome's devtools. It's also easy to debug using the generated code which is usually a clean-mapping to the original - i.e. fields turned into getX methods.
When you use StrataCode with .java files, it passes the code through unchanged. It has an accurate list of all code dependencies and so does efficient, safe incremental Java builds. You can refresh the code or using a tool change the code at runtime with dynamic layers. It's all written and configured in easy-to-read Java with extensions. Layers that are final work just like modules which turn into jar files in your classpath. That gets put into a shell-script you can run. It can also produce jar files you deploy or use in other Java code.
Goals for StrataCode
Our goal is a more efficient platform for building, customizing and distributing software using the layered design patterns. That includes better workflows, less copy copying, more reliable applications, more portable, configurable, manageable. One language with static typing used for all aspects of systems development, customization and deployment and enforcement of API contracts to bridge heterogenous development. Using a combination of layers and code-processing to minimize incompatibilities, provide more robust tools for managing growing complexity in systems. More flexible code deployments - e.g. migrating code between processes without breaking systems.
How you can help
We'd like input to help refine the designs so they can be efficiently used by everyone. As soon as we can maintain systems in a compatible, efficient way we'll start looking for customers with projects, and integrations. Until then contact us for the code. Submit bugs and feature requests. Help us improve the names for things! Suggestions for improvements. Any messages you find confusing, or things you can't find.
None of the code is that complicated despite the complexity of what it's doing. It's modular, well organized, and commented etc. We will answer questions or help you get started but the best place to learn about StrataCode internals is with a breakpoint in the debugger. If you are getting an error, search for the the code that generates that error and stop there. The data structures are easy to follow with informative toString methods.
We are looking for talented partners and advisors.