Objects have been a great success. They have improved software development by allowing us to cleanly encapsulate units of functionality of various scales -- from simple data structures to GUI tools to network servers.
But objects don't seem to help as much in dealing with systemic concerns such as synchronization, network usage, memory management, replication and the like. Trying to localize synchronization issues inside of an object just doesn't seem to work as well as trying to localize UI functionality inside of an object. Much of the complexity and brittleness in existing systems appears to stem from the way in which the programming of these issues is intertwined throughout the code.
We have invented a new unit of software modularity, called an aspect, that appears to provide a better handle on managing such systemic issues.
Aspects are intended to be used in both design and implementation. During design they make it possible to better localize systemic design issues. During implementation, aspect-oriented programming languages make it possible to program directly in terms of aspects, just as object-oriented languages have made it possible to program directly in terms of objects in the design.
This talk will present the idea of aspects, aspect-oriented programming, the kinds of systems the technology appears to be best suited for, and some of what it will take to get us there.
Gregor Kiczales is a principal scientist at the Xerox Palo Alto Research Center. His research interests are in software architecture, programming languages, and software engineering.
His work includes object-oriented programming language design and implementation -- he was one of the designers of the Common Lisp Object system (CLOS), and was the implementor of PCL, a high-performance portable implementation of CLOS. He designed the CLOS metaobject protocol, and authored, together with Jim des Rivieres and Danny Bobrow, ``The Art of the Metaobject Protocol,'' a key work in the development of metaobject protocol and reflection technology. Subsequently, he developed the concept of open implementation, a set of engineering principles to guide the design of modules that expose key aspects of their implementation to client control. Most recently he has been focusing on aspect-oriented programming, which is intended to provide an effective way of handling systems in which there are issues of importance that are not easy (or even possible) to localize to a single module.