Article

Interlanguage migration: from scripts to programs

Authors:

Sam Tobin-Hochstadt,

Matthias FelleisenAuthors Info & Claims

OOPSLA '06: Companion to the 21st ACM SIGPLAN symposium on Object-oriented programming systems, languages, and applications

Pages 964 - 974

https://doi.org/10.1145/1176617.1176755

Published: 22 October 2006 Publication History

Abstract

As scripts grow into full-fledged applications, programmers should want to port portions of their programs from scripting languages to languages with sound and rich type systems. This form of interlanguage migration ensures type-safety and provides minimal guarantees for reuse in other applications, too.In this paper, we present a framework for expressing this form of interlanguage migration. Given a program that consists of modules in the untyped lambda calculus, we prove that rewriting one of them in a simply typed lambda calculus produces an equivalent program and adds the expected amount of type safety, i.e., code in typed modules can't go wrong. To ensure these guarantees, the migration process infers constraints from the statically typed module and imposes them on the dynamically typed modules in the form of behavioral contracts.

References

[1]

Martin Abadi, Luca Cardelli, Benjamin Pierce, and Gordon Plotkin. Dynamic typing in a statically typed language. ACM Trans. Program. Lang. Syst., 13(2):237--268, 1991.

Digital Library

[2]

Alexander Aiken, Edward L. Wimmers, and T. K. Lakshman. Soft typing with conditional types. In POPL '94: Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages, pages 163--173, New York, NY, USA, 1994. ACM Press.

Digital Library

[3]

Ken Anderson, Timothy Hickey, and Peter Norvig. JScheme user manual, 2002. http://jscheme.sf.net.

[4]

Arthur I. Baars and S. Doaitse Swierstra. Typing dynamic typing. In ICFP '02: Proceedings of the seventh ACM SIGPLAN international conference on Functional programming, pages 157--166, New York, NY, USA, 2002. ACM Press.

Digital Library

[5]

Kent Beck. Test Driven Development: By Example. Addison-Wesley Professional, November 2002.

Digital Library

[6]

Gilad Bracha. Pluggable type systems. In Revival of Dynamic Languages workshop at OOPSLA 2004, October 2004.

[7]

Gilad Bracha and David Griswold. Strongtalk: typechecking smalltalk in a production environment. In OOPSLA '93: Proceedings of the eighth annual conference on Object-oriented programming systems, languages, and applications, pages 215--230, New York, NY, USA, 1993. ACM Press.

Digital Library

[8]

Frederick P. Brooks Jr. The Mythical Man-Month. Addison Wesley, 1995. Anniversary Edition.

Digital Library

[9]

Robert Cartwright and Mike Fagan. Soft typing. In PLDI '91: Proceedings of the ACM SIGPLAN 1991 Conference on Programming Language Design and Implementation, pages 278--292, New York, NY, USA, 1991. ACM Press.

Digital Library

[10]

William D. Clinger. Common Larceny. In International Lisp Conference, pages 101--107, June 2005. Invited paper.

[11]

Robert Bruce Findler and Matthias Felleisen. Contracts for higher-order functions. In ICFP '02: Proceedings of the Seventh ACM SIGPLAN International Conference on Functional Programming, pages 48--59, New York, NY, USA, 2002. ACM Press.

Digital Library

[12]

Cormac Flanagan and Matthias Felleisen. Componential set-based analysis. ACM Trans. Program. Lang. Syst., 21(2):370--416, 1999.

Digital Library

[13]

Kathryn E. Gray, Robert Bruce Findler, and Matthew Flatt. Fine-grained interoperability through mirrors and contracts. In OOPSLA '05: Proceedings of the 20th annual ACM SIGPLAN conference on Object Oriented Programming, Systems, Languages, and Applications, pages 231--245, New York, NY, USA, 2005. ACM Press.

Digital Library

[14]

Groovy, 2004--2006. http://groovy.codehaus.org.

[15]

Fritz Henglein and Jakob Rehof. Safe polymorphic type inference for a dynamically typed language: translating Scheme to ML. In FPCA '95: Proceedings of the seventh international conference on Functional programming languages and computer architecture, pages 192--203, New York, NY, USA, 1995. ACM Press.

Digital Library

[16]

Jim Hugunin. IronPython, 2003--2006. http://www.ironpython.com.

[17]

Jython, 2003--2006. http://www.jython.com.

[18]

Xavier Leroy and Michel Mauny. Dynamics in ML. In Proceedings of the 5th ACM Conference on Functional Programming Languages and Computer Architecture, pages 406--426, London, UK, 1991. Springer-Verlag.

Digital Library

[19]

Vassily Litvinov. Contraint-based polymorphism in Cecil: towards a practical and static type system. In OOPSLA '98: Proceedings of the 13th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications, pages 388--411, New York, NY, USA, 1998. ACM Press.

Digital Library

[20]

Robert A. MacLachlan. The Python compiler for CMU Common Lisp. In LFP '92: Proceedings of the 1992 ACM conference on LISP and functional programming, pages 235--246, New York, NY, USA, 1992. ACM Press.

Digital Library

[21]

Simon Marlow and Philip Wadler. A practical subtyping system for Erlang. In ICFP '97: Proceedings of the second ACM SIGPLAN international conference on Functional programming, pages 136--149, New York, NY, USA, 1997. ACM Press.

Digital Library

[22]

Jacob Matthews and Robert Bruce Findler. The Meaning of Multi-Language Programs, 2006. Unpublished manuscript.

[23]

Philippe Meunier, Robert Bruce Findler, and Matthias Felleisen. Modular set-based analysis from contracts. In POPL '06: Conference Record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of Programming Languages, pages 218--231, New York, NY, USA, 2006. ACM Press.

Digital Library

[24]

Robin Milner. A theory of type polymorphism in programming. Journal of Computer Systems Science, 17:348--375, 1978.

[25]

Manuel Serrano. Bigloo: A practical Scheme compiler, 1992--2002.

[26]

Jeremy G. Siek and Walid Taha. Gradual typing for functional languages. In ICFP '06: Proceedings of the Eleventh ACM SIGPLAN International Conference on Functional Programming, New York, NY, USA, 2006. ACM Press.

[27]

Dorai Sitaram. ScheLog, http://www.ccs.neu.edu/home/dorai/ schelog/schelog.html 1993--2004.

[28]

Guy Lewis Steele Jr. Common Lisp - The Language. Digital Press, 1984.

Digital Library

[29]

Tim Lindholm and Frank Yellin. The Java Virtual Machine Specification (Second Edition). Sun Microsystems, 1999.

Digital Library

[30]

Andrew K. Wright and Robert Cartwright. A practical soft type system for scheme. ACM Trans. Program. Lang. Syst., 19(1):87--152, 1997.

Digital Library

Cited By

Ye WOliveira BToro M(2024)Merging Gradual TypingProceedings of the ACM on Programming Languages10.1145/36897348:OOPSLA2(648-676)Online publication date: 8-Oct-2024
https://dl.acm.org/doi/10.1145/3689734
Fitzgibbons MParaskevopoulou ZMushtak NThalakottur MSulaiman Manzur JAhmed A(2024)RichWasm: Bringing Safe, Fine-Grained, Shared-Memory Interoperability Down to WebAssemblyProceedings of the ACM on Programming Languages10.1145/36564448:PLDI(1656-1679)Online publication date: 20-Jun-2024
https://dl.acm.org/doi/10.1145/3656444
Igarashi AOzaki SSekiyama TTanabe Y(2024)Space-Efficient Polymorphic Gradual Typing, Mostly ParametricProceedings of the ACM on Programming Languages10.1145/36564418:PLDI(1585-1608)Online publication date: 20-Jun-2024
https://dl.acm.org/doi/10.1145/3656441
Show More Cited By

Index Terms

Interlanguage migration: from scripts to programs
1. Software and its engineering
  1. Software notations and tools
    1. Formal language definitions
      1. Semantics
    2. General programming languages
      1. Language features
        Modules / packages
2. Theory of computation
  1. Semantics and reasoning
    1. Program semantics

Recommendations

Cayenne—a language with dependent types

Cayenne is a Haskell-like language. The main difference between Haskell and Cayenne is that Cayenne has dependent types, i.e., the result type of a function may depend on the argument value, and types of record components (which can be types or values) ...
Cayenne—a language with dependent types
ICFP '98: Proceedings of the third ACM SIGPLAN international conference on Functional programming

Cayenne is a Haskell-like language. The main difference between Haskell and Cayenne is that Cayenne has dependent types, i.e., the result type of a function may depend on the argument value, and types of record components (which can be types or values) ...
Abstraction preservation and subtyping in distributed languages
ICFP '06: Proceedings of the eleventh ACM SIGPLAN international conference on Functional programming

In most programming languages, type abstraction is guaranteed by syntactic scoping in a single program, but is not preserved by marshalling during distributed communication. A solution is to generate hash types at compile time that consist of a ...

Comments

Information & Contributors

Information

Published In

cover image ACM Conferences

OOPSLA '06: Companion to the 21st ACM SIGPLAN symposium on Object-oriented programming systems, languages, and applications

October 2006

530 pages

ISBN:159593491X

DOI:10.1145/1176617

General Chair:
Peri Tarr
IBM Thomas J. Watson Research Center, USA
,
Program Chair:
William R. Cook
University of Texas at Austin, USA

Copyright © 2006 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]

Sponsors

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 22 October 2006

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Article

Conference

OOPSLA06

Sponsor:

OOPSLA06: ACM SIGPLAN Object Oriented Programming Systems and Applications Conference

October 22 - 26, 2006

Oregon, Portland, USA

Upcoming Conference

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

179
Total Citations
View Citations
519
Total Downloads

Downloads (Last 12 months)17
Downloads (Last 6 weeks)1

Reflects downloads up to 24 Dec 2024

Other Metrics

View Author Metrics

Citations

Cited By

Ye WOliveira BToro M(2024)Merging Gradual TypingProceedings of the ACM on Programming Languages10.1145/36897348:OOPSLA2(648-676)Online publication date: 8-Oct-2024
https://dl.acm.org/doi/10.1145/3689734
Fitzgibbons MParaskevopoulou ZMushtak NThalakottur MSulaiman Manzur JAhmed A(2024)RichWasm: Bringing Safe, Fine-Grained, Shared-Memory Interoperability Down to WebAssemblyProceedings of the ACM on Programming Languages10.1145/36564448:PLDI(1656-1679)Online publication date: 20-Jun-2024
https://dl.acm.org/doi/10.1145/3656444
Igarashi AOzaki SSekiyama TTanabe Y(2024)Space-Efficient Polymorphic Gradual Typing, Mostly ParametricProceedings of the ACM on Programming Languages10.1145/36564418:PLDI(1585-1608)Online publication date: 20-Jun-2024
https://dl.acm.org/doi/10.1145/3656441
Gierczak OMenon LDimoulas CAhmed A(2024)Gradually Typed Languages Should Be Vigilant!Proceedings of the ACM on Programming Languages10.1145/36498428:OOPSLA1(864-892)Online publication date: 29-Apr-2024
https://dl.acm.org/doi/10.1145/3649842
YE WOLIVEIRA B(2024)Type-directed operational semantics for gradual typingJournal of Functional Programming10.1017/S095679682400007834Online publication date: 26-Sep-2024
https://doi.org/10.1017/S0956796824000078
SU CCHEN LYANHUI LZHOU Y(2024)Static Blame for gradual typingJournal of Functional Programming10.1017/S095679682400002934Online publication date: 25-Mar-2024
https://doi.org/10.1017/S0956796824000029
Khan MChen S(2024)Gradual Typing Performance, Micro Configurations and Macro PerspectivesTheoretical Aspects of Software Engineering10.1007/978-3-031-64626-3_15(261-278)Online publication date: 29-Jul-2024
https://dl.acm.org/doi/10.1007/978-3-031-64626-3_15
Greenman BFelleisen MDimoulas C(2023)How Profilers Can Help Navigate Type MigrationProceedings of the ACM on Programming Languages10.1145/36228177:OOPSLA2(544-573)Online publication date: 16-Oct-2023
https://dl.acm.org/doi/10.1145/3622817
Lemay MFu QBlair WZhang CXi HCong YDagand P(2023)A Dependently Typed Language with Dynamic EqualityProceedings of the 8th ACM SIGPLAN International Workshop on Type-Driven Development10.1145/3609027.3609407(44-57)Online publication date: 30-Aug-2023
https://dl.acm.org/doi/10.1145/3609027.3609407
Lazarek LGreenman BFelleisen MDimoulas C(2023)How to Evaluate Blame for Gradual Types, Part 2Proceedings of the ACM on Programming Languages10.1145/36078367:ICFP(159-186)Online publication date: 31-Aug-2023
https://dl.acm.org/doi/10.1145/3607836
Show More Cited By

View Options

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Publication

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Media

Figures

Other

Tables

View Table of Contents