Components that process state, rather than immutable data, are important because they make programs more usable with their ability to process continuously changing data. For example, a compiler built out of state-processing components can detect programming errors as soon as programmers write them. Unfortunately, state-processing components are difﬁcult to assemble because existing languages depend on awkward event handling mechanisms to communicate changes in state. Because the encoding of event handling details is not very modular, glue code that assembles state-processing components is often excessively large.
This dissertation describes how state-processing components can be glued together with less code through time-varying values known as signals. Signals are state abstractions that hide event handling details from glue code by standardizing how state changes are communicated. We explore how signals can be used to assemble components in our language SuperGlue. Although signals have been explored in other languages, SuperGlue is unique in its use of simple wire-like connections to express component assemblies. To support components that process graph-like state, such as trees, SuperGlue has object-oriented abstractions that can be used to express an unbounded number of signal connections. With signals and objects, programmers can build complicated state-processing programs with reasonable amounts of glue code.
SuperGlue is a pragmatic language that supports the reuse of existing Java components. For example, SuperGlue code can reuse user-interface components in Java’s Swing library. We have found that SuperGlue is beneﬁcial in programs that involve signiﬁcant amounts of state processing, such as many user-interface programs. For example, the SuperGlue implementation of an email client is about half the size of an equivalent Java implementation.