ORBIT: an optimizing compiler for scheme
SIGPLAN '86 Proceedings of the 1986 SIGPLAN symposium on Compiler construction
Continuation-passing, closure-passing style
POPL '89 Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Obtaining lazy evaluation with continuations in scheme
Information Processing Letters
Eiffel: the language
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Higher-Order and Symbolic Computation
Predicate Dispatching: A Unified Theory of Dispatch
ECCOP '98 Proceedings of the 12th European Conference on Object-Oriented Programming
First Class Messages as First Class Continuations
Proceedings of the First JSSST International Symposium on Object Technologies for Advanced Software
Domain-Driven Design: Tacking Complexity In the Heart of Software
Domain-Driven Design: Tacking Complexity In the Heart of Software
Proceedings of the 14th ACM SIGPLAN international conference on Functional programming
Proceedings of the 9th International Conference on Aspect-Oriented Software Development
An association-based model of dynamic behaviour
Proceedings of the 1st International Workshop on Free Composition
The keyword revolution: promoting language constructs for data access to first class citizens
Proceedings of the 1st International Workshop on Free Composition
Hi-index | 0.01 |
It is commonly agreed that decomposing a software design according to the structure of the problem domain makes it easier to maintain and manage its complexity (e.g. [9]). To retain the resulting decomposition in the implementation, a programming language is needed that supports composition mechanisms that match the compositions in the problem domain. However, current programming languages only offer a small, fixed set of composition mechanisms. This leads to compromised implementations that either do not follow the decomposition from the design, or are cluttered with additional glue code. In this paper, we discuss the composition of control flow and investigate the hypothesis that continuations may be a suitable atomic core principle for offering a wide range of control-flow composition mechanisms in a form that does not compromise the structure and maintainability of the application. We present four variants of exception handling, which have been implemented using continuations and discuss their differences and commonalities. The results of this comparison are encouraging with respect to the expressiveness of continuations and reusability of implementations. But they also show that current language support for continuations leads to code replication and complex code.