Results 1 - 10
of
22
Engines from Continuations
- Computer Languages
, 1989
"... Engines provide the means for a computation to be run for a limited period of time, interrupted if it does not complete in that time, and later restarted from the point of interruption. Previous work on engines demonstrated that engines can be implemented by defining a new interpreter to support the ..."
Abstract
-
Cited by 24 (5 self)
- Add to MetaCart
Engines provide the means for a computation to be run for a limited period of time, interrupted if it does not complete in that time, and later restarted from the point of interruption. Previous work on engines demonstrated that engines can be implemented by defining a new interpreter to support them. This article demonstrates that engines may be defined in terms of continuations and timer interrupts and thereby incorporated into an existing language implementation. The article extends the engine mechanism to solve several problems with nestable engines, and demonstrates that the extended mechanism can be implemented in terms of continuations as well.
Space-efficient gradual typing
- In Trends in Functional Programming (TFP
, 2007
"... Gradual type systems offer a smooth continuum between static and dynamic typing by permitting the free mixture of typed and untyped code. The runtime systems for these languages–and other languages with hybrid type checking–typically enforce function types by dynamically generating function proxies. ..."
Abstract
-
Cited by 19 (3 self)
- Add to MetaCart
Gradual type systems offer a smooth continuum between static and dynamic typing by permitting the free mixture of typed and untyped code. The runtime systems for these languages–and other languages with hybrid type checking–typically enforce function types by dynamically generating function proxies. This approach can result in unbounded growth in the number of proxies, however, which drastically impacts space efficiency and destroys tail recursion. We present an implementation strategy for gradual typing that is based on coercions instead of function proxies, and which combines adjacent coercions to limit their space consumption. We prove bounds on the space consumed by coercions as well as soundness of the type system, demonstrating that programmers can safely mix typing disciplines without incurring unreasonable overheads. Our approach also detects certain errors earlier than prior work. 1 GRADUAL TYPING FOR SOFTWARE EVOLUTION Dynamically typed languages have always excelled at exploratory programming.
Workflow Enactment with Continuation and Future Objects
, 2002
"... An increasing number of software developers are turning to workflow to separate the logic and the control aspects in their applications, thus making them more amenable to change. However, in spite of recent efforts to standardize and provide reusable workflow components, many developers build their ..."
Abstract
-
Cited by 16 (0 self)
- Add to MetaCart
An increasing number of software developers are turning to workflow to separate the logic and the control aspects in their applications, thus making them more amenable to change. However, in spite of recent efforts to standardize and provide reusable workflow components, many developers build their own. This is a challenging endeavor and involves solving problems which seem incompatible with the object paradigm and current object-oriented programming languages. In the context of an object-oriented workflow framework, this paper demonstrates a novel approach that resolves this impedance mismatch with techniques drawn from programming language theory. This successful cross-pollination narrows the gap between the results of decades of research in programming languages and developers working hard to cope with change.
From Reduction-Based to Reduction-Free Normalization
, 2004
"... We present a systematic construction of a reduction-free normalization function. Starting from ..."
Abstract
-
Cited by 10 (7 self)
- Add to MetaCart
We present a systematic construction of a reduction-free normalization function. Starting from
Status report: specifying JavaScript with ML
- In ML ’07: Proceedings of the 2007 workshop on Workshop on ML
, 2007
"... The Ecma TC39-TG1 working group is using ML as the specification language for the next generation of JavaScript, the popular programming language for browser-based web applications. This “definitional interpreter ” serves many purposes: a high-level and readable specification language, an executable ..."
Abstract
-
Cited by 7 (0 self)
- Add to MetaCart
The Ecma TC39-TG1 working group is using ML as the specification language for the next generation of JavaScript, the popular programming language for browser-based web applications. This “definitional interpreter ” serves many purposes: a high-level and readable specification language, an executable and testable specification, a reference implementation, and an aid in driving the design process. We describe the design and specification of JavaScript and our experience so far using Standard ML for this purpose. Categories and Subject Descriptors D.2.1 [Software Engineering]: Requirements/Specifications—Languages; D.3.1 [Programming
The Essence of Multitasking
- Proceedings of the 11th International Conference on Algebraic Methodology and Software Technology, volume 4019 of Lecture Notes in Computer Science
, 2006
"... Abstract. This article demonstrates how a powerful and expressive abstraction from concurrency theory—monads of resumptions—plays a dual rôle as a programming tool for concurrent applications. The article demonstrates how a wide variety of typical OS behaviors may be specified in terms of resumption ..."
Abstract
-
Cited by 6 (3 self)
- Add to MetaCart
Abstract. This article demonstrates how a powerful and expressive abstraction from concurrency theory—monads of resumptions—plays a dual rôle as a programming tool for concurrent applications. The article demonstrates how a wide variety of typical OS behaviors may be specified in terms of resumption monads known heretofore exclusively in the literature of programming language semantics. We illustrate the expressiveness of the resumption monad with the construction of an exemplary multitasking kernel in the pure functional language Haskell. 1
Refocusing in Reduction Semantics
, 2004
"... The evaluation function of a reduction semantics (i.e., a small-step operational semantics with an explicit representation of the reduction context) is canonically defined as the transitive closure of (1) decomposing a term into a reduction context and a redex, (2) contracting this redex, and (3) ..."
Abstract
-
Cited by 6 (3 self)
- Add to MetaCart
The evaluation function of a reduction semantics (i.e., a small-step operational semantics with an explicit representation of the reduction context) is canonically defined as the transitive closure of (1) decomposing a term into a reduction context and a redex, (2) contracting this redex, and (3) plugging the contractum in the context. Directly implementing this evaluation function therefore yields an interpreter with a worst-case overhead, for each step, that is linear in the size of the input term. We present
Tasks: Language Support for Event-driven Programming
"... ABSTRACT The event-driven programming style is pervasive as an efficient method for interacting with the environment. Unfortunately, the event-driven style severely complicates program maintenance and understanding, as it requires each logical flow of control to be fragmented across multiple indepen ..."
Abstract
-
Cited by 6 (2 self)
- Add to MetaCart
ABSTRACT The event-driven programming style is pervasive as an efficient method for interacting with the environment. Unfortunately, the event-driven style severely complicates program maintenance and understanding, as it requires each logical flow of control to be fragmented across multiple independent callbacks. We propose tasks as a new programming model for organizing event-driven programs. Tasks are a variant of cooperative multi-threading and allow each logical control flow to be modularized in the traditional manner, including usage of standard control mechanisms like procedures and exceptions. At the same time, by using method annotations, task-based programs can be automatically and modularly translated into efficient event-based code, using a form of continuation passing style (CPS) translation. A linkable scheduler architecture permits tasks to be used in many different contexts. We have instantiated our model as a backward-compatible extension to Java, called TaskJava. We illustrate the benefits of our language through a formalization in an extension to Featherweight Java, and through a case study based on an open-source web server. 1.

