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 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.

Project Status

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.

Not much optimization has been been done on Javascript code-size. There are big optimizations available, like omitting JS code from static elements and ommitting unused classes that are very easy. We've been focusing on quality so more people can help testing fruitfully. Because StrataCode has nice library organization, you can cache the Java libraries and the other core stratacode libs from one app to the next. There could be an option to also generated the smallest possible JS file, i.e. that only includes code which you are using for the smallest one-page sites.


You currently have to debug nice, similar looking generated code. You should be able to using integrated debugger when we add hooks that match line numbers.

You can use IntelliJ or Ecllipse but need to refresh the IDE on the generated code for debugging.

The IDE limitations have been easy to workaround but we'd like to build Java-like IDE integrations.

Incremental Design

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.

Jeff's Pledge and Software Philosophy

If you find a bug I'll do my best to offer a workaround as soon as possible and fix it as soon as I can. If you give me access to a test suite, I'll make sure those tests run on each new release.

I believe in open source for platform, framework and horizontal application features. The stuff everyone needs to write and run a scalable business application. This stuff is mission critical and so should not be monopolized for cost and reliability reasons. Support, services and more niche features with smaller audiences usually are priced to pay for development and to create substainable viable product ecosystems. They might or might not be open source based on how the developers choose to monetize their IP most efficiently. This is the stuff you want to pay for so it's customized for your needs. If it's not open source and you use this code, you need a stronger trust relationship with your suppliers.

My goal is to build a business supporting StrataCode core through support, services and value-add products and features to address these more niche markets. Layers, when provided in an open source platform are the ultimate democratizing force in software deployment. Just as they separate application code from framework code, they separate horizontal code everyone needs from highly specialized code only a few people need. They let you be confident you only pay for what you need. You can migrate vendors a layer at a time.

If there's demand, layers would make a great software marketplace for distributing customizations and add-on features and key platform features will be open sourced. We'll focus on only taking projects we are confident will be succesful and open the platform as soon as it's sustainable for compatible, efficient code engineering and good maintenance and customization workflows.

How you can help

We need 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. The data structures are easy to follow with informative toString methods.

We are looking for talented partners and advisors.