Matthias Felleisen

Fleet Numerical Meteorology and Oceanography Center (FNMOC) (2008)

The future annotations of MultiLisp provide a simple method for taming the implicit parallelism of functional programs. Past research concerning futures has focused on implementation issues. In this...

Jacob Matthews, Robert Bruce Findler, Paul Graunke, Matthias Felleisen

paper.tex; 2/11/2004; 14:50; p.1

Fleet Numerical Meteorology and Oceanography Center (FNMOC) (2008)

Jacob Matthews, Robert Bruce Findler, Paul Graunke, Matthias Felleisen

paper.tex; 11/01/2004; 11:06; p.1

[8] Benjamin C. Pierce. Advanced Topics in Types and Programming Languages. (2008)

Programming Languages, The Mit Press, Daniel P. Friedman, Matthias Felleisen, The Little, ...

[12] Paul R. Wilson. Uniprocessor garbage collection techniques. In Proc.

Abstract (2008)

Propositional Logic: type checking (2008)

A major cause of software unreliability is the misapplication of primitive operations, such as taking the car of nil, dividing by zero, or using an invalid array index. These errors are traditionally...

Ian Barland, John Greiner, Phokion Kolaitis, Moshe Vardi, Matthias Felleisen

Original in Formal Syntax and Semantics of Java, LNCS volume 1523 (1999) (2008)

Matthew Flatt, Shriram Krishnamurthi, Matthias Felleisen

Abstract. While class-based object-oriented programming languages provide a flexible mechanism for re-using and managing related pieces of code, they typically lack linguistic facilities for...

General Terms (2008)

Carl Eastlund, Dale Vaillancourt, Matthias Felleisen

subset of Scheme in its introductory programming course with a heavy emphasis on design. Students then proceed to a second-semester programming course using Java and a course on symbolic logic....

Abstract Catching Bugs in the Web of Program Invariants (2008)

Cormac Flanagan, Matthew Flatt, Shriram Krishnamurthi, Stephanie Weirich, Matthias Felleisen

MrSpidey is a user-friendly, interactive static debugger for Scheme. A static debugger supplements the standard debugger by analyzing the program and pinpointing those program operations that may...

Abstract Abstract Models of Memory Management (2008)

Greg Morrisett, Matthias Felleisen, Robert Harper

Most speci cations of garbage collectors concentrate on the low-level algorithmic details of how to nd and preserve accessible objects. Often, they focus on bit-level manipulations such as \scanning...

Abstract The DrScheme Project: An Overview (2008)

Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi

DrScheme provides a graphical user interface for editing and interactively evaluating Scheme programs on all major graphical platforms (Windows 95/nt, MacOs, Unix/X). The environment is especially...

does, but also includes the complete proofs in an appendix. (2008)

Robert Bruce Findler, Matthias Felleisen

Assertions play an important role in the construction of robust software. Their use in programming languages dates back to the 1970s. Eiffel, an object-oriented programming language, wholeheartedly...

ABSTRACT (2008)

Dale Vaillancourt, Matthias Felleisen

Teaching undergraduates to develop software in a formal framework such as ACL2 poses two immediate challenges. First, students typically do not know applicative programming and are often unfamiliar...

on the Syntactic Theories of Sequential Control and State (2008)

Matthias Felleisen, Robert Hieb, Matthias Felleisen, Robert Hieb

The syntactic theories of control and state are conservative extensions of the λv-calculus for equational reasoning about imperative programming facilities in higher-order languages. Unlike the...

Blunk Microsystems (2008)

Tudor Antoniu, Paul A. Steckler, Erich Neuwirth, Matthias Felleisen, Shriram Krishnamurthi

Financial companies, engineering firms and even scientists create increasingly larger spreadsheets and spreadsheet programs. The creators of large spreadsheets make errors and must track them down....

Engineering]: Coding Tools and Techniques—objectoriented programming (2008)

Richard Cobbe, Matthias Felleisen

constructs for specifying environmental acquisition in addition to inheritance acquisition for objects. They noticed that in many programs, objects are arranged in containment hierarchies and need to...

Fleet Numerical Meteorology and Oceanography Center (FNMOC) (2008)

Jacob Matthews, Robert Bruce Findler, Paul Graunke, Matthias Felleisen

paper.tex; 17/05/2004; 15:34; p.1

Abstract Semantic Casts Contracts and Structural Subtyping in a Nominal World (2008)

Robert Bruce Findler, Matthew Flatt, Matthias Felleisen

Nominal subtyping forces programmers to explicitly state all of the subtyping relationships in the program. This limits component reuse, because programmers cannot anticipate all of the contexts in...

on the Syntactic Theories of Sequential Control and State (2008)

Matthias Felleisen, Robert Hieb, Matthias Felleisen, Robert Hieb Y

The syntactic theories of control and state are conservative extensions of the v-calculus for equational reasoning about imperative programming facilities in higher-order languages. Unlike the simple...

ATail-Recursive Machine with Stack Inspection (2008)

John Clements, Matthias Felleisen

Security folklore holds that a security mechanism based on stack inspection is incompatible with a global tail call optimization policy; that an implementation of such a language must allocate memory...

ABSTRACT Sequence Traces for Object-Oriented Executions (2008)

Carl Eastlund, Matthias Felleisen

Over the past 30 years, researchers have developed a large variety of semantic models of object-oriented computations. These include object calculi as well as denotational, smallstep operational,...

Intro to Logic (2008)

Ian Barland, Phokion Kolaitis, Moshe Vardi, Matthias Felleisen, John Greiner

An introduction to reasoning with propositional and first-order logic, with applications to computer science. Part of the TeachLogic Project (www.teachlogic.org).

Introduction: logic motivation (2008)

Ian Barland, John Greiner, Phokion Kolaitis, Moshe Vardi, Matthias Felleisen

Logic provides a way to talk about truth and correctness in a rigourous way, so that we can prove things, rather than make intelligent guesses and just hope they are correct.

John Clements, Shriram Krishnamurthi, Matthias Felleisen

Programmers constantly design, implement, and program in little languages. Two different approaches to the implementation of little languages have evolved. One emphasizes the design of little...

2 (2007)

Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi

Abstract. The TeachScheme! project aims to reform three aspects of introductory high school courses on programming. The first is a systematic program design method. The key property of the method is...

Demand-Driven Type Analysis for Dynamically-Typed Functional Languages (2007)

Danny Dub, En Informatique, Danny Dub, Gilles Brassard, Marc Feeley, Matthias Felleisen

Dpartement d'informatique et de recherche oprationnelle Facult des arts et des sciences Thse prOsentre k la Facult des tudes suprieures en vue de l'obtention du grade de Ph.D.

2 (2007)

Matthias Felleisen, Robert B. Findler, Matthew Flatt, Shriram Krishnamurthi

Abstract. Nearly twenty years ago, Structure and Interpretation of Computer Programs (SICP) changed the intellectual landscape of introductory computing courses. Unfortunately, three problems---its...

<title>Not an Article</title> (2007)

John Clements, Paul T. Graunke, Shriram Krishnamurthi, Matthias Felleisen

Programmers constantly design, implement, and program in little languages. Two different approaches to the implementation of little languages have evolved. One emphasizes the design of little...

Chapter 5 On the Orthogonality of Assignments and Procedures in Algol (2007)

Matthias Felleisen, Stephen Weeks

According to folklore, Algol is an #orthogonal # extension of a simple imperative programming language with a call-by-name functional language. The former contains assignments, branching constructs,...

1.1 Summary of Previous Work: : : : : : : : : : : : : : : : : : : : : : : : : : : 2 (2007)

Robert Cartwright, Matthias Felleisen, Matthias Felleisen, Robert Cartwright Matthias

3.1 Using errors, programmers can observe the order of evaluation.: : : : : : : 10 3.2 Using control operators, programs can observe the order of evaluation.: : : 10 3.3 Procedure denotations contain...

Contents (2007)

Ramarao Kanneganti, Robert Cartwright, Robert Cartwright, Matthias Felleisen, Matthias Felleisen

A version of this report appears in the

Implementing a Static Debugger for a First-Order Functional Programming Language (2007)

Matthias Felleisen, Paul A. Steckler

A static debugger assists a programmer in nding potential errors in programs. The key to a static debugger is set-based analysis (SBA). Many authors have described formulations of SBA, but leave open...

Contents (2007)

A Programmer's Reduction Semantics (2007)

Matthew Flatt, Shriram Krishnamurthi, Matthias Felleisen

Abstract. While class-based object-oriented programming languages provide a flexible mechanism for re-using and managing related pieces of code, they typically lack linguistic facilities for...

Integrating Logic into the Computer Science Curriculum (2007)

Ian Barl, Matthias Felleisen, Kathi Fisler, Phokion Kolaitis, Moshe Y. Vardi

Computer science programs prepare students to construct systems. System construction requires reasoning about the interactions, capabilities, and limitations of components. A good degree program...

The widespread use of the continuation-passing style (CPS) transformation in compilers, optimizers, abstract interpreters, and partial evaluators reflects a common belief that the transformation has...

The-calculus is the simple and elegant, yet powerful basis for the semantic manipulation of functional programs by programmers and programming tools (compilers, optimizers, semantics-based editors)...

The Structure and Interpretation of the Computer Science Curriculum (2007)

The widespread use of the continuation-passing style (CPS) transformation in compilers, partial evaluators, and abstract interpretations suggests that it is useful for program analysis. Indeed, there...

A call-by-need lambda calculus (2007)

Twenty years ago Abelson and Sussman's Structure and Interpretation of Computer Programs radically changed the intellectual landscape of introductory computing courses. Instead of teaching some...

Ariola, Zena M., Felleisen, Matthias, Maraist, John, Odersky, Martin, Wadler, Philip

90 = 100: A Proof (2007)

Ian Barland, Moshe Vardi, Phokion Kolaitis, Matthias Felleisen, John Greiner

A (purported) geometric proof that 90=100.

Implementation and use of the PLT Scheme web server (2007)

Shriram Krishnamurthi, Peter Walton Hopkins, Jay Mccarthy, Paul T. Graunke, Greg Pettyjohn, Matthias Felleisen

Abstract. The PLT Scheme Web Server uses continuations to enable a natural, console-like program development style. We describe the implementation of the server and its use in the development of an...

Propositional Logic: partIIo (2006)

Ian Barland, John Greiner, Phokion Kolaitis, Moshe Vardi, Matthias Felleisen

Reducing statements to true/false propositions allows us to craft sentences with precise meaning, and to make precise arguments which can be checked automatically.

Reference: first-order inference rules (2006)

John Greiner, Phokion Kolaitis, Moshe Vardi, Matthias Felleisen

Inference rules for reasoning about first-order logic formulas.

Scheme with classes, mixins, and traits (2006)

Matthew Flatt, Robert Bruce Findler, Matthias Felleisen

Abstract. The Scheme language report advocates language design as the composition of a small set of orthogonal constructs, instead of a large accumulation of features. In this paper, we demonstrate...

Modeling web interactions and errors (2006)

Shriram Krishnamurthi, Robert Bruce Findler, Paul Graunke, Matthias Felleisen

Summary. Programmers confront a minefield when they design interactive Web programs. Web interactions take place via Web browsers. Browsers permit consumers to whimsically navigate among the various...

Scheme with classes, mixins, and traits (2006)

Matthew Flatt, Robert Bruce Findler, Matthias Felleisen

Abstract. The Scheme language report advocates language design as the composition of a small set of orthogonal constructs, instead of a large accumulation of features. In this paper, we demonstrate...

Modeling web interactions and errors (2006)

Shriram Krishnamurthi, Robert Bruce Findler, Paul Graunke, Matthias Felleisen

Summary. Programmers confront a minefield when they design interactive Web programs. Web interactions take place via Web browsers. Browsers permit consumers to whimsically navigate among the various...

Programming Languages and Lambda Calculi (Summer 2006 Revised Version) (2006)

Matthias Felleisen, Matthew Flatt

Continuations from Generalized Stack Inspection (2005)

Pettyjohn, Greg, Clements, John, Marshall, Joe, Krishnamurthi, Shriram, Felleisen, Matthias

Implementing first-class continuations can pose a challenge if the target machine makes no provisions for accessing and re-installing the run-time stack. In this paper, we present a novel translation...

First-Order Logic: normal forms revisited (2005)

Ian Barland, John Greiner, Phokion Kolaitis, Moshe Vardi, Matthias Felleisen

Using CNF and DNF with first-order-logic.

Introduction: outline (2005)

Ian Barland, John Greiner, Phokion Kolaitis, Moshe Vardi, Matthias Felleisen

The Base Logic module of the TeachLogic project covers propositional and first-order logic and reasoning with truth tables, equivalences, and inference rules.

Propositional Logic: partIIm (2005)

Ian Barland, John Greiner, Phokion Kolaitis, Moshe Vardi, Matthias Felleisen

More examples using formal proofs (inference rules) for determining whether a formula is true.

Propositional Logic: partIIn (2005)

Ian Barland, John Greiner, Phokion Kolaitis, Moshe Vardi, Matthias Felleisen

(Blank Abstract)

but not least, we express our gratitude to the many participants who made these ten years so much fun. (2005)

Richard Cobbe, Matthias Felleisen, Stephen Bloch, Robert Findler, Kathi Fisler, Matthew Flatt, ...

The TeachScheme! Project has reached a remarkable age. Founded in 1995, it has turned 10. Over these ten years, the Project has trained close to 250 teachers and a couple of dozen college faculty....

Environmental acquisition revisited (2005)

Richard Cobbe, Matthias Felleisen

Object-oriented programs frequently deal with hierarchical forms of data, often called whole-part arrangements. When in such arrangements the methods in the parts must compute information about their...

The TeachScheme! project: Computing and programming for every student (2004)

Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi

Abstract. The TeachScheme! Project aims to reform three aspects of introductory programming courses in secondary schools. First, we use a design method that asks students to develop programs in a...

The TeachScheme! project: Computing and programming for every student (2004)

Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi

Abstract. The TeachScheme! project aims to reform three aspects of introductory high school courses on programming. The first is a systematic program design method. The key property of the method is...

A visual environment for developing context-sensitive term rewriting systems (2004)

Jacob Matthews, Robert Bruce Findler, Matthew Flatt, Matthias Felleisen

Abstract. Over the past decade, researchers have found context-sensitive term-rewriting semantics to be powerful and expressive tools for modeling programming languages, particularly in establishing...

M.: Taming macros (2004)

The TeachScheme! project: Computing and programming for every student (2004)

Abstract. Scheme includes a simple yet powerful macro mechanism. Using macros, programmers can easily extend the language with new kinds of expressions and definitions, thus abstracting over...

Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi

Abstract. The TeachScheme! Project aims to reform three aspects of introductory programming courses in secondary schools. First, we use a design method that asks students to develop programs in a...

An investigation of contracts as projections (2004)

Robert Bruce Findler, Matthias Blume, Matthias Felleisen

Software contracts help programmers enforce program properties that the language’s type system cannot express. Unlike types, contracts are (usually) enforced at run-time. When a contract fails, the...

A visual environment for developing context-sensitive term rewriting systems (2004)

Jacob Matthews, Robert Bruce Findler, Matthew Flatt, Matthias Felleisen

Abstract. Over the past decade, researchers have found context-sensitive term-rewriting semantics to be powerful and expressive tools for modeling programming languages, particularly in establishing...

The TeachScheme! Project: Computing and Programming for Every Student (2003)

Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi

The TeachScheme! Project aims to reform three aspects of introductory programming courses in secondary schools. First, we use a design method that asks students to develop programs in a stepwise...

A tail-recursive semantics for stack inspections (2003)

John Clements, Matthias Felleisen

Abstract. Security folklore holds that a security mechanism based on stack inspection is incompatible with a global tail call optimization policy. An implementation of such a language may have to...

A tail-recursive semantics for stack inspections (2003)

John Clements, Matthias Felleisen

Abstract. Security folklore holds that a security mechanism based on stack inspection is incompatible with a global tail call optimization policy. An implementation of such a language may have to...

M.: Well-shaped macros (2003)

Automatically Restructuring Programs for the Web (2003)

Scheme includes an easy-to-use and powerful macro mechanism for extending the programming language with new expression and definition forms. Using macros, a Scheme programmer can define a new...

Jacob Matthews, Robert Bruce Findler, Shriram Krishnamurthi, Matthias Felleisen

this paper, we show that Web programmers can use existing software engineering methods to develop interactive programs and that well-known, algorithmic transformations can generate standard CGI...

Demand-Driven Type Analysis for DynamicallyTyped Functional Languages (2002)

Danny Dubé, Danny Dubé, Danny Dubé, Gilles Brassard, Marc Feeley, ...

par

DrScheme: A programming environment for Scheme (2002)

Robert Bruce Findler, John Clements, Cormac Flanagan, Matthew Flatt, Shriram Krishnamurthi, Paul Steckler, ...

DrScheme is a programming environment for Scheme. It fully integrates a graphicsenriched editor, a parser for multiple variants of Scheme, a functional read-eval-print loop, and an algebraic printer....

DrScheme: A programming environment for Scheme (2002)

Robert Bruce Findler, John Clements, Cormac Flanagan, Matthew Flatt, Shriram Krishnamurthi, Paul Steckler, ...

DrScheme is a programming environment for Scheme. It fully integrates a graphicsenriched editor, a parser for multiple variants of Scheme, a functional read-eval-print loop, and an algebraic printer....

DrScheme: A programming environment for Scheme (2002)

Robert Bruce Findler, John Clements, Cormac Flanagan, Matthew Flatt, Shriram Krishnamurthi, Paul Steckler, ...

DrScheme is a programming environment for Scheme. It fully integrates a graphicsenriched editor, a parser for multiple variants of Scheme, a functional read-eval-print loop, and an algebraic printer....

The structure and interpretation of the computer science curriculum (2002)

Matthias Felleisen, Robert B. Findler, Matthew Flatt, Shriram Krishnamurthi

Abstract. Nearly twenty years ago, Structure and Interpretation of Computer Programs (SICP) changed the intellectual landscape of introductory computing courses. Unfortunately, three problems—its...

Environmental acquisition in network management (2002)

Mark Logan, Matthias Felleisen, David Blank-edelman

Maintaining configurations in heterogeneous networks poses complex problems. We observe that medium and large networks exhibit many contextual relationships, and argue that modeling these...

The structure and interpretation of the computer science curriculum (2002)

Matthias Felleisen, Robert B. Findler, Matthew Flatt, Shriram Krishnamurthi

Abstract. Nearly twenty years ago, Structure and Interpretation of Computer Programs (SICP) changed the intellectual landscape of introductory computing courses. Unfortunately, three problems—its...

Environmental acquisition in network management (2002)

Mark Logan, Matthias Felleisen, David Blank-edelman

Maintaining configurations in heterogeneous networks poses complex problems. We observe that medium and large networks exhibit many contextual relationships, and argue that modeling these...

Little Languages and Their Programming Environments (2001)

Clements, John, Graunke, Paul, Krishnamurthi, Shriram, Felleisen, Matthias

Programmers constantly design, implement, and program in little languages. Two different approaches to the implementation of little languages have evolved. One emphasizes the design of little...

Modeling an Algebraic Stepper (2001)

Clements, John, Flatt, Mathew, Felleisen, Matthias

Programmers rely on the correctness of the tools in their programming environments. In the past, semanticists have studied the correctness of compilers and compiler analyses, which are the most...

Little Languages and their Programming Environments (2001)

John Clements, Paul Graunke, Shriram Krishnamurthi, Matthias Felleisen

Programmers constantly design, implement, and program in little languages. Two different approaches to the implementation of little languages have evolved. One emphasizes the design of little...

Behavioral contracts and behavioral subtyping (2001)

Robert Bruce Findler, Mario Latendresse, Matthias Felleisen

Component-based software manufacturing has the potential to bring division-of-labor benefits to the world of software engineering. In order to make a market of software components viable, however,...

Modeling an algebraic stepper (2001)

John Clements, Matthew Flatt, Matthias Felleisen

Abstract. Programmers rely on the correctness of the tools in their programming environments. In the past, semanticists have studied the correctness of compilers and compiler analyses, which are the...

Automatically restructuring programs for the Web (2001)

Paul Graunke, Shriram Krishnamurthi, Robert Bruce Findler, Matthias Felleisen

The construction of interactive server-side Web applications differs substantially from the construction of traditional interactive programs. In contrast, existing Web programming paradigms force...

Object-oriented programming languages need well-founded contracts (2001)

Robert Bruce Findler, Mario Latendresse, Matthias Felleisen

Abstract. Over the past few years, the notion of building software from components has become popular again. The goal is to produce systems by adapting and linking off-the-shelf modules from a pool...

Contract soundness for object-oriented languages (2001)

Robert Bruce Findler, Matthias Felleisen

Checking pre- and post-conditions of procedures and methods at runtime helps improve software reliability. In the procedural world, pre- and post-conditions have a straightforward interpretation. If...

Automatically restructuring programs for the Web (2001)

Paul Graunke, Shriram Krishnamurthi, Robert Bruce Findler, Matthias Felleisen

The construction of interactive server-side Web applications differs substantially from the construction of traditional interactive programs. In contrast, existing Web programming paradigms force...

Object-oriented programming languages need well-founded contracts (2001)

Robert Bruce Findler, Mario Latendresse, Matthias Felleisen

Abstract. Over the past few years, the notion of building software from components has become popular again. The goal is to produce systems by adapting and linking off-the-shelf modules from a pool...

Automatically restructuring programs for the Web (2001)

Paul Graunke, Shriram Krishnamurthi, Robert Bruce Findler, Matthias Felleisen

The construction of interactive server-side Web applications differs substantially from the construction of traditional interactive programs. In contrast, existing Web programming paradigms force...

Modeling an algebraic stepper (2001)

John Clements, Matthew Flatt, Matthias Felleisen

Abstract. Programmers rely on the correctness of the tools in their programming environments. In the past, semanticists have studied the correctness of compilers and compiler analyses, which are the...

Little Languages and their Programming Environments (2001)

John Clements, Shriram Krishnamurthi, Matthias Felleisen

Programmers constantly design, implement, and program in little languages. Two different approaches to the implementation of little languages have evolved. One emphasizes the design of little...

Implementing a Static Debugger for a First-Order Functional Programming Language (2000)

Matthias Felleisen, Paul A. Steckler

A static debugger assists a programmer in nding potential errors in programs. The key to a static debugger is set-based analysis (SBA). Many authors have described formulations of SBA, but leave open...

Behavioral Interface Contracts for Java (2000)

Robert Bruce Findler, Matthias Felleisen, Robert Bruce, Findler Matthias Felleisen

Programs should consist of off-the-shelf, interchangeable, black-box components that are produced by a network of independent software companies. These components should not only come with type...

From Macros to Reusable Generative Programming (1999)

Shriram Krishnamurthi Matthias, Matthias Felleisen, Bruce F. Duba

. Generative programming is widely used both to develop new programming languages and to extend existing ones with domain-specific sub-languages. This paper describes McMicMac, a framework for...

From Macros to Reusable Generative Programming (1999)

Shriram Krishnamurthi, Matthias Felleisen, Bruce F. Duba

. Generative programming is widely used both to develop new programming languages and to extend existing ones with domain-specific sub-languages. This paper describes McMicMac, a framework for...

From macros to reusable generative programming (1999)

Shriram Krishnamurthi, Matthias Felleisen, Bruce F. Duba

Abstract. Generative programming is widely used both to develop new programming languages and to extend existing ones with domain-speci c sub-languages. This paper describes McMicMac, a framework for...

Synthesizing object-oriented and functional design to promote re-use (1998)

Synthesizing object-oriented and functional design to promote re-use (1998)

A preliminary version of this paper appeared in the

Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman

Abstract. Many problems require recursively speci ed types of data and a collection of tools that operate on those data. Over time, these problems evolve so that the programmer must extend the...

The DrScheme Project: An Overview (1998)

Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi

DrScheme provides a graphical user interface for editing and interactively evaluating Scheme programs on all major graphical platforms (Windows 95/nt, MacOs, Unix/X). The environment is especially...

Classes and mixins (1998)

Matthew Flatt, Shriram Krishnamurthi, Matthias Felleisen

While class-based object-oriented programming languages provide a flexible mechanism for re-using and managing related pieces of code, they typically lack linguistic facilities for specifying a...

Synthesizing object-oriented and functional design to promote re-use (1998)

Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman

A preliminary version of this paper appeared in the

Units: Cool modules for HOT languages (1998)

Matthew Flatt, Matthias Felleisen

A module system ought to enable assembly-line programming using separate compilation and an expressive linking language. Separate compilation allows programmers to develop parts of a program...

Toward a formal theory of extensible software (1998)

Synthesizing object-oriented and functional design to promote re-use (1998)

As software projects continue to grow in scale and scope, it becomes important to reuse software. An important kind of reuse is extensibility, i.e., the extension of software without accessing...

Units: Cool modules for HOT languages (1998)

A preliminary version of this paper appeared in the

Matthew Flatt, Matthias Felleisen

A module system ought to enable assembly-line programming using separate compilation and an expressive linking language. Separate compilation allows programmers to develop parts of a program...

Set-based analysis (SBA) produces good predictions about the behavior of functional and objectoriented programs. The analysis proceeds by inferring constraints that characterize the data flow...

PLT MrEd: Graphical toolbox manual (1997)

Set-based analysis (SBA) produces good predictions about the behavior of functional and objectoriented programs. The analysis proceeds by inferring constraints that characterize the data ow...

Matthew Flatt, Robert Bruce Findler, Cormac Flanagan, Matthias Felleisen, Paul Steckler, Gann Bierner, ...

Copyright notice Copyright c○1996-99 PLT, Rice University Permission to make digital/hard copies and/or distribute this documentation for any purpose is hereby

Set-based analysis (SBA) produces good predictions about the behavior of functional and objectoriented programs. The analysis proceeds by inferring constraints that characterize the data flow...

DrScheme: a pedagogic programming environment for Scheme (1997)

Set-based analysis is a constraint-based whole program analysis that is applicable to functional and objectoriented programming languages. Unfortunately, the analysis is useless for large programs,...

Robert Bruce Findler, Cormac Flanagan, Matthew Flatt, Shriram Krishnamurthi, Matthias Felleisen

Abstract. Teaching introductory computing courses with Scheme elevates the intellectual level of the course and thus makes the subject more appealing to students with scientific interests....

Componential Set-Based Analysis (1997)

Cormac Flanagan Matthias, Matthias Felleisen

Set-based analysis is a constraint-based whole program analysis that is applicable to functional and objectoriented programming languages. Unfortunately, the analysis is useless for large programs,...

DrScheme: a pedagogic programming environment for Scheme (1997)

Set-based analysis is a constraint-based whole program analysis that is applicable to functional and objectoriented programming languages. Unfortunately, the analysis is useless for large programs,...

Robert Bruce Findler, Cormac Flanagan, Matthew Flatt, Shriram Krishnamurthi, Matthias Felleisen

Abstract. Teaching introductory computing courses with Scheme elevates the intellectual level of the course and thus makes the subject more appealing to students with scienti c interests....

A call-by-need lambda calculus. (1996)

Ariola, Zena M., Felleisen, Matthias, Maraist, John, Odersky, Martin, Wadler, Philip

Modular and polymorphic set-based analysis: Theory and practice (1996)

Cormac Flanagan, Matthias Felleisen, Cormac Flanagan, Matthias Felleisen

Set-based analysis (SBA) produces good predictions about the behavior of functional and object-oriented programs. The analysis proceeds by inferring constraints that characterize the data ow...

Catching bugs in the web of program invariants (1996)

Cormac Flanagan, Matthew Flatt, Shriram Krishnamurthi, Stephanie Weirich, Matthias Felleisen

MrSpidey is a user-friendly, interactive static debugger for Scheme. A static debugger supplements the standard debugger by analyzing the program and pinpointing those program operations that may...

Modular and polymorphic set-based analysis: Theory and practice (1996)

Cormac Flanagan, Cormac Flanagan, Cormac Flanagan, Matthias Felleisen, Matthias Felleisen, Matthias Felleisen

Set-based analysis (SBA) produces good predictions about the behavior of functional and object-oriented programs. The analysis proceeds by inferring constraints that characterize the data flow...

Program Verification Through Soft Typing (1996)

Program Verification Through Soft Typing (1996)

During the past 25 years, programming language researchers have developed increasingly sophisticated techniques for statically analyzing program behavior. These techniques have been widely used in...

The Semantics of Future and Its Use in Program Optimization (1995)

Over the past 25 years, programming language researchers have developed increasingly sophisticated techniques for statically analyzing program behavior. These techniques have been widely used in...

Set-Based Analysis for Full Scheme and Its Use in Soft-Typing (1995)

The future annotations of MultiLisp provide a simple method for taming the implicit parallelism of functional programs. Past research concerning futures has focused on implementation issues. In this...

Cormac Flanagan, Cormac Flanagan, Cormac Flanagan, Matthias Felleisen, Matthias Felleisen, Matthias Felleisen

Set-Based Analysis is an efficient and accurate program analysis for higher-order languages. It exploits an intuitive notion of approximation that treats program variables as sets of values. We...

A Call-By-Need Lambda Calculus (1995)

Zena Ariola Computer, Zena M. Ariola, Matthias Felleisen, John Maraist, Martin Odersky, Philip Wadler

The mismatch between the operational semantics of the lambda calculus and the actual behavior of implementations is a major obstacle for compiler writers. They cannot explain the behavior of their...

The Call-By-Need Lambda Calculus (1995)

Zena Ariola, Matthias Felleisen

Plotkin [Theor. Comp. Sci. 1975] showed that the lambda calculus is a good model of the evaluation process for call-by-name functional programs. Reducing programs to constants or lambda abstractions...

Abstract models of memory management (1995)

Greg Morrisett, Matthias Felleisen, Robert Harper

U.S. Government.

Set-Based Analysis for Full Scheme and Its Use in Soft-Typing (1995)

Cormac Flanagan, Cormac Flanagan, Matthias Felleisen, Matthias Felleisen

77251-1982 Set-Based Analysis is an e cient and accurate program analysis for higher-order languages. It exploits an intuitive notion of approximation that treats program variables as sets of values....

Well-founded touch optimization for futures (1994)

Cormac Flanagan, Matthias Felleisen, Cormac Flanagan, Matthias Felleisen, Cormac Flanagan, Matthias Felleisen

77251-1892 The future annotations of MultiLisp provide a simple method for taming the implicit parallelism of functional programs, but require touch operations within all placeholder-strict...

The semantics of Future (1994)

Cormac Flanagan, Matthias Felleisen, Cormac Flanagan, Matthias Felleisen, Cormac Flanagan, Matthias Felleisen

The future annotation introduced by MultiLisp provides a simple method for taming the implicit parallelism of functional programs. Prior research on futures has concentrated on implementation and...

The semantics of Future (1994)

Cormac Flanagan, Cormac Flanagan, Cormac Flanagan, Matthias Felleisen, Matthias Felleisen, Matthias Felleisen

The future annotation introduced by MultiLisp provides a simple method for taming the implicit parallelism of functional programs. Prior research on futures has concentrated on implementation and...

Is continuation-passing useful for data flow analysis (1994)

Well-founded touch optimization for futures (1994)

The widespread use of the continuation-passing style interpreters, and partial evaluators reflects a common belief that the transformation has a positive effect on the analysis of programs....

Cormac Flanagan, Cormac Flanagan, Cormac Flanagan, Matthias Felleisen, Matthias Felleisen, Matthias Felleisen

The future annotations of MultiLisp provide a simple method for taming the implicit parallelism of functional programs, but require touch operations at all placeholderstrict positions of program...

Extensible denotational language specifications (1994)

Robert Cartwright, Robert Cartwright, Matthias Felleisen, Matthias Felleisen

Abstract. Traditional denotational semantics assigns radically different meanings to one and the same phrase depending on the rest of the programming language. If the language is purely functional,...

Extensible Denotational Language Specifications (1994)

Robert Cartwright And, Robert Cartwright, Robert Cartwright, Matthias Felleisen, Matthias Felleisen

. Traditional denotational semantics assigns radically different meanings to one and the same phrase depending on the rest of the programming language. If the language is purely functional, the...

Is Continuation-Passing Useful for Data Flow Analysis? (1994)

Fully abstract semantics for observably sequential languages (1994)

The widespread use of the continuation-passing style (CPS) transformation in compilers, optimizers, abstract interpreters, and partial evaluators reflects a common belief that the transformation has...

Robert Cartwright, Robert Cartwright, Pierre-louis Curien, Pierre-louis Curien, Matthias Felleisen, Matthias Felleisen

One of the major challenges in denotational semantics is the construction of a fully abstract semantics for a higher-order sequential programming language. For the past fifteen years, research on...

Fully abstract semantics for observably sequential languages (1994)

Robert Cartwright, Robert Cartwright, Pierre-louis Curien, Pierre-louis Curien, Matthias Felleisen, Matthias Felleisen

One of the major challenges in denotational semantics is the construction of a fully abstract semantics for a higher-order sequential programming language. For the past fifteen years, research on...

On the orthogonality of assignments and procedures in Algol (1993)

Stephen Weeks, Matthias Felleisen

on Principles of Programming Languages, January 10--13, 1993, Charleston, South Carolina

Reasoning about programs in continuation-passing style (1993)

Reasoning about programs in continuation-passing style (1993)

Abstract. Plotkin's v-calculus for call-by-value programs is weaker than the fij-calculus for the same programs in continuation-passing style (CPS). To identify the callby-value axioms that...

The essence of compiling with continuations (1993)

Plotkin's-value calculus is sound but incomplete for reasoning about fij-transformations on programs in continuation-passing style (CPS). To find a complete extension, we define a new,...

Cormac Flanagan, Amr Sabry, Bruce F. Duba, Matthias Felleisen

In order to simplify the compilation process, many compilers for higher-order languages use the continuationpassing style (CPS) transformation in a first phase to generate an intermediate...

Reasoning about programs in continuation-passing style (1993)

Amr Sabry, Amr Sabry, Matthias Felleisen, Matthias Felleisen

Plotkin's-value calculus is sound but incomplete for reasoning about fij-transfor-mations on programs in continuation-passing style (CPS). To find a complete extension, we define a new,...

Reasoning about programs in continuation-passing style (1993)

The essence of compiling with continuations (1993)

Abstract. Plotkin's v-calculus for call-by-value programs is weaker than the fij-calculus for the same programs in continuation-passing style (CPS). To identify the callby-value axioms that...

Cormac Flanagan, Amr Sabry, Bruce F. Duba, Matthias Felleisen

In order to simplify the compilation process, many compilers for higher-order languages use the continuationpassing style (CPS) transformation in a first phase to generate an intermediate...

On the Orthogonality of Assignments and Procedures in Algol (1993)

Stephen Weeks Matthias, Matthias Felleisen

According to folklore, Algol is an "orthogonal" extension of a simple imperative programming language with a call-by-name functional language. The former contains assignments, branching...

The Essence of Compiling with Continuations (1993)

Cormac Flanagan, Amr Sabry, Bruce F. Duba, Matthias Felleisen

In order to simplify the compilation process, many compilers for higher-order languages use the continuationpassing style (CPS) transformation in a first phase to generate an intermediate...

On the Orthogonality of Assignments and Procedures in Algol (1993)

Stephen Weeks, Matthias Felleisen

According to folklore, Algol is an "orthogonal" extension of a simple imperative programming language with a call-by-name functional language. The former contains assignments, branching...

The Call-By-Need Lambda Calculus (1993)

Zena Ariola, Matthias Felleisen

Plotkin [Theor. Comp. Sci. 1975] showed that the lambda calculus is a good model of the evaluation process for call-by-name functional programs. Reducing programs to constants or lambda abstractions...

Observable sequentiality and full abstraction (1992)

The Revised Report on the Syntactic Theories of Sequential Control and State (1992)

One of the major challenges in denotational semantics is the construction of fully abstract models for sequential programming languages. For the past fifteen years, research on this problem has...

Matthias Felleisen, Matthias Felleisen, Robert Hieb, Robert Hieb

The syntactic theories of control and state are conservative extensions of the v -calculus for equational reasoning about imperative programming facilities in higher-order languages. Unlike the...

A Syntactic Approach to Type Soundness (1992)

Andrew K. Wright, Matthias Felleisen

We present a new approach to proving type soundness for Hindley/Milner-style polymorphic type systems. The keys to our approach are (1) an adaptation of subject reduction theorems from combinatory...

Reasoning with Continuations II: Full Abstraction for Models of Control Two Corrections (1992)

Dorai Sitaram, Matthias Felleisen

ion for Models of Control Two Corrections Dorai Sitaram Matthias Felleisen Department of Computer Science Rice University Houston, TX 77251-1892 July 29, 1992 1 Environments for Pcf v The original...

The Revised Report on the Syntactic Theories of Sequential Control and State (1992)

Matthias Felleisen, Matthias Felleisen, Robert Hieb, Robert Hieb

The syntactic theories of control and state are conservative extensions of the v -calculus for equational reasoning about imperative programming facilities in higher-order languages. Unlike the...

Parameter-Passing and the Lambda Calculus Erik Crank (1991)

Reasoning with Continuations II: Full Abstraction for Models of Control (1990)

The choice of a parameter-passing technique is an important decision in the design of a high-level programming language. To clarify some of the semantic aspects of the decision, we develop, analyze,...

Dorai Sitaram, Matthias Felleisen

A fully abstract model of a programming language assigns the same meaning to two terms if and only if they have the same operational behavior. Such models are well-known for functional languages but...

On the Expressive Power of Programming Languages (1990)

The semantics of program dependence (1989)

The literature on programming languages contains an abundance of informal claims on the relative expressive power of programming languages, but there is no framework for formalizing such statements...

The calculi of lambda-v-cs conversion :--a syntactic theory of control and state in imperative higher-order programming languages /--Matthias Felleisen. (1987)

Optimizing and parallelizing compilers for procedural languages rely on various forms of program dependence graphs (pdgs) to express the essential control and data dependences among atomic program...

Felleisen, Matthias.

Vita.

Why Computer Science Doesn't Matter (0000)

Felleisen, Matthias

Aligning computer science with high school mathematics can help turn it into an essential subject for all students.

Reasoning about Programs in Continuation-Passing Style

Amr Sabry, Amr Sabry, Matthias Felleisen, Matthias Felleisen

Plotkin's -value calculus is sound but incomplete for reasoning about fij-transfor- mations on programs in continuation-passing style (CPS). To find a complete extension, we define a new,...

A Programmer's Reduction Semantics for Classes and Mixins

Matthew Flatt, Shriram Krishnamurthi, Matthias Felleisen

. While class-based object-oriented programming languages provide a flexible mechanism for re-using and managing related pieces of code, they typically lack linguistic facilities for specifying a...

Reasoning about Programs in Continuation-Passing Style