A new approach to software engineering disentangles complexities in system design
Intrigued by the need to simplify the difficult and expensive process of software design, the LIBPR (Liberating programming) project observed that professionals are often able to describe the behaviour of their systems (before, during and after development), accurately and clearly, regardless of whether they have computer-programming skills. With this in mind, the team approached the problem by revisiting and radically transforming the accepted patterns of what a well-designed software system should look like. Based on the initial invention of scenario-based programming (SBP) and its visual, diagram-based language of live sequence charts (LSC), the team has shown how complex software can be aligned with the behavioural descriptions that appear in requirements documents and user manuals. Instead of the common design approach, in which intricate serial sequences of commands (programmes) have to be carefully designed to guide the system’s behaviour in a way that satisfies the requirements and constraints, in scenario-based programming the requirements themselves are fully executable, thus liberating programming from many of its conventional constraints. The requirements are encoded in a way that allows a computer to inspect each of them directly at every step of the execution, and determine its next step based on what they dictate that must, may or must not be done at that point (so forbidden behaviour becomes part of the programme). The requirements are thus turned into, and to a large extent replace, the traditional programme. In addition to offering revolutionary ways of structuring and then executing programmes, this approach enabled new, natural, ways of carrying out the very act of programming: on a simulator or GUI of the system the developer actually triggers (“plays in”) the actions that a user or the environment would present to the system, followed by the desired system reactions. The recorded behavioural sequence is then transformed automatically into the corresponding scenario. The alignment of the programme with how people think about the system also enables programming in (controlled) natural language. That is, subject to constraining grammar rules, a sentence like “when the user presses the red button, the light turns on”, is automatically parsed and translated into a formal executable programmed scenario. A collection of these sentences thus becomes the final system. A key benefit of the approach is the ability to code each new requirement incrementally, with little or no change to existing specifications, and use specialised tools to understand how the system will behave when all scenarios run together as a system. The project also yielded sophisticated algorithms and tools based on methods like model-checking, SMT solving and programme synthesis, for verifying correctness of scenario-based programmes, and for automatically repairing them when undesired behaviours or conflicting scenarios are found. This work also included compositional verification techniques, where the system is verified by essentially verifying its constituent scenarios. The scenario-based approach was broadened significantly by the team, over and above the visual LSC language, to include also implementations in standard computer languages, including Java, C, C++. C#, Erlang, and JavaScript. The applicability of SBP was demonstrated in a variety of applications – including industrial automation, automotive and aircraft control, and biological models.
