Script to Program Evolution (STOP)

Date: 11 June
Room: Conference 8


  • Sam Tobin-Hochstadt (co-Chair and primary contact), Northeastern University
  • Tobias Wrigstad, Uppsala University
  • Jan Vitek, Purdue University
  • Nathaniel Nystrom, University of Lugano
  • Matthias Felleisen, Northeastern University
  • Philip Wadler, University of Edinburgh
  • Cormac Flanagan, Santa Cruz



Programme Committee:

  • Avik Chaudhuri
  • Kathryn Gray
  • Arjun Guha
  • David Herman
  • Manuel Hermenegildo
  • Atsushi Igarashi
  • Ranjit Jhala
  • Sam Tobin-Hochstadt (Chair)

The STOP workshop aims to bring together researchers in different communities working on “hardening” scripts into programs. Typical topics include studies on the differences between scripts and regular programs; studies on the exploitation of the dynamic nature (e.g., dynamic loading, eval, reflection) of scripting languages; work on retrofitting type systems for documentation and maintenance purposes; research on adding contract systems for monitoring invariants at component boundaries; and efforts concerning language interoperability.
While this field has existed for some 20 years, the steadily growing use of scripting languages in the software industry has triggered the need for a concerted effort. STOP fills the need for communicating results across language paradigms, for sharing experiences regardless of application, and for exchanging ideas on future directions.

After two successful STOP workshops featuring both position papers and technical papers, this edition of the STOP workshop series seeks to bring together the numerous researchers working on these issues for informal discussion, exchange of ideas, and demonstrations of new techniques and tools.

Important Dates 重要日期

Submission deadline:
30 March, 2012
20 Apr, 2012
Final Version:
15 May, 2012
11 June, 2012

Preliminary Call For Papers 征稿启事

Recent years have seen increased use of scripting languages in large applications. Scripting languages optimize development time, especially early in the software life cycle, over safety and robustness. As the understanding of the system reaches a critical point and requirements stabilize, scripting languages become less appealing. Compromises made to optimize development time make it harder to reason about program correctness, harder to do semantic-preserving refactorings, and harder to optimize execution speed. Lack of type information makes code harder to navigate and to use correctly. In the worst cases, this situation leads to a costly and potentially error-prone rewrite of a program in a compiled language, losing the flexibility of scripting languages for future extension.

Recently, pluggable type systems and annotation systems have been proposed. Such systems add compile-time checkable annotations without changing a program’s run-time semantics which facilitates early error checking and program analysis. It is believed that untyped scripts can be retrofitted to work with such systems. Furthermore, integration of typed and untyped code, for example, through use of gradual typing, allows scripts to evolve into safer programs more suitable for program analysis and compile-time optimizations.

With few exceptions, practical reports are yet to be found. The STOP workshop focuses on the evolution of scripts, largely untyped code, into safer programs, with more rigid structure and more constrained behavior through the use of gradual/hybrid/pluggable typing, optional contract checking, extensible languages, refactoring tools, and the like. The goal is to further the understanding and use of such systems in practice, and connect practice and theory.

Selection Process

Abstracts, position papers, and status reports are welcome. Papers should be 1-2 pages in standard ACM SIGPLAN format. All submissions will be reviewed by the program committee. The accepted papers, after rework by the authors, will be published in an informal proceedings, which will be distributed at the workshop. All accepted submissions shall remain available from the workshop web page. Questions may be directed to Sam Tobin-Hochstadt at

STOP Program

Monday, June 11
9:45–9:50 Opening Remarks
9:50–10:45 Keynote: David Mandelin - The Evolution of the JavaScript Engine
10:45–11:00 Break
11:00–12:00 Session 1

Improving Tools for JavaScript Programmers
Esben Andersen, Asger Feldthaus, Simon Holm Jensen, Casper S. Jensen, Peter A. Jonsson, Magnus Madsen, Anders Møller
Aarhus University

Status Report: Dependent Types for JavaScript
Ravi Chugh1, David Herman2, Ranjit Jhala1
1UCSD, 2Mozilla

12:00–13:30 Lunch
13:30–14:30 Session 2

Big Bang: Designing a Statically-Typed Scripting Language
Pottayil Harisanker Menon, Zachary Palmer, Alexander Rozenshteyn, Scott Smith
Johns Hopkins University

Minigrace: A progress report
Michael Homer, James Noble
Victoria University of Wellington

14:30–15:00 Break
15:00–16:00 Session 3

Contracts with Path-Based Effects for Secure and Verifiable Software (Position Paper)
Peter Thiemann
University of Freiburg

Towards Gradual Typing in Jython
Michael M. Vitousek, Shashank Bharadwaj, Jeremy G. Siek
University of Colorado

The Evolution of the JavaScript Engine

David Mandelin

Dave's picture

JavaScript was introduced in 1995 as a scripting language for the web, at first for little more than interactive menus and crude demos. JavaScript today is the scripting language, programming language, and even assembly language of the web. Now JavaScript is used to make beautiful 3D demos, games, and apps, and to run programs ported from languages such as C++. This talk is a history of JavaScript engine performance, especially the last five years, which I directly experienced. I'll talk about the different architectures and compilers implementers have tried, as engines evolved from simple interpreters to optimized interpreters and through multiple generations of JIT compilers. I'll also talk about the environment that shaped that evolution: the ideas, demos, and benchmarks that pushed and pulled implementers along. I'll conclude with some thoughts about things that haven't been tried yet, what users and the web need from JavaScript now, and where JavaScript engines might be headed next.

Time: 9:45–10:45, June 11
Room: NS

Dave Mandelin is manager of the JavaScript team at Mozilla and is also the module owner of the SpiderMonkey JavaScript engine. Previously, he was an engineer at Mozilla, working mainly on program analysis and then JavaScript performance. He is one of the author of trace-based Just-in-time compiler that was published at PLDI'09.