On understanding types, data abstraction, and polymorphism
ACM Computing Surveys (CSUR) - The MIT Press scientific computation series
Information and Computation - Semantics of Data Types
Higher-order modules and the phase distinction
POPL '90 Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Soft typing with conditional types
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Compiling polymorphism using intensional type analysis
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Applicative functors and fully transparent higher-order modules
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A variable typed logic of effects
Information and Computation
Multi-stage programming with explicit annotations
PEPM '97 Proceedings of the 1997 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Program fragments, linking, and modularization
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Bounded existentials and minimal typing
Theoretical Computer Science
Units: cool modules for HOT languages
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Tempo: specializing systems applications and beyond
ACM Computing Surveys (CSUR) - Special issue: electronic supplement to the September 1998 issue
Dependent types in practical programming
Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Functional reactive programming from first principles
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
System architecture directions for networked sensors
ASPLOS IX Proceedings of the ninth international conference on Architectural support for programming languages and operating systems
A modal analysis of staged computation
Journal of the ACM (JACM)
Macros as multi-stage computations: type-safe, generative, binding macros in MacroML
Proceedings of the sixth ACM SIGPLAN international conference on Functional programming
Meta-programming with names and necessity
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
Tagless staged interpreters for typed languages
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Guarded recursive datatype constructors
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Distributed On-Demand Address Assignment in Wireless Sensor Networks
IEEE Transactions on Parallel and Distributed Systems
From Macros to Reusable Generative Programming
GCSE '99 Proceedings of the First International Symposium on Generative and Component-Based Software Engineering
Multi-Stage Programming: Axiomatization and Type Safety
ICALP '98 Proceedings of the 25th International Colloquium on Automata, Languages and Programming
An Idealized MetaML: Simpler, and More Expressive
ESOP '99 Proceedings of the 8th European Symposium on Programming Languages and Systems
Closed Types as a Simple Approach to Safe Imperative Multi-stage Programming
ICALP '00 Proceedings of the 27th International Colloquium on Automata, Languages and Programming
A versatile constraint-based type inference system
Nordic Journal of Computing
The nesC language: A holistic approach to networked embedded systems
PLDI '03 Proceedings of the ACM SIGPLAN 2003 conference on Programming language design and implementation
LFP '84 Proceedings of the 1984 ACM Symposium on LISP and functional programming
TAG: a Tiny AGgregation service for ad-hoc sensor networks
ACM SIGOPS Operating Systems Review - OSDI '02: Proceedings of the 5th symposium on Operating systems design and implementation
Meta-programming through typeful code representation
ICFP '03 Proceedings of the eighth ACM SIGPLAN international conference on Functional programming
A type system for well-founded recursion
Proceedings of the 31st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Journal of Functional Programming
Inlining as staged computation
Journal of Functional Programming
Intensional polymorphism in type-erasure semantics
Journal of Functional Programming
A methodology for generating verified combinatorial circuits
Proceedings of the 4th ACM international conference on Embedded software
A Symmetric Modal Lambda Calculus for Distributed Computing
LICS '04 Proceedings of the 19th Annual IEEE Symposium on Logic in Computer Science
Combining programming with theorem proving
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
A verified staged interpreter is a verified compiler
Proceedings of the 5th international conference on Generative programming and component engineering
Proceedings of the 5th international conference on Generative programming and component engineering
The regiment macroprogramming system
Proceedings of the 6th international conference on Information processing in sensor networks
Concoqtion: indexed types now!
Proceedings of the 2007 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
PEPM '08 Proceedings of the 2008 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Ynot: dependent types for imperative programs
Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
Flask: staged functional programming for sensor networks
Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
Shifting the stage: staging with delimited control
Proceedings of the 2009 ACM SIGPLAN workshop on Partial evaluation and program manipulation
Proceedings of the 2009 ACM SIGPLAN workshop on Partial evaluation and program manipulation
Type-specialized staged programming with process separation
Proceedings of the 2009 ACM SIGPLAN workshop on Generic programming
A Brief Overview of Agda --- A Functional Language with Dependent Types
TPHOLs '09 Proceedings of the 22nd International Conference on Theorem Proving in Higher Order Logics
A monadic multi-stage metalanguage
FOSSACS'03/ETAPS'03 Proceedings of the 6th International conference on Foundations of Software Science and Computation Structures and joint European conference on Theory and practice of software
Invited talk: resource-aware programming
ICESS'04 Proceedings of the First international conference on Embedded Software and Systems
Scalaness/nesT: type specialized staged programming for sensor networks
Proceedings of the 12th international conference on Generative programming: concepts & experiences
Hi-index | 0.00 |
Staging is a powerful language construct that allows a program at one stage of evaluation to manipulate and specialize a program to be executed at a later stage. We propose a new staged language calculus, 驴ML驴, which extends the programmability of staged languages in two directions. First, 驴ML驴 supports dynamic type specialization: types can be dynamically constructed, abstracted, and passed as arguments, while preserving decidable typechecking via a System F驴-style semantics combined with a restricted form of 驴 驴 -style runtime type construction. With dynamic type specialization the data structure layout of a program can be optimized via staging. Second, 驴ML驴 works in a context where different stages of computation are executed in different process spaces, a property we term staged process separation. Programs at different stages can directly communicate program data in 驴ML驴 via a built-in serialization discipline. The language 驴ML驴 is endowed with a metatheory including type preservation, type safety, and decidability as demonstrated constructively by a sound type checking algorithm. While our language design is general, we are particularly interested in future applications of staging in resource-constrained and embedded systems: these systems have limited space for code and data, as well as limited CPU time, and specializing code for the particular deployment at hand can improve efficiency in all of these dimensions. The combination of dynamic type specialization and staging across processes greatly increases the utility of staged programming in these domains. We illustrate this via wireless sensor network programming examples.