StaBL - State Based Language for Specification of Web Applications

Context and motivation: Usage of Formal Specification languages is scarce in web application development as compared to safety critical/hardware systems. Question/problem: An apt formal specification language should provide the following features: Firstly, it should have well-defined semantics, so that specifications written in it can not be inherently ambiguous. Secondly, it should have tool support for automatic detection of specification bugs. Additionally, for domains like web development, it is important that specification formalisms build over familiar notations, as the benefits of learning highly mathematical notations in such domains are perceived to be low. Principal ideas/results: This work presents a State Based Language inspired by Statecharts called StaBL for specification of web applications, and how StaBL can be used for writing such specifications. We also present modifications to the language w.r.t Statechart which facilitate writing modular and scalable specification. Contribution: In particular, we present the feature of locally scoped variables with inter-state data-flow. We summarise our experience of developing specifications with StaBL, which shows that StaBL specifications, on the one hand, are able to capture most essential elements of the functional aspects of a web application while foregoing much of the verbosity of a regular programming language.

💡 Research Summary

The paper addresses the notable scarcity of formal specification languages in web application development, contrasting it with the widespread adoption of such languages in safety‑critical and hardware domains. The authors argue that the perceived mathematical complexity of traditional formal methods (e.g., Z, B, TLA+, Alloy) discourages their use in non‑critical software, where developers prefer familiar notations. To bridge this gap, they introduce StaBL (State Based Language), a domain‑specific formal language inspired by Statecharts but enriched with imperative programming constructs reminiscent of C and Python.

StaBL’s design rests on three pillars: (1) a rigorously defined semantics that eliminates ambiguity, (2) tool support for automatic detection of specification errors, and (3) a syntax that feels natural to software engineers, thereby reducing the learning curve. The language models a web application as a hierarchical state machine: each state corresponds to a page or view, and transitions represent navigation events. States can contain locally scoped variables; a hash‑prefix ( # ) marks input variables. Code can be placed in state entry/exit blocks or in transition actions, using familiar assignment and expression syntax.

A concrete example – a simple “Student” portal – illustrates the approach. Two top‑level states, LoggedOut and LoggedIn, capture the authentication flow. Local variables user and password reside in LoggedOut, while LoggedIn holds the logged‑in user ID. Transition t_login is triggered by an eLogin event, guarded by a comparison between the entered password and a stored map of students. Upon success, the action updates LoggedIn.loggedinUser. Nested substates SetRoom and ViewDetails under LoggedIn demonstrate how sub‑pages can be modeled, with transitions for setting a room, viewing details, and completing each task. The example also showcases generic containers (maps) and side‑effect‑free library functions (get_map, put_map) that return new immutable structures, facilitating static analysis.

The type system combines basic types (int, boolean, string) with parametric polymorphic containers (list, set, map) and user‑defined structures. Functions are first‑class, typed, and pure (no external side effects). Polymorphic types are expressed as type functions that accept type arguments, enabling reusable, type‑safe specifications. Although function definitions are not fully implemented in the current prototype, the language defines a set of library functions sufficient for symbolic simulation.

A distinctive contribution is StaBL’s scoping discipline. Variables are readable (R) and writable (W) according to precise predicates: within the state where they are declared (and all descendant states) they have RW access; on a transition, variables of the source state and its ancestors are readable, while those of the destination state and its ancestors are writable. This design eliminates the need for global variables while still allowing essential inter‑state data flow, such as propagating a user ID from a login page to a dashboard. The authors formalize these rules and integrate them into a static type‑checking phase, ensuring that illegal reads or writes are caught early.

Semantically, a StaBL specification is a tuple (S, T) of states and transitions, each equipped with entry/exit code, guards, and actions. The machine is always in a single leaf state together with its ancestors (a configuration). The paper provides formal definitions for ancestor/descendant relations, atomic states, and initial sub‑states, laying the groundwork for rigorous verification.

Related work is surveyed, noting that prior attempts to use Statecharts for web modeling focused on isolated concerns (navigation, service composition) and did not aim for a full‑featured, formally verified specification language. StaBL differentiates itself by marrying Statechart’s visual hierarchy with an imperative, type‑safe core, and by explicitly addressing scoping and data flow challenges unique to web applications.

In conclusion, the authors claim that StaBL enables concise yet expressive functional specifications of web applications, capturing essential behavior without the verbosity of general‑purpose programming languages. The prototype supports static analysis (type checking, scope validation) but lacks runtime simulation, code generation, and a graphical editor. Future work includes extending tool support, integrating with existing modeling environments, and exploring automated test case generation from specifications. Overall, StaBL represents a promising step toward bringing formal, verifiable specifications into mainstream web development.