Diagramming Program Values by Spatial Refinement

The Brown PLT Blog

RSS

CONTACT

GROUP PAGE

POSTS BY TAG

Android

April 1

Browsers

Crowdsourcing

Differential Analysis

Diagram

Education

Flowlog

Formal Methods

Higher-Order Functions

In-Flow Peer Review

JavaScript

Large Language Models

Linear Temporal Logic

Misconceptions

Permissions

Programming Languages

Program Planning

Privacy

Properties

Pyret

Python

Resugaring

Rust

Scope

Software-Defined Networking

Spatial

Security

Semantics

Tables

Testing

Tools

Types

User Studies

Verification

Visualization

-->

PREVIOUS POSTS

Diagramming Program Values by Spatial Refinement

LLMs ⭢ Regular Expressions, Responsibly!

Sharing is Scaring: Why is Cloud File-Sharing Hard?

Practical Static Analysis for Privacy Bugs

Lightweight Diagramming for Lightweight Formal Methods

Argus: Interactively Debugging Rust trait Errors

LTL Tutor

Misconceptions In Finite-Trace and Infinite-Trace Linear Temporal Logic

Iterative Student Program Planning using Transformer-Driven Feedback

Differential Analysis: A Summary

Forge: A Tool to Teach Formal Methods

Finding and Fixing Standard Misconceptions About Program Behavior

Privacy-Respecting Type Error Telemetry at Scale

Profiling Programming Language Learning

The Examplar Project: A Summary

A Core Calculus for Documents

Observations on the Design of Program Planning Notations for Students

Conceptual Mutation Testing

Generating Programs Trivially: Student Use of Large Language Models

A Grounded Conceptual Model for Ownership Types in Rust

What Happens When Students Switch (Functional) Languages

Typed-Untyped Interactions: A Comparative Analysis

Little Tricky Logics

Identifying Problem Misconceptions

Performance Preconceptions

Structural Versus Pipeline Composition of Higher-Order Functions

Plan Composition Using Higher-Order Functions

Towards a Notional Machine for Runtime Stacks and Scope

Gradual Soundness: Lessons from Static Python

Applying Cognitive Principles to Model-Finding Output

Automated, Targeted Testing of Property-Based Testing Predicates

A Benchmark for Tabular Types

Student Help-Seeking for (Un)Specified Behaviors

Adding Function Transformers to CODAP

Developing Behavioral Concepts of Higher-Order Functions

Adversarial Thinking Early in Post-Secondary Education

Teaching and Assessing Property-Based Testing

Students Testing Without Coercion

Using Design Alternatives to Learn About Data Organizations

What Help Do Students Seek in TA Office Hours?

Combating Misconceptions by Encouraging Example-Writing

The Hidden Perils of Automated Assessment

Mystery Languages

Resugaring Type Rules

Picking Colors for Pyret Error Messages

Can We Crowdsource Language Design?

Crowdsourcing User Studies for Formal Methods

User Studies of Principled Model Finder Output

A Third Perspective on Hygiene

Scope Inference, a.k.a. Resugaring Scope Rules

The PerMission Store

Examining the Privacy Decisions Facing Users

The Pyret Programming Language: Why Pyret?

Resugaring Evaluation Sequences

Slimming Languages by Reducing Sugar

In-flow Peer Review: An Overview

Tierless Programming for SDNs: Differential Analysis

Tierless Programming for SDNs: Verification

Tierless Programming for SDNs: Optimality

Tierless Programming for SDNs: Events

Tierless Programming for Software-Defined Networks

CS Student Work/Sleep Habits Revealed As Possibly Dangerously Normal

Parley: User Studies for Syntax Design

Typechecking Uses of the jQuery Language

Verifying Extensions' Compliance with Firefox's Private Browsing Mode

From MOOC Students to Researchers

Social Ratings of Application Permissions (Part 4: The Goal)

Social Ratings of Application Permissions (Part 3: Permissions Within a Domain)

Social Ratings of Application Permissions (Part 2: The Effect of Branding)

Social Ratings of Application Permissions (Part 1: Some Basic Conditions)

Aluminum: Principled Scenario Exploration Through Minimality

A Privacy-Affecting Change in Firefox 20

The New MOOR's Law

Essentials of Garbage Collection

(Sub)Typing First Class Field Names

Typing First Class Field Names

S5: Engineering Eval

Progressive Types

Modeling DOM Events

Mechanized LambdaJS

ECMA Announces Official λJS Adoption

Objects in Scripting Languages

S5: Wat?

Belay Lessons: Smarter Web Programming

S5: Semantics for Accessors

S5: A Semantics for Today's JavaScript

The Essence of JavaScript

ADsafety

Diagramming Program Values by Spatial Refinement

Tags: Diagram, Programming Languages, Spatial, Tools, Visualization

Posted on 22 May 2026.

Compilers can vectorize loops you never wrote. IDEs can finish functions before you do. Agents can refactor your codebase from a sentence.<br>And yet, when you want to inspect the value your program just produced, you still use the REPL as if nothing has changed in fifty years: type a variable name, get text back, squint. Here is Python showing you a binary decision diagram:

Node(15,...