First Steps Towards a Wise Development Environment for Behavioral Models

First Steps Towards a Wise Development Environment for Behavioral Models

David Harel (Department of Computer Science and Applied Mathematics, Weizmann Institute of Science, Rehovot, Israel), Guy Katz (Computer Science Department, Stanford University, Stanford, CA, USA), Rami Marelly (Department of Computer Science and Applied Mathematics, Weizmann Institute of Science, Rehovot, Israel) and Assaf Marron (Department of Computer Science and Applied Mathematics, Weizmann Institute of Science, Rehovot, Israel)
Copyright: © 2016 |Pages: 22
DOI: 10.4018/IJISMD.2016070101

Abstract

The authors present an initial wise development framework: a development environment that proactively and interactively assists the software engineer in modeling complex reactive systems. Their framework repeatedly analyzes models of the system under development at various levels of abstraction, and then reasons about these models in order to detect possible errors, to derive emergent properties of interest, and to assist in system testing and debugging. Upon request, the environment can instrument the system model in order to monitor or test the execution for certain behaviors, or even augment it in order to repair or avoid detected behavior that is undesired. The direction and prioritization of the analysis and related tasks is based on the relevance of the observed properties and the expected impact of actions to be taken, and is performed by specialized automated and human-assisted techniques that have been incorporated into the framework. The authors' development environment is an initial step in the direction of their recent Wise Computing vision, which calls for turning the computer (namely, the development environment) into an equal member of the development team: knowledgeable, independent, concerned and proactively involved in the development process. They have implemented their tool within the context of behavioral programming (BP) – a scenario-based modeling approach, in which components are aligned with how humans often describe desired system behavior. The authors' work thus further enhances the naturalness and incrementality of developing in BP.
Article Preview

1. Introduction

The development of large reactive software systems is an expensive and error-prone undertaking. Deliverables will often fail, resulting in unintended software behavior, exceeded budgets and breached time schedules. One of the key reasons for this difficulty is the growing complexity of many kinds of reactive systems, which increasingly prevents the human mind from managing a comprehensive picture of all their relevant elements and behaviors. Moreover, of course, the state-explosion problem typically prevents us from exhaustively analyzing all possible software behaviors. While major advances in modeling tools and methodologies have greatly improved our ability to develop reactive systems by allowing us to reason on abstract models thereof, specific solutions are quickly reaching their limits, and resolving the great difficulties in developing reliable reactive systems remains a major, and critical, moving target.

Over the years it has been proposed, in various contexts, e.g., (Cerf, 2014; Harel, Katz, Marelly, & Marron, 2015; Reubenstein & Waters, 1991; Rich & Waters, 1988), that a possible strategy for mitigating these difficulties could lay in changing the role of the computer in the development process. Instead of having the computer serve as a tool, used only to analyze or check specific aspects of the code as instructed by the developer, one could seek to actually transform it into a member of the development team — a proactive participant, analyzing the entire system and making informed observations and suggestions. This way, the idea goes, the computer’s superior capabilities of handling large amounts of code could be manifested. Combined with human insight and understanding of the system’s goals, this synergy could produce more reliable and error-free systems.

In this paper we follow this spirit, and present a methodology and an interactive framework for the modeling and development of complex reactive systems, in which the computer plays a proactive role. Following the terminology of (Harel, Katz, Marelly, & Marron, 2015), and constituting a very modest initial effort along the lines of the Wise Computing vision outlined there, we term this framework a wise framework. Intuitively, a truly wise framework should provide the developer with an interactive companion for all phases of system development, “understand” the system, draw attention to potential errors and suggest improvements and generalizations; and this should be done via two-way communication with the developer, which will be very high-level, using natural (perhaps natural-language-based) interfaces. The framework presented here is but a first step in that direction, and focuses solely on providing an interactive development assistant capable of discovering interesting properties and drawing attention to potential bugs; still, it can already handle non-trivial programs, as we later demonstrate through a case-study.

Various parts of this approach have been implemented by a variety of researchers in other forms, as described in the Related Work section. A main novel aspect of our approach, however, is in the coupling of the notion of a proactive and interactive framework with a modeling language called behavioral programming (Harel, Marron, & Weiss, 2012) — a scenario-based language, in which systems are modeled as sets of independent scenarios that are interleaved at runtime. This formalism makes it possible for our interactive development framework to repeatedly and quickly construct abstract executable models of the program, and then analyze them in order to reach meaningful conclusions. It is now widely accepted that a key aspect in the viability of analysis tools and environments is that they are sufficiently lightweight to be integrated into the developer’s workflow without significantly slowing it down (Cristiano et al., 2015; Sadowski, Gogh, Jaspan, Söederberg, & Winter, 2015). We attempt to achieve this by leveraging scenario-based modeling. As demonstrated in later sections, the proactiveness of our approach and its tight integration into the development cycle can lead to early detection of bugs during development, when they are still relatively easy and cheap to fix.

Complete Article List

Search this Journal:
Reset
Open Access Articles: Forthcoming
Volume 10: 4 Issues (2019): Forthcoming, Available for Pre-Order
Volume 9: 4 Issues (2018): 1 Released, 3 Forthcoming
Volume 8: 4 Issues (2017)
Volume 7: 4 Issues (2016)
Volume 6: 4 Issues (2015)
Volume 5: 4 Issues (2014)
Volume 4: 4 Issues (2013)
Volume 3: 4 Issues (2012)
Volume 2: 4 Issues (2011)
Volume 1: 4 Issues (2010)
View Complete Journal Contents Listing