Software Tools for Concurrent Programming

Date/Time:
Thursday 10 May 2012, 6.00pm - 8.00pm. Tea and coffee will be available from 5.30pm

Venue:
The Davidson Building, 5 Southampton Street, London WC2E 7HA. The nearest underground stations are Covent Garden and Charing Cross.

Speaker:
Peter Grogono

Summary:

The programmer’s traditional tools - compilers , debuggers, and test harnesses - are no longer adequate for the development of large and complex software systems. More advanced tools are emerging and will become increasingly important in the future. New and better tools are especially important for the development of concurrent and distributed programs. While developing Erasmus, a process-oriented programming language, we have encountered several areas in which novel approaches are needed.

First, systems consist of components. Each component has an implementation and an interface. The feasibility of connecting components should be decided on the basis of their interfaces rather than their implementations. Interfaces are an important part of object-oriented programming, where they define capabilities but do not specify either requirements or temporal sequences. An Erasmus interface specifies all three aspects of an interface: what the component provides, what it needs, and the sequences in which events may occur.

Second, theories of concurrency focus on symmetric relations between processes, such as bisimulation. Erasmus, however, is based on an asymmetric relation. When processes are connected, one is a server and the others are clients; the compiler must examine interfaces to ensure that each server can perform all of the tasks required by its clients. Thus an ordering of interfaces is required rather than an equivalence relation. The ordering must respect all three properties of the interface, as defined above.

Finally, properties of concurrent systems are often non-compositional: that subsystems possess a particular property is not a sufficient condition for the system as a whole to possess the property. Global analysis is required to check system properties and abstraction is required to achieve acceptable efficiency.

We are currently addressing these problems using two techniques: process algebra and abstract interpretation. Both techniques allow abstract models to be constructed automatically from source code. Process algebras were developed specifically for concurrency, but must be adapted to the special needs of Erasmus. Abstract interpretation has been applied to sequential programming and, to some extent, to shared-memory concurrent programming. We are developing new strategies for abstractly interpreting message-passing programs.

About the speaker:

Peter Grogono is a professor in the Department of Computer Science and Software Engineering at Concordia University in Montreal. Before joining the department in 1984, he worked in several areas of software development, including real-time systems, pattern recognition, electronic music, and accounting. In addition to concurrent programming, he is interested in evolutionary programming and in applications of software to the arts.

Admission:
Free, but to gain admission please email your name to our Membership Secretary, Algirdas Pakstas, at a.pakstas@londonmet.ac.uk

Slides:

View the slides for this event (PDF 2 Mb)