Section: Research Program
Design-Driven Software Development
Raising the level of abstraction beyond programming is a very active research topic involving a range of areas, including software engineering, programming languages and formal verification. The challenge is to allow design dimensions of a software system, both functional and non-functional, to be expressed in a high-level way, instead of being encoded with a programming language. Such design dimensions can then be leveraged to verify conformance properties and to generate programming support.
Our research on this topic is to take up this challenge with an approach inspired by programming languages, introducing a full-fledged language for designing software systems and processing design descriptions both for verification and code generation purposes. Our approach is also DSL-inspired in that it defines a conceptual framework to guide software development. Lastly, to make our approach practical to software developers, we introduce a methodology and a suite of tools covering the development life-cycle.
To raise the level of abstraction beyond programming, the key approaches are model-driven engineering and architecture description languages. A number of architecture description languages have been proposed; they are either (1) coupled with a programming language (e.g., ), providing some level of abstraction above programming, or (2) integrated into a programming language (e.g., , ), mixing levels of abstraction. Furthermore, these approaches poorly leverage architecture descriptions to support programming, they are crudely integrated into existing development environments, or they are solely used for verification purposes. Model-driven software development is another actively researched area. This approach often lacks code generation and verification support. Finally, most (if not all) approaches related to our research goal are general purpose; their universal nature provides little, if any, guidance to design a software system. This situation is a major impediment to both reasoning about a design artifact and generating programming support.