Matthias Felleisen

181 papers A* 28A 34B 5C 6Journal 68Unranked 34

Year	Rank	Type	Title / Venue / Authors
2026	J	`jnl`	Mixing Visual and Textual Code. CoRR Leif Andersen, Michael Ballantyne, Cameron Moy, Matthias Felleisen, Stephen Chang
2026	J	`jnl`	Navigating Mixed-Typed Migration with Profilers. ACM Trans. Program. Lang. Syst. Nathaniel Hejduk, Ben Greenman, Matthias Felleisen, Christos Dimoulas
2025	J	`jnl`	Contract Systems Need Domain-Specific Notations (Artifact). Dagstuhl Artifacts Ser. Cameron Moy, Ryan Jung, Matthias Felleisen
2025	A	`conf`	Contract Systems Need Domain-Specific Notations (Pearl/Brave New Idea). ECOOP Cameron Moy, Ryan Jung, Matthias Felleisen
2025	J	`jnl`	Conversational Concurrency with Dataspaces and Facets. CoRR Samuel Caldwell, Tony Garnock-Jones, Matthias Felleisen
2025	J	`jnl`	Conversational Concurrency with Dataspaces and Facets. Art Sci. Eng. Program. Samuel Caldwell, Tony Garnock-Jones, Matthias Felleisen
2025	J	`jnl`	Conversational Concurrency with Dataspaces and Facets. Art Sci. Eng. Program. Samuel Caldwell, Tony Garnock-Jones, Matthias Felleisen
2025	J	`jnl`	The Rational Programmer: Investigating Programming Language Pragmatics. Commun. ACM Christos Dimoulas, Matthias Felleisen
2024	J	`jnl`	Effectful Software Contracts. Proc. ACM Program. Lang. Cameron Moy, Christos Dimoulas, Matthias Felleisen
2024	J	`jnl`	Making Hybrid Languages: A Recipe. CoRR Leif Andersen, Cameron Moy, Stephen Chang, Matthias Felleisen
2024	J	`jnl`	Programming and reasoning about actors that share state. J. Funct. Program. Samuel Caldwell, Tony Garnock-Jones, Matthias Felleisen
2024	J	`jnl`	Type Tailoring (Artifact). Dagstuhl Artifacts Ser. Ashton Wiersdorf, Stephen Chang, Matthias Felleisen, Ben Greenman
2024	A	`conf`	Type Tailoring. ECOOP Ashton Wiersdorf, Stephen Chang, Matthias Felleisen, Ben Greenman
2023	J	`jnl`	How Profilers Can Help Navigate Type Migration. Proc. ACM Program. Lang. Ben Greenman, Matthias Felleisen, Christos Dimoulas
2023	J	`jnl`	How to Evaluate Blame for Gradual Types, Part 2. Proc. ACM Program. Lang. Lukas Lazarek, Ben Greenman, Matthias Felleisen, Christos Dimoulas
2023	—	`conf`	Injecting Language Workbench Technology into Mainstream Languages. Eelco Visser Commemorative Symposium Michael Ballantyne, Matthias Felleisen
2023	J	`jnl`	Trace contracts. J. Funct. Program. Cameron Moy, Matthias Felleisen
2023	J	`jnl`	Typed-Untyped Interactions: A Comparative Analysis. ACM Trans. Program. Lang. Syst. Ben Greenman, Christos Dimoulas, Matthias Felleisen
2022	J	`jnl`	A Transient Semantics for Typed Racket. Art Sci. Eng. Program. Ben Greenman, Lukas Lazarek, Christos Dimoulas, Matthias Felleisen
2021	J	`jnl`	A Transient Semantics for Typed Racket. CoRR Ben Greenman, Lukas Lazarek, Christos Dimoulas, Matthias Felleisen
2021	J	`jnl`	How to evaluate blame for gradual types. Proc. ACM Program. Lang. Lukas Lazarek, Ben Greenman, Matthias Felleisen, Christos Dimoulas
2020	J	`jnl`	Adding Interactive Visual Syntax to Textual Code. CoRR Leif Andersen, Michael Ballantyne, Matthias Felleisen
2020	J	`jnl`	Adding interactive visual syntax to textual code. Proc. ACM Program. Lang. Leif Andersen, Michael Ballantyne, Matthias Felleisen
2020	J	`jnl`	Macros for domain-specific languages. Proc. ACM Program. Lang. Michael Ballantyne, Alexis King, Matthias Felleisen
2020	J	`jnl`	Typed dataspace actors. J. Funct. Program. Samuel Caldwell, Tony Garnock-Jones, Matthias Felleisen
2019	J	`jnl`	Complete monitors for gradual types. Proc. ACM Program. Lang. Ben Greenman, Matthias Felleisen, Christos Dimoulas
2019	J	`jnl`	Feature-Specific Profiling. ACM Trans. Program. Lang. Syst. Leif Andersen, Vincent St-Amour, Jan Vitek, Matthias Felleisen
2019	—	`conf`	From Macros to DSLs: The Evolution of Racket. SNAPL Ryan Culpepper, Matthias Felleisen, Matthew Flatt, Shriram Krishnamurthi
2019	J	`jnl`	How to evaluate the performance of gradual type systems. J. Funct. Program. Ben Greenman, Asumu Takikawa, Max S. New, Daniel Feltey, Robert Bruce Findler, Jan Vitek, Matthias Felleisen
2018	J	`jnl`	A programmable programming language. Commun. ACM Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi, Eli Barzilay, Jay A. McCarthy, Sam Tobin-Hochstadt
2018	J	`jnl`	A spectrum of type soundness and performance. Proc. ACM Program. Lang. Ben Greenman, Matthias Felleisen
2018	J	`jnl`	Feature-Specific Profiling. CoRR Leif Andersen, Vincent St-Amour, Jan Vitek, Matthias Felleisen
2017	—	`conf`	Migratory Typing: Ten Years Later. SNAPL Sam Tobin-Hochstadt, Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Ben Greenman, Andrew M. Kent, Vincent St-Amour, T. Stephen Strickland, Asumu Takikawa
2017	J	`jnl`	Super 8 languages for making movies (functional pearl). Proc. ACM Program. Lang. Leif Andersen, Stephen Chang, Matthias Felleisen
2016	A	`conf`	Coordinated Concurrent Programming in Syndicate. ESOP Tony Garnock-Jones, Matthias Felleisen
2016	A*	`conf`	Is sound gradual typing dead? POPL Asumu Takikawa, Daniel Feltey, Ben Greenman, Max S. New, Jan Vitek, Matthias Felleisen
2016	A	`conf`	Oh Lord, please don't let contracts be misunderstood (functional pearl). ICFP Christos Dimoulas, Max S. New, Robert Bruce Findler, Matthias Felleisen
2015	B	`conf`	Feature-Specific Profiling. CC Vincent St-Amour, Leif Andersen, Matthias Felleisen
2015	—	`conf`	The Racket Manifesto. SNAPL Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi, Eli Barzilay, Jay A. McCarthy, Sam Tobin-Hochstadt
2015	A	`conf`	Towards Practical Gradual Typing. ECOOP Asumu Takikawa, Daniel Feltey, Earl Dean, Matthew Flatt, Robert Bruce Findler, Sam Tobin-Hochstadt, Matthias Felleisen
2015	A	`conf`	Transferring Skills at Solving Word Problems from Computing to Algebra Through Bootstrap. SIGCSE Emmanuel Schanzer, Kathi Fisler, Shriram Krishnamurthi, Matthias Felleisen
2014	J	`jnl`	Editorial. J. Funct. Program. Matthias Felleisen
2014	A*	`conf`	Profiling for laziness. POPL Stephen Chang, Matthias Felleisen
2014	A	`conf`	The Network as a Language Construct. ESOP Tony Garnock-Jones, Sam Tobin-Hochstadt, Matthias Felleisen
2013	J	`jnl`	Contracts for First-Class Classes. ACM Trans. Program. Lang. Syst. T. Stephen Strickland, Christos Dimoulas, Asumu Takikawa, Matthias Felleisen
2013	J	`jnl`	ICFP 2002: Contracts for higher-order functions. ACM SIGPLAN Notices Robert Bruce Findler, Matthias Felleisen
2013	A	`conf`	Option contracts. OOPSLA Christos Dimoulas, Robert Bruce Findler, Matthias Felleisen
2013	A	`ed.`	Programming Languages and Systems - 22nd European Symposium on Programming, ESOP 2013, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2013, Rome, Italy, March 16-24, 2013. Proceedings ESOP Matthias Felleisen, Philippa Gardner
2013	—	`book`	Realm of Racket - Learn to Program, One Game at a Time! Matthias Felleisen, David Van Horn, Conrad Barski
2012	A	`conf`	Complete Monitors for Behavioral Contracts. ESOP Christos Dimoulas, Sam Tobin-Hochstadt, Matthias Felleisen
2012	J	`jnl`	Editorial. J. Funct. Program. Matthias Felleisen
2012	A	`conf`	Gradual typing for first-class classes. OOPSLA Asumu Takikawa, T. Stephen Strickland, Christos Dimoulas, Sam Tobin-Hochstadt, Matthias Felleisen
2012	A	`conf`	Optimization coaching: optimizers learn to communicate with programmers. OOPSLA Vincent St-Amour, Sam Tobin-Hochstadt, Matthias Felleisen
2012	A*	`conf`	Run your research: on the effectiveness of lightweight mechanization. POPL Casey Klein, John Clements, Christos Dimoulas, Carl Eastlund, Matthias Felleisen, Matthew Flatt, Jay A. McCarthy, Jon Rafkind, Sam Tobin-Hochstadt, Robert Bruce Findler
2012	A	`conf`	The Call-by-Need Lambda Calculus, Revisited. ESOP Stephen Chang, Matthias Felleisen
2012	J	`jnl`	The Call-by-need Lambda Calculus, Revisited CoRR Stephen Chang, Matthias Felleisen
2012	C	`conf`	Typing the Numeric Tower. PADL Vincent St-Amour, Sam Tobin-Hochstadt, Matthew Flatt, Matthias Felleisen
2011	A*	`conf`	Correct blame for contracts: no more scapegoating. POPL Christos Dimoulas, Robert Bruce Findler, Cormac Flanagan, Matthias Felleisen
2011	—	`conf`	From Stack Traces to Lazy Rewriting Sequences. IFL Stephen Chang, Eli Barzilay, John Clements, Matthias Felleisen
2011	A*	`conf`	Languages as libraries. PLDI Sam Tobin-Hochstadt, Vincent St-Amour, Ryan Culpepper, Matthew Flatt, Matthias Felleisen
2011	B	`conf`	Multilingual component programming in racket. GPCE Matthias Felleisen
2011	J	`jnl`	On contract satisfaction in a higher-order world. ACM Trans. Program. Lang. Syst. Christos Dimoulas, Matthias Felleisen
2011	J	`jnl`	Stepping Lazy Programs CoRR Stephen Chang, John Clements, Eli Barzilay, Matthias Felleisen
2011	A	`conf`	TeachScheme! SIGCSE Matthias Felleisen
2011	J	`jnl`	The Design and Implementation of Typed Scheme: From Scripts to Programs CoRR Sam Tobin-Hochstadt, Matthias Felleisen
2010	—	`conf`	Adding types to untyped languages. TLDI Matthias Felleisen
2010	C	`conf`	Contracts for first-class classes. DLS T. Stephen Strickland, Matthias Felleisen
2010	J	`jnl`	Debugging hygienic macros. Sci. Comput. Program. Ryan Culpepper, Matthias Felleisen
2010	J	`jnl`	Evaluating Call-By-Need on the Control Stack CoRR Stephen Chang, David Van Horn, Matthias Felleisen
2010	—	`conf`	Evaluating Call-by-Need on the Control Stack. Trends in Functional Programming Stephen Chang, David Van Horn, Matthias Felleisen
2010	A	`conf`	Fortifying macros. ICFP Ryan Culpepper, Matthias Felleisen
2010	—	`conf`	Hygienic Macros for ACL2. Trends in Functional Programming Carl Eastlund, Matthias Felleisen
2010	A	`conf`	Logical types for untyped languages. ICFP Sam Tobin-Hochstadt, Matthias Felleisen
2010	A	`conf`	TeachScheme!: a checkpoint. ICFP Matthias Felleisen
2009	A	`conf`	A functional I/O system or, fun for freshman kids. ICFP Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi
2009	C	`conf`	Contracts for first-class modules. DLS T. Stephen Strickland, Matthias Felleisen
2009	J	`jnl`	Editorial. J. Funct. Program. Xavier Leroy, Matthias Felleisen
2009	C	`conf`	Future contracts. PPDP Christos Dimoulas, Riccardo Pucella, Matthias Felleisen
2009	C	`conf`	Making induction manifest in modular ACL2. PPDP Carl Eastlund, Matthias Felleisen
2009	—	`conf`	Nested and Dynamic Contract Boundaries. IFL T. Stephen Strickland, Matthias Felleisen
2009	A	`conf`	Practical Variable-Arity Polymorphism. ESOP T. Stephen Strickland, Sam Tobin-Hochstadt, Matthias Felleisen
2009	—	`book`	Semantics Engineering with PLT Redex. Matthias Felleisen, Robert Bruce Findler, Matthew Flatt
2009	C	`conf`	Toward a Practical Module System for ACL2. PADL Carl Eastlund, Matthias Felleisen
2009	J	`jnl`	Viewpoint - Why computer science doesn't matter. Commun. ACM Matthias Felleisen, Shriram Krishnamurthi
2008	—	`conf`	Functional programming and theorem proving for undergraduates: a progress report. FDPE@ICFP Rex L. Page, Carl Eastlund, Matthias Felleisen
2008	A*	`conf`	The design and implementation of typed scheme. POPL Sam Tobin-Hochstadt, Matthias Felleisen
2008	J	`jnl`	Why teach programming languages in this day and age and how to go about it. ACM SIGPLAN Notices Matthias Felleisen
2007	A	`conf`	Adding delimited and composable control to a production programming environment. ICFP Matthew Flatt, Gang Yu, Robert Bruce Findler, Matthias Felleisen
2007	B	`conf`	Debugging macros. GPCE Ryan Culpepper, Matthias Felleisen
2007	J	`jnl`	Implementation and use of the PLT scheme Web server. High. Order Symb. Comput. Shriram Krishnamurthi, Peter Walton Hopkins, Jay A. McCarthy, Paul T. Graunke, Greg Pettyjohn, Matthias Felleisen
2007	A*	`ed.`	Proceedings of the 34th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2007, Nice, France, January 17-19, 2007 POPL Martin Hofmann, Matthias Felleisen
2006	—	`conf`	ACL2 in DrScheme. ACL2 Dale Vaillancourt, Rex L. Page, Matthias Felleisen
2006	—	`conf`	Interlanguage migration: from scripts to programs. OOPSLA Companion Sam Tobin-Hochstadt, Matthias Felleisen
2006	A*	`conf`	Modular set-based analysis from contracts. POPL Philippe Meunier, Robert Bruce Findler, Matthias Felleisen
2006	B	`conf`	Scheme with Classes, Mixins, and Traits. APLAS Matthew Flatt, Robert Bruce Findler, Matthias Felleisen
2005	A	`conf`	Continuations from generalized stack inspection. ICFP Greg Pettyjohn, John Clements, Joe Marshall, Shriram Krishnamurthi, Matthias Felleisen
2005	J	`jnl`	Editorial. High. Order Symb. Comput. Matthias Felleisen, Julia Lawall, Manuel Serrano, Olin Shivers
2005	A*	`conf`	Environmental acquisition revisited. POPL Richard Cobbe, Matthias Felleisen
2005	—	`conf`	How to design class hierarchies. FDPE@ICFP Matthias Felleisen
2005	J	`jnl`	The first year. J. Comput. Sci. Coll. Matthias Felleisen
2004	—	`conf`	A Visual Environment for Developing Context-Sensitive Term Rewriting Systems. RTA Jacob Matthews, Robert Bruce Findler, Matthew Flatt, Matthias Felleisen
2004	J	`jnl`	A tail-recursive machine with stack inspection. ACM Trans. Program. Lang. Syst. John Clements, Matthias Felleisen
2004	J	`jnl`	Automatically Restructuring Programs for the Web. Autom. Softw. Eng. Jacob Matthews, Robert Bruce Findler, Paul T. Graunke, Shriram Krishnamurthi, Matthias Felleisen
2004	A	`conf`	Functional Objects. ECOOP Matthias Felleisen
2004	A	`conf`	Semantic Casts: Contracts and Structural Subtyping in a Nominal World. ECOOP Robert Bruce Findler, Matthew Flatt, Matthias Felleisen
2004	B	`conf`	Taming Macros. GPCE Ryan Culpepper, Matthias Felleisen
2004	J	`jnl`	The TeachScheme! Project: Computing and Programming for Every Student. Comput. Sci. Educ. Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi
2004	J	`jnl`	The structure and interpretation of the computer science curriculum. J. Funct. Program. Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi
2004	A*	`conf`	Validating the Unit Correctness of Spreadsheet Programs. ICSE Tudor Antoniu, Paul A. Steckler, Shriram Krishnamurthi, Erich Neuwirth, Matthias Felleisen
2003	A	`conf`	A Tail-Recursive Semantics for Stack Inspections. ESOP John Clements, Matthias Felleisen
2003	A	`conf`	Modeling Web Interactions. ESOP Paul T. Graunke, Robert Bruce Findler, Shriram Krishnamurthi, Matthias Felleisen
2003	J	`jnl`	Welcome to the Educational Pearls Column. J. Funct. Program. Matthias Felleisen
2002	A	`conf`	Contracts for higher-order functions. ICFP Robert Bruce Findler, Matthias Felleisen
2002	—	`conf`	Developing Interactive Web Programs. Advanced Functional Programming Matthias Felleisen
2002	J	`jnl`	DrScheme: a programming environment for Scheme. J. Funct. Program. Robert Bruce Findler, John Clements, Cormac Flanagan, Matthew Flatt, Shriram Krishnamurthi, Paul Steckler, Matthias Felleisen
2002	—	`conf`	Environmental Acquisition in Network Management. LISA Mark Logan, Matthias Felleisen, David N. Blank-Edelman
2002	A*	`conf`	From POPL to the classroom and back. POPL Matthias Felleisen
2001	A*	`conf`	Automatically Restructuring Programs for the We. ASE Paul T. Graunke, Robert Bruce Findler, Shriram Krishnamurthi, Matthias Felleisen
2001	—	`conf`	Behavioral contracts and behavioral subtyping. ESEC / SIGSOFT FSE Robert Bruce Findler, Mario Latendresse, Matthias Felleisen
2001	A	`conf`	Contract Soundness for Object-Oriented Languages. OOPSLA Robert Bruce Findler, Matthias Felleisen
2001	A	`conf`	Modeling an Algebraic Stepper. ESOP John Clements, Matthew Flatt, Matthias Felleisen
2001	A	`conf`	Programming the Web with High-Level Programming Languages. ESOP Paul T. Graunke, Shriram Krishnamurthi, Steve Van Der Hoeven, Matthias Felleisen
2001	J	`jnl`	SIGPLAN Response to the Ironman Draft of the Computing Curricula 2001. ACM SIGPLAN Notices Ron Cytron, Matthias Felleisen
2000	J	`jnl`	Components and program analyses. ACM SIGSOFT Softw. Eng. Notes Matthias Felleisen
1999	—	`conf`	A Programmer's Reduction Semantics for Classes and Mixins. Formal Syntax and Semantics of Java Matthew Flatt, Shriram Krishnamurthi, Matthias Felleisen
1999	J	`jnl`	Componential Set-Based Analysis. ACM Trans. Program. Lang. Syst. Cormac Flanagan, Matthias Felleisen
1999	A	`conf`	Expressing Structural Properties as Language Constructs. ESOP Shriram Krishnamurthi, Yan-David Erlich, Matthias Felleisen
1999	—	`conf`	From Macros to Reusable Generative Programming. GCSE Shriram Krishnamurthi, Matthias Felleisen, Bruce F. Duba
1999	A	`conf`	Programming Languages as Operating Systems (or Revenge of the Son of the Lisp Machine). ICFP Matthew Flatt, Robert Bruce Findler, Shriram Krishnamurthi, Matthias Felleisen
1999	—	`conf`	Safety as a Metric. CSEE&T Matthias Felleisen, Robert Cartwright
1999	J	`jnl`	The Semantics of Future and an Application. J. Funct. Program. Cormac Flanagan, Matthias Felleisen
1998	A*	`conf`	Classes and Mixins. POPL Matthew Flatt, Shriram Krishnamurthi, Matthias Felleisen
1998	A	`ed.`	Proceedings of the third ACM SIGPLAN International Conference on Functional Programming (ICFP '98), Baltimore, Maryland, USA, September 27-29, 1998. ICFP Matthias Felleisen, Paul Hudak, Christian Queinnec
1998	A	`conf`	Synthesizing Object-Oriented and Functional Design to Promote Re-Use. ECOOP Shriram Krishnamurthi, Matthias Felleisen, Daniel P. Friedman
1998	J	`jnl`	The DrScheme Project: An Overview. ACM SIGPLAN Notices Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi
1998	—	`conf`	Toward a Formal Theory of Extensible Software. SIGSOFT FSE Shriram Krishnamurthi, Matthias Felleisen
1998	A*	`conf`	Units: Cool Modules for HOT Languages. PLDI Matthew Flatt, Matthias Felleisen
1997	A*	`conf`	Componential Set-Based Analysis. PLDI Cormac Flanagan, Matthias Felleisen
1997	—	`conf`	DrScheme: A Pedagogic Programming Environment for Scheme. PLILP Robert Bruce Findler, Cormac Flanagan, Matthew Flatt, Shriram Krishnamurthi, Matthias Felleisen
1997	—	`conf`	Program Units as Higher-Order Modules. HOOTS Matthew Flatt, Matthias Felleisen
1997	J	`jnl`	The Call-By-Need lambda Calculus. J. Funct. Program. Zena M. Ariola, Matthias Felleisen
1996	—	`book`	A little Java, a few patterns. Matthias Felleisen, Daniel P. Friedman
1996	J	`jnl`	Program Verification Through Soft Typing. ACM Comput. Surv. Robert Cartwright, Matthias Felleisen
1996	A*	`conf`	Static Debugging: Browsing the Web of Program Invariants. PLDI Cormac Flanagan, Matthew Flatt, Shriram Krishnamurthi, Stephanie Weirich, Matthias Felleisen
1996	—	`book`	The little MLer. Matthias Felleisen, Daniel P. Friedman
1996	—	`book`	The little schemer (4. ed.). Daniel P. Friedman, Matthias Felleisen
1996	—	`book`	The seasoned schemer. Daniel P. Friedman, Matthias Felleisen
1995	—	`conf`	Abstract Models of Memory Management. FPCA J. Gregory Morrisett, Matthias Felleisen, Robert Harper
1995	A*	`conf`	The Call-by-Need Lambda Calculus. POPL Zena M. Ariola, Matthias Felleisen, John Maraist, Martin Odersky, Philip Wadler
1995	A*	`conf`	The Semantics of Future and Its Use in Program Optimizations. POPL Cormac Flanagan, Matthias Felleisen
1994	J	`jnl`	A Syntactic Approach to Type Soundness Inf. Comput. Andrew K. Wright, Matthias Felleisen
1994	—	`conf`	Extensible Denotational Language Specifications. TACS Robert Cartwright, Matthias Felleisen
1994	J	`jnl`	Fully Abstract Semantics for Observably Sequential Languages Inf. Comput. Robert Cartwright, Pierre-Louis Curien, Matthias Felleisen
1994	A*	`conf`	Is Continuation-Passing Useful for Data Flow Analysis? PLDI Amr Sabry, Matthias Felleisen
1993	A*	`conf`	On the Orthogonality of Assignments and Procedures in Algol. POPL Stephen Weeks, Matthias Felleisen
1993	J	`jnl`	Reasoning about Programs in Continuation-Passing Style. LISP Symb. Comput. Amr Sabry, Matthias Felleisen
1993	A*	`conf`	The Essence of Compiling with Continuations. PLDI Cormac Flanagan, Amr Sabry, Bruce F. Duba, Matthias Felleisen
1993	—	`conf`	The essence of compiling with continuations (with retrospective) Best of PLDI Cormac Flanagan, Amr Sabry, Bruce F. Duba, Matthias Felleisen
1992	A*	`conf`	Observable Sequentiality and Full Abstraction. POPL Robert Cartwright, Matthias Felleisen
1992	—	`conf`	Reasoning About Programs in Continuation-Passing Style. LISP and Functional Programming Amr Sabry, Matthias Felleisen
1992	—	`conf`	SPCF: Its Model, Calculus, and Computational Power (Preliminary Version). REX Workshop Ramarao Kanneganti, Robert Cartwright, Matthias Felleisen
1992	J	`jnl`	The Revised Report on the Syntactic Theories of Sequential Control and State. Theor. Comput. Sci. Matthias Felleisen, Robert Hieb
1991	A*	`conf`	Modeling Continuations without Continuations. POPL Dorai Sitaram, Matthias Felleisen
1991	J	`jnl`	On the Expressive Power of Programming Languages. Sci. Comput. Program. Matthias Felleisen
1991	A*	`conf`	Parameter-Passing and the Lambda Calculus. POPL Erik Crank, Matthias Felleisen
1990	J	`jnl`	Control Delimiters and Their Hierarchies. LISP Symb. Comput. Dorai Sitaram, Matthias Felleisen
1990	A	`conf`	On the Expressive Power of Programming Languages. ESOP Matthias Felleisen
1990	—	`conf`	Reasoning with Continuations II: Full Abstraction for Models of Control. LISP and Functional Programming Dorai Sitaram, Matthias Felleisen
1989	J	`jnl`	A Syntactic Theory of Sequential State. Theor. Comput. Sci. Matthias Felleisen, Daniel P. Friedman
1989	A*	`conf`	The Semantics of Program Dependence. PLDI Robert Cartwright, Matthias Felleisen
1988	—	`conf`	Abstract Continuations: A Mathematical Semantics for Handling Full Jumps. LISP and Functional Programming Matthias Felleisen, Mitchell Wand, Daniel P. Friedman, Bruce F. Duba
1988	A*	`conf`	The Theory and Practice of First-Class Prompts. POPL Matthias Felleisen
1988	—	`conf`	lambda-V-CS: An Extended lambda-Calculus for Scheme. LISP and Functional Programming Matthias Felleisen
1987	A*	`conf`	A Calculus for Assignments in Higher-Order Languages. POPL Matthias Felleisen, Daniel P. Friedman
1987	—	`conf`	A Reduction Semantics for Imperative Higher-Order Languages. PARLE (2) Matthias Felleisen, Daniel P. Friedman
1987	J	`jnl`	A Syntactic Theory of Sequential Control. Theor. Comput. Sci. Matthias Felleisen, Daniel P. Friedman, Eugene E. Kohlbecker, Bruce F. Duba
1987	—	`conf`	Control operators, the SECD-machine, and the λ-calculus. Formal Description of Programming Concepts Matthias Felleisen, Daniel P. Friedman
1987	J	`jnl`	Reflections on Landins's J-Operator: A Partly Historical Note. Comput. Lang. Matthias Felleisen
1986	J	`jnl`	A Closer Look at Export and Import Statements. Comput. Lang. Matthias Felleisen, Daniel P. Friedman
1986	—	`conf`	Hygienic Macro Expansion. LISP and Functional Programming Eugene E. Kohlbecker, Daniel P. Friedman, Matthias Felleisen, Bruce F. Duba
1986	A*	`conf`	Reasoning with Continuations LICS Matthias Felleisen, Daniel P. Friedman, Eugene E. Kohlbecker, Bruce F. Duba