StrataCode Documentation

Use the object operator like 'class' to create both a type and an instance.
Generated code defines getPerson() and a class if needed.
Inner objects are read-only properties of the enclosing object
Initialize a recursive graph of objects using @Component
Use the scope keyword to control the lifecycle of the instance (e.g. scope<session>, scope<window>, scope<global>)
(more)

Data Binding

Person {
   String fullName := firstName + " " + lastName;
   String name :=: inputField.value;
   name =: System.out.println("New name: " + name);
}

x := y; Defines a forward binding. x, a property, is set when y, a java expression's value changes.
x :=: y; Defines a bi-directional binding. x is set when y changes and y is set when x changes. y must be an invertible Java expression, (e.g. 7 * z works but w * z gives an error).
x =: y; Defines a reverse-only binding. when x is set, y is set or evaluated.
(more, api)

Multiple Inheritance

// inherit fields
interface Style {
   Color foreground; 
}

// inherit property assignments
interface RedStyle extends Style {
   foreground = Color.RED;
}

Put non-static fields in interfaces so they are inherited by all implementing classes. get/set methods are generated and used. Use property assignments in interfaces to copy those changes to all implementing classes. Use default methods for adding behavior.

File types

.sc
.schtml
.sccss
.sct

.sc Files

object HelloWorld {
   String message = "Welcome to StrataCode";
}

The .sc suffix is used for StrataCode files, a superset of Java including layers, data binding, and more. It will usually work like Java but there are some differences. Mix sc and java files on a file by file and layer by layer.

.schtml Files

<html>
  <body>
     <%! String yourName = ""; %>
     <input type="text" value=":=: yourName">
     Hello <%= yourName %>!
  </body>
</html>

The .schtml files mix HTML and Java to convert tags into StrataCode objects. Tags can extend other templates or tags and the bodies of the inherited template can be merged in different ways - append, replace, merge using order rules, etc. Templates can embed Java using JSP-like syntax tags - <%, <%=, <%!, and <%@ (more), (api).

.sccss Files

.body {
   width: <%= Window.window.innerWidth %>px;
}

The .sccss files use template language operators to generate CSS. You can control whether the CSS is generated at build time, server-load time, and/or updated dynamically on the client when values change.

.sct Files

<%! // switch to code
object TemplateString {
   String message = %> Now we are 
in a "template string".
<% ; // switch back to code 
} %>

When your .sc file needs to embed large regions of text strings, you can rename it to .sct. Then use the JSP-like language operators to switch back and forth between code and template strings. A template string can be used in place of any String expression in Java. (more)

Tools

scc command
IntelliJ plugin
Program editor
Command line

scc command

% scc editor/js/mixin example/unitConverter/html/clientServer

The scc command is a build, run, refresh, restart tool all in one. You supply the list of layers and it compiles, and runs the resulting application and can refresh, and restart itself as needed to update based on code you change. The last layer in the chain of the ones you supply is designated the build layer and it's often wise to designate a special layer for that purpose. The results go into that layer's build or dynbuild directories depending on whether that layer is compiled or dynamic. (more)

Layers

About
Adding New Layers
Framework Layers

Adding New Layers

// layer extends baseLayer
foo extends bar {
   // ... layer properties here
   void init() { //... init code ...  }
   void start() { //... start code ...  }
}

You define a new layer by adding a new directory in the layer path, then creating a StrataCode layer definition file in that directory: directoryName.sc e.g. the layer foo is defined by the file: foo/foo.sc. The layer definition file is interpreted when the system starts and acts like the build script. Layers are initialized in two passes and can update and modify properties from previous layers in each pass. Unlike most build systems, you copy much less config into your project, you extend the layer and customize it only in framework layers or for special circumstances. (more)

Frameworks

Web
Android
JUnit
Jetty

Jetty

CServer {
   httpConnector {
      port = 8080;
   }
   handlerList {
      webAppHandler {
         contextPath = "/";
         war="./web";
      }
   }
}

Fully customizable Jetty deployment with StrataCode. (more)

Android

UnitConverter extends Activity {
   ...
   object unit1 extends LinearLayout {
      object unit1Label extends UnitLabel {
         textString := currentConverter.unit1;
      }
      object unit1Field extends UnitTextField {
         textString :=: 
            numberConverter.numberToString(currentConverter.value1);
      }
   }
   ...
}

Supports data binding for android framework classes, automatic project build and deploy (more)

JUnit

@Test void unitTest() {...}

Tag test methods with annotations, run all tests in a stack of layers.

Synchronization

About
Customizing
Debugging