Event-driven programming

Encyclopedia : E : EV : EVE : Event-driven programming

Event-driven programming is a computer programming paradigm. Unlike traditional programs, which follow their own control flow pattern, only sometimes changing course at branch points, the control flow of event-driven programs is largely driven by external events.

Contents

1 Overview
2 Example
3 References
4 See also
5 Event-driven frameworks and libraries
6 External links

Overview

Instead of waiting for a complete command which may order it to process information, the system is preprogrammed with an event loop, to look repeatedly for information to process (whether this might be the appearance of a file in a folder, a keyboard or mouse operation, or a timer event) and then perform a trigger function to process it. Programming an event driven system is thus a matter of rewriting the default trigger functions of the system, to match the required behavior.

The method by which information on events is acquired by the underlying system is immaterial. Inputs can be polled in the event loop, or interrupt handlers can be registered to react to hardware events; many systems use a mixture of both techniques. The preprogrammed algorithm ensures that triggers provided are executed when they are needed, thus providing a software abstraction that emulates an interrupt driven environment.

Event-driven programs typically consist of a number of small programs called event handlers, which are to be called in response to external events, and a dispatcher, which calls the event handlers, often using an event queue to hold unprocessed events.

In many cases event handlers can trigger events themselves, possibly leading to an event cascade.

Event-driven programming stresses flexibility and asynchrony as virtues, and tries to be as modeless as possible. Graphical user interface programs are typically programmed in an event-driven style.

Computer operating systems are another classic example of event-driven programs on at least two levels. At the lowest level, interrupt handlers act as direct event handlers for hardware events, with the CPU hardware performing the role of the dispatcher. Operating systems also typically act as dispatchers for software processes, passing data and software interrupts to user processes that in many cases are programmed as event handlers themselves.

A command line interface can be viewed as a special case of the event driven model in which the system, which is inactive, awaits one very complex event--the entry of a command by the user.

Coroutine libraries can be used to provide thread-like notation around a traditional event loop core. Ruby is a popular scripting language that takes this approach. Ruby threads are simple coroutines scheduled around an event loop. Libtask [link] provides a similar facility for C.

Event-driven programming is a flexible way to allow your programs to respond to many different inputs or events.

Example

This example uses pseudocode to illustrate how data is read from a socket using an event driven approach:

function read_next_data(fd)
data = read_async( fd )
if len(data) == 0
=> Nothing to read, register to be called back when something is ready
event_polling_register( fd, read_next_data )
=> Go back to doing something else
else
=> Data was available and len(data) was received
add_data_to_buffer( buffer, data )
fi

This example uses Tcl code to illustrate how data is read from a socket using an event driven approach:

# open channel set chan [socket $host $port] set buffer "" fconfigure $chan -blocking none # register event handler fileevent $chan readable [list read_next_data $chan buffer]

# process event until end of file proc read_next_data }

Event-driven programming is a flexible way to allow your programs to respond to many different inputs or events.

References

Grant Palmer: Java Event Handling, Prentice Hall, ISBN 0-13-041802-1
David Luckham: The Power of Events - An Introduction to Complex Event Processing in Distributed Enterprise Systems, Addison-Wesley, ISBN 0-201-72789-7
George S. Fishman: Discrete-Event Simulation - Modeling, Programming, and Analysis, Springer, ISBN 0-387-95160-1
Miro Samek: Practical Statecharts in C/C++: Quantum Programming for Embedded Systems, CMP Books, ISBN 1-57820-110-1

Event-driven frameworks and libraries

Liboop, event loop management library
libsigc++, a callback framework for C++
libevent, an event notification library for C/C++
REBECA, Event-Based Electronic Commerce Architecture
Tcl, Tcl language has event driven programming built in
Twisted, Python
POE, Perl
PRADO, a component-based and event-driven Web programming framework for PHP 5
Gui4Cli, an event driven programming language for Windows

External links

[Description] from Portland Pattern Repository
Tutorial "[Event-Driven Programming: Introduction, Tutorial, History]" by Stephen Ferg
Tutorial "[Event Driven Programming]" by Alan Gauld
Article "[Transitioning from Structured to Event-Driven Programming]" by Ben Watson
Article "[Rethinking Swing Threading]" by Jonathan Simon
Article "[The event driven programming style]" by Chris McDonald
Article "[Event Driven Programming using Template Specialization]" by Christopher Diggins
Article "[Delegates and Event Handling in C#]" by Faisal Jawaid
Article "[Concepts and Architecture of Vista - a Multiparadigm Programming Environment]" by Stefan Schiffer and Joachim Hans Fröhlich
Chapter "[Event-driven programming vs. multi-threaded programming]" from the Equeue user's guide by Gerd Stolpmann
Chapter "[Event-Driven Programming and Agents]"
[LabWindows/CVI Resources]
[Comment] by Tim Boudreau
[Citations from CiteSeer]