Guy Wiener

A decentralized approach for programming interactive applications with JavaScript and blockly

We present a decentralized-control methodology and a tool-set for developing interactive user interfaces. We focus on the common case of developing the client side of Web applications. Our approach is to combine visual programming using Google Blockly with a single-threaded implementation of behavioral programming in JavaScript. We show how the behavioral programming principles can be implemented with minimal programming resources, i.e., with a single-threaded environment using coroutines. We give initial, yet full, examples of how behavioral programming is instrumental in addressing common issues in this application domain, e.g., that it facilitates separation of graphical representation from logic and handling of complex inter-object scenarios. The implementation in JavaScript and Blockly (separately and together) expands the availability of behavioral programming capabilities, previously implemented in LSC, Java, Erlang and C++, to audiences with different skill-sets and design approaches.

Behavioral programming, decentralized control, and multiple time scales

Behavioral programming is a recently proposed approach for non-intrusive incremental software development. We propose that behavioral programming concepts, such as behavioral decomposition, synchronized execution of independent behaviors, and event blocking, can help in the incremental and natural coding of complex decentralized systems, complementing actor-oriented and agent-oriented approaches. We also contribute to the existing research on behavioral programming a method for coordinating behaviorally-programmed components which, due to different time scales or interaction with the external environment, cannot synchronize and thus cannot employ event blocking. We show that the resulting decentralized system retains many of the advantages present in a purely behavioral, fully synchronized system.

Coordinating and visualizing independent behaviors in erlang

Behavioral programming, introduced by the LSC language and extended by the BPJ Java library, enables development of behaviors as independent modules that are relatively oblivious of each other, yet are integrated at run-time yielding cohesive system behavior. In this paper we present a proof-of-concept for infrastructure and a design pattern that enable development of such behavioral programs in Erlang. Each behavior scenario, called a behavior thread, or b-thread, runs in its own Erlang process. Runs of programs are sequences of events that result from three kinds of b-thread actions: requesting that events be considered for triggering, waiting for triggered events, and blocking events that may be requested by other b-threads. A central mechanism handles these requests, and coordinates b-thread execution, yielding composite, integrated system behavior. We also introduce a visualization tool for Erlang programs written in the proposed design pattern. We believe that enabling the modular incremental development of behavioral programming in Erlang could further simplify the development and maintenance of applications consisting of concurrent independent behaviors.

A use-case for behavioral programming

We combine visual programming using Google Blockly with a single-threaded implementation of behavioral programming (BP) in JavaScript, and propose design patterns for developing reactive systems such as client-side Web applications and smartphone customization applications as collections of independent cross-cutting scenarios that are interwoven at run time. We show that BP principles can be instrumental in addressing common software engineering issues such as separation of graphical representation from logic and the handling of inter-object scenarios. We also show that a BP infrastructure can be implemented with limited run-time resources in a single-threaded environment using coroutines. In addition to expanding the availability of BP capabilities, we hope that this work will contribute to the evolving directions of technologies and design patterns in developing interactive applications. We present an approach for Behavioral Programming (BP) in JavaScript (JS) and Blockly.The approach allows for intuitive incremental development of reactive applications.We propose design patterns for interfacing with external environments from BP in JS.We demonstrate BP programs in Blockly and in JS for interactive client side applications.We introduce a small tool for smartphone customization based on interwoven scenarios.

A declarative approach for software modeling

In this paper we describe a method for encoding software models as Prolog programs, and how to use these programs to support incremental development. Requirements, alternative designs, and implementation patterns are encoded as predicates in the program, and define a search routine, the solutions of which are possible implementations of the requirements. Under default operation, this routine validates that a given parsed code is compatible with one of these solutions. Additionally, the same search routine can be executed by special interpreters that provide traceability and code generation as well. Code generation may be complete or partial, allowing the user to combine hand-written and generated code. By customizing the interpreter, the user can generate an outline of the design or a tasks list, instead of code. We demonstrate these techniques using Java and SQL, but our approach is applicable to other programming languages and paradigms as well.

Round-Trip Modeling Using OPM/PL

In this work we present OPM/PL, a suite of modeling tools based on the Object-Process Methodology (OPM) and implemented in Prolog. OPM/PL includes tools for model authoring, querying and visualization, as well as code parsing and code generation. OPM/PL aims at integrating the information from the source code, models and requirements of a software project into a single database with a uniform format. This approach extends the role of a modeling tool to include a representation of the code and its relations to the model. The OPM/PL database contains both model elements and information from code parsing. This combined representation allows developers to flesh out a model from existing code, and update the code according changes in the model. Thus, OPM/PL provides a system for round-trip modeling.