Try:

StrangeLoop2 years ago

“Birdsong as code” by Chris Ford (Strange Loop 2023)

Chris Ford live-codes birdsong in Clojure/Overtone to argue that code can serve as a clarifying notation for musical structure. He explains basic sound theory (fundamentals, harmonics, envelopes), contrasts linear (harmonic-series) and exponential (12‑tone) scales, models pied butcherbird and hermit thrush pitch choices with synthesizer code, compares approximations numerically, and finishes with a live synthesis/performance exploring human–bird musical interplay.

StrangeLoop2 years ago

“Software & The Game of Go” by David Nolen (Strange Loop 2023)

David Nolen’s Strange Loop 2023 talk uses the history, rules, and strategy of the board game Go to draw lessons for software practice. He explains Go’s rules and historical context, then extracts “golden rules” — tradeoffs, planning, sacrifice, coordination, simplicity and balance — and shows how those strategic principles apply to software design, engineering judgment, and product work.

StrangeLoop2 years ago

“Cursorless: A spoken language for editing code” by Pokey Rule (Strange Loop 2023)

Pokey Rule presents Cursorless, an open‑source spoken programming language for editing code by voice. The talk explains Cursorless’s core abstractions (marks that emit targets, pipelines of modifiers defined by scopes, and actions that operate on final targets), contrasts dumb (textual) and smart (parse‑tree based via tree‑sitter) scopes, demonstrates composable voice commands and the tacit/point‑free execution style, and outlines implementation details, tradeoffs, and future directions (IDE/web support, tutorials, OCR, and LLM integrations).

StrangeLoop2 years ago

“Using data-driven metrics to anticipate and prevent security incidents” by Caitlin Buckshaw

Caitlin Buckshaw (GitHub) explains how she built a peer engineering function that captures detailed incident data and applies trend analysis, automated pipelines, dashboards and an internal scoring system to prioritize fixes and shift security work left. She covers variant analysis and application-security testing techniques (DAST, CodeQL, Brakeman, custom tools), cross-team sharing practices, early wins (internal findings and improved preventions), and challenges of running the program.

StrangeLoop2 years ago

“Oatmeal is Cheap: A Fundamental Theorem for Procedural Generators” by Younès Rabii

Rabii presents a formal theorem for procedural generators that links generator source length (uncoded knowledge), possibility-space size (scale), and artifact complexity (a Kolmogorov-style measure). He proves inequalities that carve out infeasible regions in the design space and shows that increasing scale without adding design/implementation effort necessarily raises pattern density, producing repetitive or noisy “oatmeal” outputs. The talk applies the framework to game examples (Minecraft villages, No Man’s Sky, his game T Garden) and to large generative systems (Wikipedia, Stable Diffusion) to illustrate practical trade-offs and order-of-magnitude estimates.

StrangeLoop2 years ago

“Swift as C++ Successor in FoundationDB” by Konrad Malawski (Strange Loop 2023)

A Strange Loop case study showing how Apple’s Swift was incrementally adopted inside FoundationDB to replace C++. The talk covers Swift/C++ interop (clang modules, bridging headers, custom ref-count hooks), language features that improve memory and concurrency safety (value semantics, copy-on-write, actors, sendable checks), integration with FDB’s flow/simulation runtime, build/debug tooling, and reported performance parity after migration.

StrangeLoop2 years ago

“Supporting Data Journalism through Compilers for Visual Inputs” by Parker Ziegler

Parker Ziegler presents research on using compiler techniques to convert visual inputs (SVGs, design files, and direct-manipulation edits) into parameterized programs for data visualizations. He demonstrates Rivis (compiles SVG subtrees into partial JavaScript visualizations by inferring semantics and generating code with holes for data columns) and Cardit (a direct-manipulation cartography environment that maps UI edits to an IR and emits Mapbox GL JS), arguing this approach makes published graphics live, remixable, and easier for data journalists to reuse.

StrangeLoop2 years ago

“Computational Physics, Beyond the Glass” by Sam Ritchie (Strange Loop 2023)

Sam Ritchie presents a project that ports and reimplements a Scheme-based computer algebra system in Clojure/ClojureScript and pairs it with MathBox-driven, in-browser interactive notebooks to make computational physics playable and shareable. He demos live visualizations (geodesics, attractors, pendulums), explains language/design choices (extensible symbolic types, automatic differentiation, simplifiers), and argues for tooling that surfaces physics culture for learners and future intelligent textbooks.

StrangeLoop2 years ago

“Is my Large Language Model a Strange Loop?” by Zac Hatfield-Dodds (Strange Loop 2023)

Zac Hatfield-Dodds’ Strange Loop 2023 talk uses Hofstadter’s “strange loops” lens to explore both the internal mechanics of modern neural networks (feature representations, superposition, Transformer residual/attention circuitry, and induction heads) and the external training/feedback loops that shape LLM behavior (pretraining, RLHF, preference models, red‑teaming, Constitutional AI and RL from AI feedback). The talk presents interpretability findings, experiments on bias and self-assessment, and discusses open questions about emergent behaviors and safety.

StrangeLoop2 years ago

“A JVM threading model for the containerized times” by Luiz Hespanha and Flavio Brasil

Engineers describe how JVM microservices on Kubernetes suffered surprising CPU throttling and cluster instability because coarse-grained metrics and CPU quota behavior hid spikes and scheduler/GC pauses. They built navu, an adaptive concurrency controller that collects fine-grained CPU histograms and heartbeat scheduling metrics, redirects executors to limit or expand thread concurrency, and rejects excess work to avoid throttling. navu improved service stability, latency percentiles and reduced cost; planned next steps include lowering overhead for tiny pods, Loom (virtual-thread) integration, and open-sourcing.

StrangeLoop2 years ago

“An approach to computing and sustainability inspired from permaculture” by Devine Lu Linvega

Devine Lu Linvega presents an approach to “computing within limits” inspired by permaculture and his experience living on a small boat. He advocates minimal, portable systems and software preservation — demonstrating a 32-opcode stack-based VM and self-hosting assembler, discussing older/emulated platforms, portability via VM/specs, and validation techniques (stack-depth checks, linters) to sustain software practice under resource constraints.

StrangeLoop2 years ago

“From Geometry to Algebra and Back Again: 4000 Years of Papers” by Jack Rusher

Jack Rusher surveys 4,000 years of mathematical development (from ancient geometry and number systems through complex numbers to geometric algebra), argues that mathematical notation should be treated like a programming language and be machine-readable, and advocates geometric algebra as a unifying, practical formalism for physics and graphics — illustrating ideas with Scheme/Clojure/JavaScript examples and a live coding demo.

StrangeLoop2 years ago

“War Time Proofs and Futuristic Programs” by Valeria de Paiva

Valeria de Paiva surveys historical revolutions in science and mathematics to motivate modern revolutions in computation: Curry–Howard (proofs-as-types), lambda calculus, and categorical semantics. She explains Gödel’s dialectica interpretation and her categorical modeling of it, connects type theory (including linear and dependent types) to programming-language constructs and proof assistants, and highlights applications such as concurrency/distributed computing, lenses, partial compilers, and automatic differentiation.

StrangeLoop2 years ago

“Experimentation: putting research papers into prod” by Leemay Nassery

Leemay Nassery explains how to scale experimentation and move ML research into production. She identifies three common blockers — slow ML ranking iteration, too few users for tests, and insensitive/topline metrics — and proposes advanced tactics: interleaved ranker comparisons, overlapping experiments, and better feature-level metrics, instrumentation, and platform abstractions, along with performance and cultural considerations for adoption.

StrangeLoop2 years ago

“Formal semantics for multi-language programs” by Amal Ahmed

Amal Ahmed reviews the Matthews & Findler 2007 approach for giving formal, source-level semantics to multi-language programs by adding typed boundary forms between languages and defining how values are converted or wrapped across boundaries (lump vs natural embeddings). She explains how this enables type-sound interoperability, discusses conversion strategies (including error/exception mapping), and surveys follow-up work (dependent types, affine/linear mixes, typed assembly, compiler-correctness proofs, and verifying FFI glue). She closes with open problems: verifying real-world FFIs and connecting source-level semantics to target-level glue (e.g., for WebAssembly).

StrangeLoop2 years ago

“Inside the Wizard Research Engine” by Ben L. Titzer

Ben Titzer presents Wizard, a compact research WebAssembly engine written in Virgil that prioritizes observability, approachability, and competitive baseline performance. Wizard provides probe-based instrumentation (global/local), a frame-accessor API for dynamic analyses (coverage, branch profiling, loop monitors, tracing), a bytecode-level debugger, and a simple single-pass baseline JIT that shares stack layout with the interpreter to enable fast transitions. The system is designed as a teaching and experimentation vehicle (about 18k LoC) to make VM research and language experimentation easier and more observable.

StrangeLoop2 years ago

“Concatenative programming and stack-based languages” by Douglas Creager

Douglas Creager’s talk introduces stack-based (concatenative) languages: their execution model (stack, quotations, stack-manipulation ops), formal semantics (stack transformers and stack effects), and theoretical properties (Turing-completeness via reductions to combinatory logic and minimal primitive sets). He also covers practical implications—compilation to assembly, associativity enabling parallel compilation, demos the uxn VM, and highlights suitability for constrained devices.

StrangeLoop2 years ago

“Programming Distributed Systems” by Mae Milano

A talk about the challenges of programming distributed systems (destructive data races, coordination overhead, and consistency errors) and language-centered solutions. The speaker presents Mixy, an information-flow/type-system approach for mixed-consistency transactions, monotonic/coordination-free programming techniques (CRDT-like DSLs) and the Deratio replication system, and a region-based type system to prevent destructive data races in shared-memory concurrency (inspired by Rust/Swift work). Implementations and practical trade-offs are discussed.

StrangeLoop2 years ago

“Why Programming Languages Matter” by Andrew Black

Andrew Black argues that programming languages are critical infrastructure because they shape how programmers think and how systems are built. He surveys his personal history of language design (Algol 68, 3R, Eden, Emerald, traits, Grace, Fortress), draws lessons about paradigms (functional, object, process, logic), highlights language-driven solutions for distributed systems (immutability, location-independent invocation, failure handling), and emphasizes tooling and the social aspects that determine language adoption and effectiveness.

StrangeLoop2 years ago

“Ectype - bringing type safety (and more!) to vanilla JavaScript” by Holly Wu (Strange Loop 2023)

Holly Wu presents E-type, a proof-of-concept approach that adds static and runtime typing to vanilla JavaScript by making types first-class runtime values and using a linter-driven static analyzer instead of code generation. E-type provides constructs like structs, variants (sum types), match-based pattern matching, generics-as-functions, and conditional/refinement types, and exposes ‘from’ for statically-checked values and ‘conform’ for runtime validation. The talk demos editor integration and a running web-server example, explains interop with existing JS libraries, and discusses trade-offs (performance, verbosity, limited syntactic extension) and future directions.