BEAP: An End-User Agile Programming Paradigm for Business Applications
3
Citation
11
Reference
10
Related Paper
Keywords:
Business process reengineering
Event-driven programming
Paradigm shift
Abstraction
This paper presents Biglook, a widget library for an extended version of the Scheme programming language. It uses classes of a Clos-like object layer to represent widgets and Scheme closures to handle graphical events. Combining functional and object-oriented programming styles yields an original application programming interface that advocates a strict separation between the implementation of the graphical interfaces and the user-associated commands, enabling compact source code. The Biglook implementation separates the Scheme programming interface and the native back-end. This permits different ports for Biglook. The current version uses GTK+ and Swing graphical toolkits, while the previous release used Tk.
Event-driven programming
Graphical user interface
Programming style
Interface (matter)
Functional reactive programming
Clos network
Cite
Citations (3)
Programming is generally considered to be a complicated and time-consuming task even for professionals. This comes mostly from the unfriendliness of the programming environment. One of the possible ways to overcome this problem is by the utilization of visual information in programming.In this paper, we first observe some trials toward realization of user-friendly programming, and then give an outline of an iconic programming environment, HI-VISUAL, which the authors are now developing.In HI-VISUAL, objects dealt with by the system, such as data and programs are represented in terms of icons. Programming is carried out simply by arranging icons on the display. The system displays intermediate results of execution in the course of program development so that the user can proceed program development interactively. In addition to this interaction facility for programming, program development based on the top-down approach is also provided for programming in the large. Details of the program modules can be left unspecified until they become clear in the lower level of module hierarchy.Some computer displayed pictures are given for ease of understanding interactions between the user and the system.
Event-driven programming
Visual programming language
Extensible programming
Realization (probability)
Functional reactive programming
Computer programming
Cite
Citations (20)
In event-driven programming we can react to an event by binding methods to it as handlers, but such a handler binding in current event systems is explicit and requires explicit reason about the graph of event propagation even for straightforward cases. On the other hand, the handler binding in reactive programming is implicit and constructed through signals. Recent approaches to support either event-driven programming or reactive programming show the need of using both the two styles in a program. We propose an extension to expand event systems to support reactive programming by enabling the automation of handler bindings. With such an extension programmers can use events to cover both the implicit style in reactive programming and the explicit style in event-driven programming. We first describe the essentials of reactive programming, signals and signal assignments, in terms of events, handlers, and bindings, then point out the lack of automation in existing event systems. Unlike most research activities we expand event systems to support signals rather than port signals to event systems. In this paper we also show a prototype implementation and translation examples to evaluate the concept of automation.
Event-driven programming
Functional reactive programming
Complex Event Processing
Programming by demonstration
Programming style
Cite
Citations (2)
The GEC Toolkit offers to programmers a high-level, generic style of programming Graphical User Interfaces (GUIs). Programmers are not concerned with low-level widget plumbing. Instead, they use mathematical data models that reflect both the application logic and the visualisation. The data models and the logic are expressed as standard functional style data types and functions over these data types. This significantly brings down the learning effort. In this paper we present an improved programming method of this toolkit and illustrate it by means of a complicated case study: that of a family tree editor. The new programming method brings GUI programming into the reach of every novice functional programmer.
Functional reactive programming
Event-driven programming
Programming style
Programmer
Graphical user interface
Cite
Citations (0)
Concurrency makes robot programming challenging even for professional programmers, yet it is essential for rich, interactive social robot behaviors. Visual programming aims to lower the barrier for robot programming but does not support rich concurrent behavior for meaningful robotics applications. In this paper, we explore extensions to block-based visual languages to enable programming of concurrent behavior with (1) asynchronous procedure calls, which encourage imperative programming, (2) callbacks, which encourage event-driven programming, and (3) promise, which also encourages imperative programming by providing event synchronization utilities. We compare these approaches through a systematic analysis of social robot programs with representative concurrency patterns, as well as a user study (N=23) in which participants authored such programs. Our work identifies characteristic differences between these approaches and demonstrates that the promise-based concurrency interface enables more concise programs with fewer errors.
Event-driven programming
Concurrent object-oriented programming
Visual programming language
Concurrent computing
Programming by demonstration
Cite
Citations (0)
In event-driven programming we can react to an event by binding methods to it as handlers, but such a handler binding in current event systems is explicit and requires explicit reason about the graph of event propagation even for straightforward cases. On the other hand, the handler binding in reactive programming is implicit and constructed through signals. Recent approaches to support either event-driven programming or reactive programming show the need of using both the two styles in a program. We propose an extension to expand event systems to support reactive programming by enabling the automation of handler bindings. With such an extension programmers can use events to cover both the implicit style in reactive programming and the explicit style in event-driven programming. We first describe the essentials of reactive programming, signals and signal assignments, in terms of events, handlers, and bindings, then point out the lack of automation in existing event systems. Unlike most research activities we expand event systems to support signals rather than port signals to event systems. In this paper we also show a prototype implementation and translation examples to evaluate the concept of automation. Furthermore, the comparison with the predicate pointcuts in aspect-oriented programming and the details of the experimental compiler are discussed.
Event-driven programming
Functional reactive programming
Complex Event Processing
Programming style
Predicate (mathematical logic)
Cite
Citations (2)
From the Publisher:
A Small Matter of Programming asks why it has been so difficult for end users to command programming power and explores the problems of end-user-driven application development that must be solved to afford end users greater computational power. Drawing on empirical research on existing end user systems, the book analyzes cognitive, social, and technical issues of end user programming. In particular, it examines the importance of task-specific programming languages, visual application frameworks, and collaborative work practices for end user computing with the goal of helping the designers and programmers understand and better satisfy the needs of end users who want the capability to create, customize, and extend their applications software. The ideas in the book are based on the author's research on two successful end user programming systems - spreadsheets and CAD systems - as well as other empirical research. Nardi concentrates on broad issues in end user programming, especially end users' strengths and problems, introducing tools and techniques as they are related to higher-level user issues.
End-user computing
Cite
Citations (616)
A Small Matter of Programming asks why it has been so difficult for end users to command programming power and explores the problems of end user-driven application development that must be solved to afford end users greater computational power. Drawing on empirical research on existing end user systems, A Small Matter of Programming analyzes cognitive, social, and technical issues of end user programming. In particular, it examines the importance of task-specific programming languages, visual application frameworks, and collaborative work practices for end user computing, with the goal of helping designers and programmers understand and better satisfy the needs of end users who want the capability to create, customize, and extend their applications software. The ideas in the book are based on the author's research on two successful end user programming systems - spreadsheets and CAD systems - as well as other empirical research. Nardi concentrates on broad issues in end user programming, especially end users' strengths and problems, introducing tools and techniques as they are related to higher-level user issues. Bonnie A. Nardi is a Member of the Technical Staff at Hewlett Packard Laboratories.
Event-driven programming
User story
Cite
Citations (399)
The paper describes a way of extending the flexibility of example-based programming. The purpose of introducing such a programming style is to provide the user with a way of telling the system why and how he operates on it. This ability is achieved by introducing three mechanisms for target object specification, goal-driven execution, and parameter transfer by means of a clipboard. In the system, the user can specify the relationship between the application status, the target object, and the user operation. A flexible programming capability can be provided as a monitoring function for system support. Consequently, the user can apply the programming-by-example facility to any applications implemented on top of this system.< >
Functional reactive programming
Abstraction
Programming style
Event-driven programming
Cite
Citations (2)
Programmer
Event-driven programming
Computer programming
Cite
Citations (4)