StrataCode

Scalable. Customizable.

A new dimension in coding with layers and code-processing

StrataCode provides Java extensions for data binding, components, layers, and client/server sync. An IntelliJ plugin. Java to JS converter. Site builder framework with storefront and management UIs.

Download preview Site builder Videos

Data binding for Java expressions

Attach expressions to properties with three new operators for configurable rules that run anywhere. Bind to remote data sources in the browser. Call methods when properties change for seamless async method calls. Use for validation, database queries, UIs, management UIs, and more. Debuggable and scalable for programmers. Easy to customize by everyone else. Learn more.

Forward binding

Reverse + bi-directional

Next gen components

Wire together components using properties. Use @Component for graphs with recursive relationships and multi-step initialization. The same source code works in both compiled and dynamic modes, all statically typed. Automatic getX/setX, events, parent/child, and flexible declarative lifecycle to provide a thread-safe sandbox for components. Reduce framework dependencies in application code by injecting them using annotations and code-templates. Framework dependencies are isolated to framework layers and generated code allowing application code to be freely reused.Learn more.

Layered code

Run programs with a list of layers. Each layer may extend one or more others forming an ordered stack.

Files in each layer are placed into a name space using settings in that layer (e.g. a package prefix may be added, html files placed in the web directory). Files in a subsequent layer with the same name will replace, or modify the previous one. Formats like sc, sct, and schtml support a type-safe 'modify type' operation by merging the source files using the code-processor. This operation changes the original type: adding fields, overriding methods, setting properties.

The combined result is saved in a typical project directory that's compiled and run. Learn more.

Multi-process systems

One layered config to better manage overlaps between tools. One command to build, and run client/server apps, or multi-process systems. Data sync of overlaps for efficient, intuitive RPC.

Web programming

Templates support reactive, web components with data binding, inheritance and tag objects that expose browser features as properties. Build concise, customizable, efficient pages whether as a static site, client-only, server-only, or in isomorphic client/server mode.

Templates are converted to Java that's transpiled to readable JS for the browser. Synchronize overlapping layers of the application to reduce the cost and complexity of client/server programming. Learn more.

Database framework

Built on a SQL parser/formatter for defining schemas in SQL, code or a mix. Supports only the proven patterns in O/R mapping. For more performance or complex situations, call custom SQL functions from generated APIs.

Supports interactive schema migration. Provides details about schema changes, schema history with validation.

Programmers can use thread-safe APIs that avoid stale references and build efficient DB components with caching, 'auto commit' or transactions.

Join data from different data sources all using annotations. Built-in workflow features for testing and staging changes against a production DB. Learn more.

Code processor

All languages, formats, and frameworks are built with Parselets, a revolutionary new code-processor. It parses code, and provides APIs to make incremental, type-aware changes before compiling (e.g. converting field to getX/setX property) Learn more.

Tools and customization

IntelliJ IDEA plugin, Management UIs built from annotated domain models (example). Dynamic layers - java simulator right from the AST optimized for run-once code. Supports Java-syntax for layer-definition files and live programming experience for dynamic aspects of the code. Later compile those same layers for efficient runtime (more).

Layers - universal config and customization

Build and run entire multi-process systems using layered components written with Java plus extensions. Layers provide cleaner module directories with less copying and scaffolding. Layer directories specify dependencies, additions, and modifications preserving their design intent. Move features from layer to layer without refactoring downstream code.

Layers support package install/update for maven and other package formats. They define new file formats, directory structure for downstream layers, add code-processors, modify Java types with layers.

As a project grows in size, layers offer refactoring freedom. A large type that has accumulated dependencies can be split into multiple layers, merged back again without changing the generated code. Those parts of that same type can be used in another process - e.g. a new mobile UI, or back-end service.

A preview release of StrataCode is now available. Contact Jeff Vroom (jeff@jvroom.com) for a download code. For those who like developing frameworks, it's a relatively small, readable code base with no core dependencies.

StrataCode is now ready for developers, projects, investors and partners.