SuperGlue: Component Programming with Object-Oriented Signals

The assembly of components that can handle continuously changing data results in programs that are more interactive. Unfortunately, the code that glues together such components is often difficult to write because it is exposed to many complicated event-handling details. This paper introduces the SuperGlue language where components are assembled by connecting their signals, which declaratively represent state as time-varying values. To support the construction of interactive programs that require an unbounded number of signal connections, signals in SuperGlue are scaled with object-oriented abstractions. With SuperGlue's combination of signals and objects, programmers can build large interactive programs with substantially less glue code when compared to conventional approaches. For example, the SuperGlue implementation of an email client is around half the size of an equivalent Java implementation.

[1]  Peyman Oreizy,et al.  Reuse of off-the-shelf components in C2-style architectures , 1997, ICSE '97.

[2]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[3]  Gary T. Leavens,et al.  MultiJava: modular open classes and symmetric multiple dispatch for Java , 2000, OOPSLA '00.

[4]  Albert Benveniste,et al.  programmi language and its , 2001 .

[5]  David Notkin,et al.  Language Support for Connector Abstractions , 2003, ECOOP.

[6]  Craig S. Kaplan,et al.  Predicate Dispatching: A Unified Theory of Dispatch , 1998, ECOOP.

[7]  Todd D. Millstein,et al.  Practical predicate dispatch , 2004, OOPSLA.

[8]  Victor W. Marek.  Book review: The Art of Prolog Advanced Programming Techniques by L. Sterling and E. Shapiro (The MIT Press) , 1988, SGAR.

[9]  Leon Sterling,et al.  The Art of Prolog , 1987, IEEE Expert.

[10]  Antony Courtney,et al.  Frappé: Functional Reactive Programming in Java , 2001, PADL.

[11]  Ole Lehrmann Madsen,et al.  Virtual classes: a powerful mechanism in object-oriented programming , 1989, OOPSLA '89.

[12]  Leon Sterling,et al.  The Art of Prolog - Advanced Programming Techniques , 1986 .

[13]  Bjørn N. Freeman-Benson,et al.  Integrating Constraints with an Object-Oriented Language , 1992, ECOOP.

[14]  Fred L. Drake,et al.  The Python Language Reference Manual , 1999 .

[15]  Wilson C. Hsieh,et al.  Component programming with object-oriented signals , 2005 .

[16]  Gérard Berry,et al.  The foundations of Esterel , 2000, Proof, Language, and Interaction.

[17]  Nicolas Halbwachs,et al.  LUSTRE: A declarative language for programming synchronous systems* , 1987 .

[18]  Ralph E. Johnson,et al.  Design Patterns: Abstraction and Reuse of Object-Oriented Design , 1993, ECOOP.

[19]  Paul Hudak,et al.  Arrows, Robots, and Functional Reactive Programming , 2002, Advanced Functional Programming.

[20]  William R. Cook,et al.  Mixin-based inheritance , 1990, OOPSLA/ECOOP '90.

[21]  Ole Lehrmann Madsen,et al.  Virtual classes: a powerful mechanism in object-oriented programming , 1989, OOPSLA 1989.

[22]  Paul Hudak,et al.  Functional reactive animation , 1997, ICFP '97.

[23]  David Notkin,et al.  Architectural Reasoning in ArchJava , 2002, ECOOP.

[24]  Bjørn N. Freeman-Benson,et al.  Kaleidoscope: mixing objects, constraints, and imperative programming , 1990, OOPSLA/ECOOP '90.

[25]  Matthias Felleisen,et al.  Units: cool modules for HOT languages , 1998, PLDI.

[26]  David C. Luckham,et al.  An Event-Based Architecture Definition Language , 1995, IEEE Trans. Software Eng..

[27]  Naranker Dulay,et al.  Specifying Distributed Software Architectures , 1995, ESEC.

[28]  Nicolas Halbwachs,et al.  LUSTRE: a declarative language for real-time programming , 1987, POPL '87.

[29]  Shriram Krishnamurthi,et al.  Embedding Dynamic Dataflow in a Call-by-Value Language , 2006, ESOP.

[30]  Matthew Flatt,et al.  Jiazzi: new-age components for old-fasioned Java , 2001, OOPSLA '01.