Matthew Flatt

Matthew Flatt

Auto-generated profile, based on publicly available information

Matthew Flatt

University of Utah, Salt Lake City, USA

Research Focus & Metrics

Academic Career Length

18Years (2009-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
1 March 2009 in Journal of Functional Programming
Verified
Journal Article
Closed access
PDF file
MSMichael Sperber
Michael Sperber
RDR. Kent Dybvig
R. Kent Dybvig
MFMatthew Flatt
Matthew Flatt
ASAnton VAN Straaten
Anton VAN Straaten
RFRobby Findler
Robby Findler
JMJacob Matthews
Jacob Matthews
Programming languages should be designed not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary. Scheme demonstrates that a very small number of rules for forming expressions, with no restrictions on how they are composed, suffice to form a practical and efficient programming language that is flexible enough to support most of the major programming paradigms in use today. Scheme was one of the first programming languages to incorporate first-class procedures as in the lambda calculus, thereby proving the usefulness of static scope rules and block structure in a dynamically typed language. Scheme was the first major dialect of Lisp to distinguish procedures from lambda expressions and symbols, to use a single lexical environment for all variables, and to evaluate the operator position of a procedure call in the same way as an operand position. By relying entirely on procedure calls to express iteration, Scheme emphasized the fact that tail-recursive procedure calls are essentially gotos that pass arguments. Scheme was the first widely used programming language to embrace first-class escape procedures, from which all previously known sequential control structures can be synthesized. A subsequent version of Scheme introduced the concept of exact and inexact number objects, an extension of Common Lisp's generic arithmetic. More recently, Scheme became the first programming language to support hygienic macros, which permit the syntax of a block-structured language to be extended in a consistent and reliable manner.

1 March 2012 in Journal of Functional Programming
Verified
Journal Article
Closed access
PDF file
MFMatthew Flatt
Matthew Flatt
RCRyan Culpepper
Ryan Culpepper
DDDavid Darais
David Darais
RFRobert Bruce Findler
Robert Bruce Findler
Racket is a large language that is built mostly within itself. Unlike the usual approach taken by non-Lisp languages, the self-hosting of Racket is not a matter of bootstrapping one implementation through a previous implementation, but instead a matter of building a tower of languages and libraries via macros. The upper layers of the tower include a class system, a component system, pedagogic variants of Scheme, a statically typed dialect of Scheme, and more. The demands of this language-construction effort require a macro system that is substantially more expressive than previous macro systems. In particular, while conventional Scheme macro systems handle stand-alone syntactic forms adequately, they provide weak support for macros that share information or macros that use existing syntactic forms in new contexts. This paper describes and models features of the Racket macro system, including support for general compile-time bindings, sub-form expansion and analysis, and environment management. The presentation assumes a basic familiarity with Lisp-style macros, and it takes for granted the need for macros that respect lexical scope. The model, however, strips away the pattern and template system that is normally associated with Scheme macros, isolating a core that is simpler, can support pattern and template forms themselves as macros, and generalizes naturally to Racket's other extensions.

16 October 2023 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
MFMatthew Flatt
Matthew Flatt
TATaylor Allred
Taylor Allred
NANia Angle
Nia Angle
SGStephen De Gabrielle
Stephen De Gabrielle
RFRobert Bruce Findler
Robert Bruce Findler
STSam Tobin-Hochstadt
Sam Tobin-Hochstadt
Rhombus is a new language that is built on Racket. It offers the same kind of language extensibility as Racket itself, but using traditional (infix) notation. Although Rhombus is far from the first language to support Lisp-style macros without Lisp-style parentheses, Rhombus offers a novel synthesis of macro technology that is practical and expressive. A key element is the use of multiple binding spaces for context-specific sublanguages. For example, expressions and pattern-matching forms can use the same operators with different meanings and without creating conflicts. Context-sensitive bindings, in turn, facilitate a language design that reduces the notational distance between the core language and macro facilities. For example, repetitions can be defined and used in binding and expression contexts generally, which enables a smoother transition from programming to metaprogramming. Finally, since handling static information (such as types) is also a necessary part of growing macros beyond Lisp, Rhombus includes support in its expansion protocol for communicating static information among bindings and expressions. The Rhombus implementation demonstrates that all of these pieces can work together in a coherent and user-friendly language.

1 December 2012 in Higher-Order and Symbolic Computation
Verified
Journal Article
Closed access
PDF file
CKCasey Klein
Casey Klein
MFMatthew Flatt
Matthew Flatt
RFRobert Bruce Findler
Robert Bruce Findler

26 October 2015
Verified
Conference Paper
Open access
PDF file
XLXiangqi Li
Xiangqi Li
MFMatthew Flatt
Matthew Flatt
Modern programmers enjoy a wealth of high-level and graphical tools for understanding and debugging programs. Nevertheless, programmers often resort to the simple and the time-honored technique of inserting print statements into programs to reveal progress and to expose intermediate values. This trace debugging (a.k.a. printf debugging) technique persists because it has many advantages. Traditional trace debugging also has several drawbacks, including the need to modify the source program and the need for additional tools when trace output becomes too voluminous. Medic, our new debugging and program-exploration tool for Racket, augments the traditional examination of control and state with output processing, metaprogramming, and visualization features. Medic allows programmers to leverage the benefits of trace debugging while addressing many of its drawbacks.

17 October 2024
Verified
Conference Paper
Open access
YLYunjeong Lee
Yunjeong Lee
KGKiran Gopinathan
Kiran Gopinathan
YZYang Ziyi
Yang Ziyi
MFMatthew Flatt
Matthew Flatt
ISIlya Sergey
Ilya Sergey
Domain-Specific Languages (DSLs) are a popular way to simplify and streamline programmatic solutions of commonly occurring yet specialized tasks. While the design of frameworks for implementing DSLs has been a popular topic of study in the research community, significantly less attention has been given to studying how those frameworks end up being used by practitioners and assessing utility of their features for building DSLs "in the wild". In this paper, we conduct such a study focusing on a particular framework for DSL construction: the Racket programming language. We provide (a) a novel taxonomy of language design intents enabled by Racket-embedded DSLs, and (b) a classification of ways to utilize Racket's mechanisms that make the implementation of those intents possible. We substantiate our taxonomy with an analysis of 30 popular Racket-based DSLs, discussing how they make use of the available mechanisms and accordingly achieve their design intents. The taxonomy serves as a reusable measure that can help language designers to systematically develop, compare, and analyze DSLs in Racket as well as other frameworks.