# repl

Published articles for repl.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## wastrel milestone: full hoot support, with generational gc as a treat

DevFeed: [wastrel milestone: full hoot support, with generational gc as a treat](<https://devfeed.tech/articles/wastrel-milestone-full-hoot-support-with-generational-gc-as-a-treat-35036.md>)

Original publisher: [Read original article](<https://wingolog.org/archives/2026/04/09/wastrel-milestone-full-hoot-support-with-generational-gc-as-a-treat>)

Author: Andy Wingo

Published: 2026-04-09T13:48:04Z

Content type: article

Language: en

Sources: [wingolog](<https://devfeed.tech/sources/wingolog.md>)

Topics: [WebAssembly](<https://devfeed.tech/topics/web-assembly.md>), [scheme](<https://devfeed.tech/topics/scheme.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [gcc](<https://devfeed.tech/topics/gcc.md>)

Tags: [binaries](<https://devfeed.tech/tags/binaries.md>), [garbage-collection](<https://devfeed.tech/tags/garbage-collection.md>), [gc](<https://devfeed.tech/tags/gc.md>), [gcc](<https://devfeed.tech/tags/gcc.md>), [hoot](<https://devfeed.tech/tags/hoot.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [repl](<https://devfeed.tech/tags/repl.md>), [scheme](<https://devfeed.tech/tags/scheme.md>), [spidermonkey](<https://devfeed.tech/tags/spidermonkey.md>), [toolchain](<https://devfeed.tech/tags/toolchain.md>), [treats](<https://devfeed.tech/tags/treats.md>), [v8](<https://devfeed.tech/tags/v8.md>), [wasm](<https://devfeed.tech/tags/wasm.md>), [wastrel](<https://devfeed.tech/tags/wastrel.md>), [web](<https://devfeed.tech/tags/web.md>), [webassembly](<https://devfeed.tech/tags/webassembly.md>)

### AI overview

The article describes a Wastrel milestone: compiling WebAssembly files produced by the Hoot Scheme toolchain into native binaries, including a console-based read-eval-print loop. It covers the build process, runtime modules, binary size, dependencies, and initial performance observations.

### Source excerpt

Hear ye, hear ye: Wastrel and Hoot means REPL! Which is to say, Wastrel can now make native binaries out of WebAssembly files as produced by the Hoot Scheme toolchain, up to and including a full read-eval-print loop. Like the REPL on the Hoot web page, but instead of requiring a browser, you can just run it on your console. Amazing stuff! try it at home First, we need the latest Hoot. Build it from source, then compile a simple REPL: echo '(import (hoot repl)) (spawn-repl)' > repl.scm ./pre-inst-env hoot compile -fruntime-modules -o repl.wasm repl.scm This takes about a minute. The resulting wasm file has a pretty full standard library including a full macro expander and evaluator. Normally Hoot would do some aggressive tree-shaking to discard any definitions not used by the program, but with a REPL we don't know what we might need. So, we pass -fruntime-modules to instruct Hoot to record all modules and their bindings in a central registry, so they can be looked up at run-time. This results in a 6.6 MB Wasm file; with tree-shaking we would have been at 1.2 MB. Next, build Wastrel from source, and compile our new repl.wasm: wastrel compile -o repl repl.wasm This takes about 5 minutes on my machine: about 3 minutes to generate all the C, about 6.6MLOC all in all, split into a couple hundred files of about 30KLOC each, and then 2 minutes to compile with GCC and link-time optimization (parallelised over 32 cores in my case). I have some ideas to golf the first part down a bit, but the the GCC side will resist improvements. Finally, the moment of truth: $ ./repl Hoot 0.8.0 Enter `,help' for help. (hoot user)> "hello, world!" => "hello, world!" (hoot user)> statics When I first got the REPL working last week, I gasped out loud: it's alive, it's alive!!! Now that some days have passed, I am finally able to look a bit more dispassionately at where we're at. Firstly, let's look at the compiled binary itself. By default, Wastrel passes the -g flag to GCC, which results in bi

## Assorted NixOS things

DevFeed: [Assorted NixOS things](<https://devfeed.tech/articles/assorted-nixos-things-38528.md>)

Original publisher: [Read original article](<https://msfjarvis.dev/posts/assorted-nixos-things/>)

Author: Harsh Shandilya

Published: 2024-12-07T20:19:00Z

Content type: article

Language: en

Sources: [Posts on Harsh Shandilya](<https://devfeed.tech/sources/posts-on-harsh-shandilya.md>)

Topics: [Nix](<https://devfeed.tech/topics/nix.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [systems](<https://devfeed.tech/topics/systems.md>), [tailscale](<https://devfeed.tech/topics/tailscale.md>), [Virtual Private Network](<https://devfeed.tech/topics/vpn.md>), [Text-based user interface](<https://devfeed.tech/topics/tui.md>)

Tags: [cli](<https://devfeed.tech/tags/cli.md>), [commands](<https://devfeed.tech/tags/commands.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [errors](<https://devfeed.tech/tags/errors.md>), [git](<https://devfeed.tech/tags/git.md>), [module](<https://devfeed.tech/tags/module.md>), [nix](<https://devfeed.tech/tags/nix.md>), [nixos](<https://devfeed.tech/tags/nixos.md>), [nixpkgs](<https://devfeed.tech/tags/nixpkgs.md>), [packages](<https://devfeed.tech/tags/packages.md>), [repl](<https://devfeed.tech/tags/repl.md>), [tailscale](<https://devfeed.tech/tags/tailscale.md>)

### AI overview

A running log of practical NixOS, Nix, and Nixpkgs notes covering flake metadata, the module system, package updates, the Nix language, REPL builds, fixed-output derivations, and Tailscale exit nodes.

### Source excerpt

Running log of random things I've learned about Nix/NixOS/Nixpkgs

## Setting up psql, the PostgreSQL CLI

DevFeed: [Setting up psql, the PostgreSQL CLI](<https://devfeed.tech/articles/setting-up-psql-the-postgresql-cli-34576.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2017/12/setting-up-psql-the-postgresql-cli/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2017-12-22T14:23:43Z

Content type: tutorial

Language: en

Sources: [Dimitri Fontaine](<https://devfeed.tech/sources/dimitri-fontaine.md>)

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [console](<https://devfeed.tech/topics/console.md>), [Scripting](<https://devfeed.tech/topics/scripting.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [Environment Variables](<https://devfeed.tech/topics/environment-variables.md>)

Tags: [cli](<https://devfeed.tech/tags/cli.md>), [console](<https://devfeed.tech/tags/console.md>), [environment-variables](<https://devfeed.tech/tags/environment-variables.md>), [history](<https://devfeed.tech/tags/history.md>), [input](<https://devfeed.tech/tags/input.md>), [interactive](<https://devfeed.tech/tags/interactive.md>), [keyboard](<https://devfeed.tech/tags/keyboard.md>), [less](<https://devfeed.tech/tags/less.md>), [pager](<https://devfeed.tech/tags/pager.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [psql](<https://devfeed.tech/tags/psql.md>), [redirection](<https://devfeed.tech/tags/redirection.md>), [repl](<https://devfeed.tech/tags/repl.md>), [scripting](<https://devfeed.tech/tags/scripting.md>), [setup](<https://devfeed.tech/tags/setup.md>)

### AI overview

A tutorial on setting up and using psql, PostgreSQL's command-line console. It explains interactive and scripting features, the REPL workflow, and configuration through the psqlrc file and environment variables.

### Source excerpt

PostgreSQL ships with an interactive console with the command line tool named psql. It can be used both for scripting and interactive usage and is moreover quite a powerful tool. Interactive features includes autocompletion, readline support (history searches, modern keyboard movements, etc), input and output redirection, formatted output, and more.

## How to Write SQL

DevFeed: [How to Write SQL](<https://devfeed.tech/articles/how-to-write-sql-34558.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2017/06/how-to-write-sql/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2017-06-08T11:23:26Z

Content type: tutorial

Language: en

Sources: [Dimitri Fontaine](<https://devfeed.tech/sources/dimitri-fontaine.md>)

Topics: [SQL](<https://devfeed.tech/topics/sql.md>), [Code](<https://devfeed.tech/topics/code.md>), [Python](<https://devfeed.tech/topics/python.md>), [Clojure](<https://devfeed.tech/topics/clojure.md>), [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [orm](<https://devfeed.tech/tags/orm.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [psql](<https://devfeed.tech/tags/psql.md>), [python](<https://devfeed.tech/tags/python.md>), [repl](<https://devfeed.tech/tags/repl.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

A tutorial on writing SQL as repository files rather than embedding queries as strings or relying entirely on an ORM. It discusses maintaining and debugging raw SQL, demonstrates a query against the Chinook database, and explains how psql variables can be used to run and edit queries interactively.

### Source excerpt

Kris Jenkins cooked up a very nice way to embed SQL in your code: YeSQL for Clojure. The main idea is that you should be writing your SQL queries in .sql files in your code repository and maintain them there. The idea is very good and it is now possible to find alternative implementations of the Clojure yesql library in other languages. Today, we are going to have a look at one of them for the python programming language: anosql.

## Setting Up Live-Reloading ClojureScript Development with Boot

DevFeed: [Setting Up Live-Reloading ClojureScript Development with Boot](<https://devfeed.tech/articles/clojurescript-boot-live-reload-weasel-vim-fireplace-piggieback-32109.md>)

Original publisher: [Read original article](<https://adambard.com/blog/clojurescript-boot-fireplace/>)

Published: 2016-01-11T00:00:00Z

Content type: tutorial

Language: en

Sources: [Adam Bard](<https://devfeed.tech/sources/adam-bard.md>)

Topics: [ClojureScript](<https://devfeed.tech/topics/clojurescript.md>), [boot](<https://devfeed.tech/topics/boot.md>), [configuration](<https://devfeed.tech/topics/configuration.md>), [Development](<https://devfeed.tech/topics/development.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>)

Tags: [boot](<https://devfeed.tech/tags/boot.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [development](<https://devfeed.tech/tags/development.md>), [reload](<https://devfeed.tech/tags/reload.md>), [repl](<https://devfeed.tech/tags/repl.md>), [vim](<https://devfeed.tech/tags/vim.md>)

### AI overview

A tutorial for assembling a live-reloading, auto-compiling ClojureScript development setup with Boot. It explains the required dependencies, configuration, and task composition, including starting a REPL and passing the fileset.

### Source excerpt

My long-standing complaint about Clojurescript is that it's a pain to get running. People who prefer Leiningen seem to have gotten a handle on this with figwheel; however, those of us who have jumped on the Boot train (it's newer and therefore better!) still have to do some assembly to get the live-reloading auto-compiling repl setup that's become the standard for Clojurescript development. Like many problems in the Clojure universe, this is less a problem of technology and more a problem of approachable documentation. With just a little bit of configuration and some understanding, you too can assemble that perfect Clojurescript dev setup using Boot.

## Writing Friendlier Clojure

DevFeed: [Writing Friendlier Clojure](<https://devfeed.tech/articles/writing-friendlier-clojure-32179.md>)

Original publisher: [Read original article](<https://adambard.com/blog/write-friendlier-clojure/>)

Published: 2015-10-01T00:00:00Z

Content type: tutorial

Language: en

Sources: [Adam Bard](<https://devfeed.tech/sources/adam-bard.md>)

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [repl](<https://devfeed.tech/tags/repl.md>)

### AI overview

A practical guide to refactoring dense Clojure code. It examines a Markov-chain sentence generator and shows how reducing explicit nesting and treating nested parts as black boxes can make the implementation easier to understand.

### Source excerpt

I love the Clojure language, but I don't think there's any use pretending that the combination of expressiveness, power, and repl-driven development can result in some staggeringly dense code. Everyone that writes Clojure is guilty of this at one time or another; you start with the core of your function, evaluate it, wrap it a bit, eval again, and before you know it you have a lopsided, deeply nested, organically-grown stalagmite of a program.

## My Top Clojure Articles

DevFeed: [My Top Clojure Articles](<https://devfeed.tech/articles/my-top-clojure-articles-32129.md>)

Original publisher: [Read original article](<https://adambard.com/blog/greatest-clojure-hits/>)

Published: 2014-07-07T00:00:00Z

Content type: article

Language: en

Sources: [Adam Bard](<https://devfeed.tech/sources/adam-bard.md>)

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [coding](<https://devfeed.tech/topics/coding.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Error Handling](<https://devfeed.tech/topics/error-handling.md>)

Tags: [articles](<https://devfeed.tech/tags/articles.md>), [beginner](<https://devfeed.tech/tags/beginner.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [coding](<https://devfeed.tech/tags/coding.md>), [functional](<https://devfeed.tech/tags/functional.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [intermediate](<https://devfeed.tech/tags/intermediate.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [repl](<https://devfeed.tech/tags/repl.md>), [stream-processing](<https://devfeed.tech/tags/stream-processing.md>), [techniques](<https://devfeed.tech/tags/techniques.md>)

### AI overview

A curated collection of the author's beginner-to-intermediate Clojure articles, ordered by difficulty. It introduces Clojure's practical features, functional programming practices, error handling, web applications, macros, protocols, reducers, concurrency, and libraries.

### Source excerpt

For the past few years, most of my posts have been beginner-intermediate essays on various clojure features and coding techniques. Since a lot of people have told me that they like my blog as a genre piece, I decided to pull some of my favorites into one place, and order them by difficulty, from Clojure beginner on up so that folks don't have to root around.

## REPL Driven Development

DevFeed: [REPL Driven Development](<https://devfeed.tech/articles/repl-driven-development-31904.md>)

Original publisher: [Read original article](<http://blog.jayfields.com/2014/01/repl-driven-development.html>)

Author: Jay (noreply@blogger.com)

Published: 2014-01-27T17:53:00Z

Content type: opinion

Language: en

Sources: [Jay Fields](<https://devfeed.tech/sources/jay-fields.md>)

Topics: [Development](<https://devfeed.tech/topics/development.md>), [Code](<https://devfeed.tech/topics/code.md>), [Software](<https://devfeed.tech/topics/software.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [application](<https://devfeed.tech/tags/application.md>), [c-sharp](<https://devfeed.tech/tags/c-sharp.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [development](<https://devfeed.tech/tags/development.md>), [emacs](<https://devfeed.tech/tags/emacs.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [expression](<https://devfeed.tech/tags/expression.md>), [java](<https://devfeed.tech/tags/java.md>), [junit](<https://devfeed.tech/tags/junit.md>), [nunit](<https://devfeed.tech/tags/nunit.md>), [productivity](<https://devfeed.tech/tags/productivity.md>), [repl](<https://devfeed.tech/tags/repl.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [running](<https://devfeed.tech/tags/running.md>), [software](<https://devfeed.tech/tags/software.md>), [verification](<https://devfeed.tech/tags/verification.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

The article explains REPL Driven Development (RDD), a workflow in which developers craft s-expressions, evaluate them immediately in a REPL, inspect the results or apply changes to a running application, and repeat until the problem is solved. The author argues that avoiding application restarts, separate verification tools, and leaving the source enables faster feedback while writing production code.

### Source excerpt

When I describe my current workflow I use the TLA RDD, which is short for REPL Driven Development. I've been using REPL Driven Development for all of my production work for awhile now, and I find it to be the most effective workflow I've ever used. RDD differs greatly from any workflow I've used in the past, and (despite my belief that it's superior) I've often had trouble concisely describing what makes the workflow so productive. This entry is an attempt to describe what I consider RDD to be, and to demonstrate why I find it the most effective way to work. RDD Cycle First, I'd like to address the TLA RDD. I use the term RDD because I'm relying on the REPL to drive my development. More specifically, when I'm developing, I create an s-expression that I believe will solve my problem at hand. Once I'm satisfied with my s-expression, I send that s-expression to the REPL for immediate evaluation. The result of sending an s-expression can either be a value that I manually inspect, or it can be a change to a running application. Either way, I'll look at the result, determine if the problem is solved, and repeat the process of crafting an s-expression, sending it to the REPL, and evaluating the result. If that isn't clear, hopefully the video below demonstrates what I'm talking about. If you're unfamiliar with RDD, the previous video might leave you wondering: What's so impressive about RDD? To answer that question, I think it's worth making explicit what the video is: an example of a running application that needs to change, a change taking place, and verification that the application runs as desired. The video demonstrates change and verification; what makes RDD so effective to me is what's missing: (a) restarting the application, (b) running something other than the application to verify behavior, and (c) moving out of the source to execute arbitrary code. Eliminating those 3 steps allows me to focus on what's important, writing and running code that will be executed in

## (An ((Even Better) Lisp) Interpreter (in Python))

DevFeed: [(An ((Even Better) Lisp) Interpreter (in Python))](<https://devfeed.tech/articles/an-even-better-lisp-interpreter-in-python-40573.md>)

Original publisher: [Read original article](<http://norvig.com/lispy2.html>)

Published: 2010-10-05T00:00:00Z

Content type: tutorial

Language: en

Sources: [Peter Norvig](<https://devfeed.tech/sources/peter-norvig.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>), [scheme](<https://devfeed.tech/topics/scheme.md>), [implementation](<https://devfeed.tech/topics/implementation.md>)

Tags: [class](<https://devfeed.tech/tags/class.md>), [interpreter](<https://devfeed.tech/tags/interpreter.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [python](<https://devfeed.tech/tags/python.md>), [repl](<https://devfeed.tech/tags/repl.md>)

### AI overview

This article presents an improved version of Lispy, a Lisp interpreter implemented in Python. It adds input ports for reading complete expressions across multiple lines, improved error handling, macro examples, and a non-recursive evaluator implemented with a loop and mutable evaluation state.

### Source excerpt

A new version of Lispy (Lisp interpreter in Python). I released an earlier version on Sept. 30th, but this version is improved.