Why Is Matthias Felleisen Influential?
According to Wikipedia , Matthias Felleisen is a German-American computer science professor and author. He grew up in Germany and immigrated to the US when he was 21 years old. He received his PhD from Indiana University under the direction of Daniel P. Friedman.
Matthias Felleisen's Published Works
Number of citations in a given year to any of this author's works
Total number of citations to an author for the works they published in a given year. This highlights publication of the most important work(s) by the author
1990 2000 2010 2020 0 125 250 375 500 625 750 875 1000 1125 1250 1375 1500 Published Papers A Syntactic Approach to Type Soundness The Revised Report on the Syntactic Theories of Sequential Control and State The essence of compiling with continuations Classes and mixins Contracts for higher-order functions DrScheme: a programming environment for Scheme A call-by-need lambda calculus The theory and practice of first-class prompts The design and implementation of typed scheme Hygienic macro expansion Control operators, the SECD-machine, and the λ-calculus (298) Semantics Engineering with PLT Redex (289) On the Expressive Power of Programming Languages Units: cool modules for HOT languages A Syntactic Theory of Sequential Control Reasoning about programs in continuation-passing style Interlanguage migration: from scripts to programs Reasoning about programs in continuation-passing style. Languages as libraries The calculi of lambda-nu-cs conversion: a syntactic theory of control and state in imperative higher-order programming languages (186) A Programmer's Reduction Semantics for Classes and Mixins How to design programs: an introduction to programming and computing Componential set-based analysis Abstract models of memory management How to Design Programs (126) The semantics of program dependence Logical types for untyped languages Synthesizing Object-Oriented and Functional Design to Promote Re-Use Contract Soundness for object-oriented languages DrScheme: A Pedagogic Programming Environment for Scheme Catching bugs in the web of program invariants Run your research: on the effectiveness of lightweight mechanization Reasoning with Continuations (100) The semantics of future and its use in program optimization The TeachScheme! Project: Computing and Programming for Every Student The Semantics of Future (97) Transferring Skills at Solving Word Problems from Computing to Algebra Through Bootstrap Is sound gradual typing dead? Validating the unit correctness of spreadsheet programs On the expressive power of programming languages Behavioral contracts and behavioral subtyping Control delimiters and their hierarchies Fully Abstract Semantics for Observably Sequential Languages The call-by-need lambda calculus on the Principles of Programming Languages (87) Correct blame for contracts: no more scapegoating Abstract continuations: a mathematical semantics for handling full jumps A functional I/O system or, fun for freshman kids A Syntactic Theory of Sequential State Modeling an Algebraic Stepper A calculus for assignments in higher-order languages Observable sequentiality and full abstraction Automatically Restructuring Programs for the Web The DrScheme project: an overview Modeling Web Interactions The Semantics of Future and an Application Programming languages as operating systems (or revenge of the son of the lisp machine) Reasoning with continuations II: full abstraction for models of control Implementation and use of the PLT scheme Web server Gradual typing for first-class classes Complete Monitors for Behavioral Contracts A Visual Environment for Developing Context-Sensitive Term Rewriting Systems Scheme with Classes, Mixins, and Traits ViewpointWhy computer science doesn't matter The Racket Manifesto The structure and interpretation of the computer science curriculum Continuations from generalized stack inspection Parameter-passing and the lambda calculus Is continuation-passing useful for data flow analysis? A programmable programming language Programming languages and lambda calculi (47) On contract satisfaction in a higher-order world A tail-recursive machine with stack inspection Adding delimited and composable control to a production programming environment Modular set-based analysis from contracts The Call-by-need Lambda Calculus, Revisited A Reduction Semantics for Imperative Higher-Order Languages Programming languages for reusable software components (36) A little Java, a few patterns Semantic Casts: Contracts and Structural Subtyping in a Nominal World Optimization coaching: optimizers learn to communicate with programmers Towards Practical Gradual Typing A functional I/O system or, fun for freshman kids Automatically restructuring programs for the Web Expressing Structural Properties as Language Constructs A spectrum of type soundness and performance From Macros to Reusable Generative Programming The essence of compiling with continuations (with retrospective) (27) A Tail-Recursive Semantics for Stack Inspections &lgr;-V-CS: an extended &lgr;-calculus for scheme How to Design Programs: An Introduction to Computing and Programming (25) Linguistic reuse (25) Set-Based Analysis for Full Scheme and Its Use in Soft-Typing (25) An Investigation of Contracts as Projections (24) Toward a formal theory of extensible software Reflections on Landins's J-Operator: A Partly Historical Note On the orthogonality of assignments and procedures in Algol Migratory Typing: Ten Years Later Programming in Standard ML (20) Practical Variable-Arity Polymorphism Typing the Numeric Tower Future contracts Little Languages and Their Programming Environments (19) Contracts for first-class classes ACL2 in DrScheme Componential Set-Based Analysis Modeling web interactions and errors The Little Schemer (17) Automatically restructuring software for the web (16) Program verification through soft typing Fostering Little Languages (16) A Closer Look at Export and Import Statements How to evaluate the performance of gradual type systems SPCF: Its Model, Calculus, and Computational Power (Preliminary Version) Modular and Polymorphic Set-Based Analysis: Theory and Practice (14) Contracts for First-Class Classes Fortifying macros Option contracts Functional programming and theorem proving for undergraduates: a progress report Contracts for first-class modules Feature-Specific Profiling The design and implementation of typed scheme The seasoned schemer Environmental Acquisition in Network Management (12) Debugging hygienic macros Behavioral Interface Contracts for Java (12) Debugging macros The little MLer (11) Oh Lord, please don't let contracts be misunderstood (functional pearl) Taming Macros Nested and Dynamic Contract Boundaries Contracts for higher-order functions Memory for Functions (9) Super 8 languages for making movies (functional pearl) Programming Languages and Systems The Network as a Language Construct The Semantics of Futures (8) The Essence of Compiling with Continuations Object-oriented Programming Languages Need Well-founded Contracts (8) Static Debugging: Browsing the Web of Program Invariants Building Little Languages With Macros (7) Profiling for laziness ICFP 2002: Contracts for higher-order functions Coordinated Concurrent Programming in Syndicate Toward a Practical Module System for ACL2 Realm of Racket - Learn to Program, One Game at a Time! (6) Environmental acquisition revisited Computing curricula 2001 draft Well-Founded Touch Optimization for Futures (6) lambda-V-CS: An Extended lambda-Calculus for Scheme. (5) How to design class hierarchies Programming Languages and Lambda Calculi (Summer 2006 Revised Version) (5) Refining syntactic sugar: tools for supporting macro development (5) Extensible Denotational Language Speciications Extensible Denotational Language Specifications ? 2 Extensible Operational Semantics Are Expressions, with X Possibly Free in E, 4 (5) Integrating Logic into the Computer Science Curriculum (5) Automatic verification for interactive graphical programs Models of continuations without continuations Languages as libraries Hygienic Macros for ACL2 Methods to Our Madness (5) Developing Interactive Web Programs Evaluating Call-by-Need on the Control Stack Complete monitors for gradual types A New Way of Debugging Lisp Programs (3) Adding interactive visual syntax to textual code Is sound gradual typing dead? TeachScheme!: a checkpoint Gradual typing for first-class classes The little LISPer (2nd ed.) (3) Safety as a metric A Stepper for Scheme Macros (2) Proceedings of the 34th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages Modular proof development in acl2 (2) The Technology that Computer Science Education Overlooked (2) Reasoning with Continuations Iii: a Complete Calculus of Control (2) Proceedings of the third ACM SIGPLAN international conference on Functional programming Logical types for untyped languages Foundations for behavioral higher-order contracts (2) From Macros to DSLs: The Evolution of Racket Feature-Specific Profiling Well-Shaped Macros (2) The little Schemer (4th ed.) (2) Making induction manifest in modular ACL2 Proceedings of the 1999 Workshop on Functional and Declarative Programming in Education (1) The State of Things to Come (1) Macros for domain-specific languages Think It Through (1) Learning the Rules Why teach programming languages in this day and age and how to go about it The Loss of Knowledge (1) How to evaluate blame for gradual types The Design and Implementation of Typed Scheme: From Scripts to Programs (1) Componential Set-Based Analysis Proceedings of the 34th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2007, Nice, France, January 17-19, 2007 Functional Objects Run your research: on the effectiveness of lightweight mechanization How to Design Programs, 2e (1) Stepping Lazy Programs (1) Software for Article From Stack Traces to Lazy Rewriting Sequences From POPL to the classroom and back Sequence Traces for Object-Oriented Executions (1) Environmental acquisition revisited On the Effectiveness of Lightweight Mechanization (1) Correct blame for contracts: no more scapegoating Is Continuation-Passing Useful for Data Flow Analysis? Optimization coaching: optimizers learn to communicate with programmers Adding types to untyped languages Profiling for laziness Contracts for first-class classes Adding delimited and composable control to a production programming environment Linguistic Support for Unit Testing UUCS-07-013 (1) Editorial Debugging Hygienic Macros 1 (0) Intermezzo 4: Defining Functions on the Fly (0) Designing Abstractions with First-Class Functions (0) Scaling contracts to realistic languages (0) Even Older Games (0) Computer Science Does Matter (0) A Transient Semantics for Typed Racket Similarities in Definitions (0) More Uses of Accumulation (0) Intermezzo 6: The Nature of Inexact Numbers (0) Contracts for First-Class Classes Technical Report NU-CCIS-1004 T (0) Behavioral Interface Contracts for Java ( Rice University CS TR 00-366 ) (0) Option contracts Come to Our Carousel (0) Position Paper : Performance Evaluation for Gradual Typing (0) The Semantics of Program Dependence NLE volume 22 issue 4 Cover and Back matter Processing Simple Forms of Data (0) Implementing a Static Debugger for a First-Order Functional Programming Language (0) Changing the State of Variables (0) Functions are Values (0) Oh Lord, please don't let contracts be misunderstood (functional pearl) Changong Structures, Vectors, and Objects (0) Variable-Arity Polymorphism T (0) Components and program analyses Well-founded Touch Optimization for Futures Well-founded Touch Optimization for Futures (0) CPC volume 21 issue 1-2 Cover and Back matter The Proof of the Pudding Part of This Total Breakfast (0) Observable Sequentiality and Full AbstractionRobert (0) Modular set-based analysis from contracts From POPL to the classroom and back Prehistory of Programming Languages (0) Hygenic Macro Expansion History of Programming Languages (0) A New Form of Recursion (0) Intermezzo 2: List Abbreviations (0) Session details: Keynote session Multilingual component programming in racket Parameter-Passing and the Lambda CalculusErik Crank (0) Conditional Expressions and Functions (0) Editorial Tutorial on Static Inference of Numeric (0) Restless for More (0) More Self-referential Data Definitions (0) Designing Functions with Memory (0) Contract Soundness for Object-Oriented Languages Multilingual component programming in racket Functional Programming 1 EDUCATIONAL PEARL The Structure and Interpretation of the Computer Science Curriculum (0) Mutually Referential Data Definitions (0) The Little Assistant (0) SIGPLAN Response to the Ironman Draft of the Computing Curricula 2001 (0) Compound Data, Part 1: Structures (0) Flow-Dire ted Lightweight Closure ConversionJEFFREY (0) Intermezzo 7: The Final Syntax and Semantics (0) Welcome to the Educational Pearls Column Typed dataspace actors Assignments to Variables (0) The Semantics of Future the Semantics of Future (0) The Essence of Compiling with ContinuationsCormac Flanagan (0) Editorial Numbers, Expressions, Simple Programs (0) The Lambda Calculus and Operational Semantics (0) Processing Arbitrarily Large Data (0) CPC volume 23 issue 4 Cover and Back matter TeachScheme!: a checkpoint The Varieties of Data (0) Programming Languages as Operating Systems (or Revenge of the Son of the Lisp Machine) Session details: Relating and integrating static and dynamic checks The first year Designing Accumulator-Style Functions (0) Units: Cool Modules for HOT Languages The little schemer (4. ed.) (0) Modular ACL2 (0) Little Languages and their Programming Environments Rice University Technical Report TR 99-350 (0) Examples of Memory Usage (0) Composing Functions, Revisited Again (0) Program Units as Higher-Order Modules Intermezzo 1: Syntax and Semantics (0) Fortifying macros Algorithms that Backtrack (0) Editorial Intermezzo 3: Local Definitions and Lexical Scope (0) Intermezzo 5: The Cost of Computing and Vectors (0) Designing Functions that Change Structures (0) Old Games, New Rules (0) More on Processing Arbitrarily Large Data (0) Software Contracts in a Higher-order World Variations on a Theme (0) Behavioral contracts and behavioral subtyping More on Processing Lists (0) Be a Good Visitor (0) Think It Over, and Over, and Over (0) Specifying Finite-State Actors ? (0) Toward a Formal Theory of Extensible Software A design-based introductory computer science course Students, Teachers, and Computers (0) Proceedings of the 22nd European conference on Programming Languages and Systems (0) Processing Two Complex Pieces of Data (0) Programs are Function Plus Variable Definitions (0) The Stars Are Aligned (0) Appendix A : DiSTiL Realms and Components (0) Changing the Rules (0) Designing Abstractions from Examples (0) Objects Are People, Too (0) Development through Iterative Refinement (0) Oh My, Stars! (0) Changing Compound Values (0) Contracts for first-class modules Continuations from generalized stack inspection More Papers This paper list is powered by the following services:
Other Resources About Matthias Felleisen What Schools Are Affiliated With Matthias Felleisen? Matthias Felleisen is affiliated with the following schools:
Matthias Felleisen's AcademicInfluence.com Rankings
