Tech News
← Home  ·  All topics

Lisp

13 GoKawiil briefs on this topic · RSS for lisp

Blog post argues Clojure (2017) reshapes how developers think about programming

A 2017 blog post recommends Clojure as a language worth learning because of its breadth of influence, calling it an ideal choice for programmers who want their thinking about code fundamentally challenged. The author highlights Clojure's Lisp heritage, its dynamic typing, preference for built-in data structures over objects, emphasis on higher-order functions, and full macro support as key features that set it apart.

Jonquil 0.4.3 brings DrRacket-style editing to Clojure development

Jonquil 0.4.3 has been released as a Clojure code editor modeled on the DrRacket interface, incorporating some features inspired by Lisp Machines. The build is signed and notarized for Apple Silicon Macs running macOS 26 or later, bundles GTK so files open immediately, and can be installed via Homebrew with the command 'brew install b12n-oss/tap/jonquil' or downloaded directly. Running a full project with a deps.edn file requires also installing Jolt and git, while Intel Macs and Linux users must build the editor from source.

New tool Sift offers unified formatter, linter and LSP for Lisp dialects

Sift is a newly released open-source tool, built in Guile 3.0, that formats, lints and serves as a language server for Scheme, Emacs Lisp and Common Lisp. It reads each dialect according to its own specification rather than a shared syntax, and claims its formatting is idempotent, preserving comments and blank lines exactly where they appear in the source. It can be installed via Guix or Nix, or run directly from its repository, and is distributed under the MIT license.

Doug Hoyte's 'Let Over Lambda' Lisp macro book now free online

Doug Hoyte's 2008 book 'Let Over Lambda,' a deep-dive into Common Lisp macros published to mark Lisp's 50th anniversary, is now available to read free online in HTML and PDF. The author notes his thinking has evolved since 2008 but says the book still holds up as a tutorial on Lisp macros, and points to an existing Japanese translation sold through Amazon.co.jp.

New experimental project 'cljrs' brings Clojure-style Lisp to Rust

A developer has released cljrs, an experimental Clojure dialect built for the Rust ecosystem. It is designed as a Lisp runtime featuring persistent data structures, a hosted macro system, and native interop, with both compiled and interpreted execution modes.

Antimony CAD tool models shapes via graph nodes and Python scripts

Antimony is a computer-aided design tool built around a graph-based engine where users connect nodes, each defined by a customizable Python 3 script, to build solid models. It combines a directed-acyclic-graph framework for tracking data flow, a functional-representation geometry engine for boolean CSG operations, and a standard library of shapes and transforms like rotate, scale, attract, bend and repel. The tool can export heightmaps for 2.5D fabrication and STL files with sharp-edge feature detection for 3D printing or manufacturing.

OpenLDK project brings JVM bytecode execution into Common Lisp via SBCL

A developer has built OpenLDK, a JIT compiler and runtime that translates Java bytecode into Common Lisp code compiled natively by SBCL, letting Java objects run in the same process and heap as Lisp applications. The project, started in late 2024, now supports running JVM-hosted languages like Kotlin and Clojure alongside Lisp, and can execute Spring Boot applications, including saving an initialized app image that restarts in roughly 84 milliseconds.

Retro-computing writeup details early LISP systems running in tiny memory footprints

The piece traces LISP implementations that fit within extremely small memory budgets, starting with the original 1960 LISP on MIT's IBM 704, which used 32K words of 36-bit core with the LISP system itself taking 12K words, leaving under 20K cons cells. It also cites 1964's PDP-1 LISP, which ran on systems with just 4096 words of 18-bit storage, with the system consuming roughly 2000 words.

Essay examines why minimal languages like Forth, Lisp, Tcl and assembly grant outsized power

A blog post explores the relationship between the size of a programming language and its expressive power, arguing that smaller languages aren't necessarily less capable. It contrasts rigid, low-level languages like assembly and SNOBOL with syntactically tiny but highly flexible high-level languages: Forth, Lisp (especially Scheme), and Tcl.

Common Lisp's live image model accelerates coding with LLMs

Recent developments highlight how Common Lisp's unique image-based architecture allows for instant code updates and debugging, reducing wait times during development. This enables large language models to more effectively generate, test, and refine code without lengthy rebuilds or crashes. As a result, Common Lisp offers a more seamless environment for AI-assisted programming compared to traditional languages.

Essay dissects why Lisp's parenthesis-heavy syntax strains readability

A software commentator examines why Lisp code, with its uniform prefix notation and heavy parenthesization, is widely perceived as harder to read than C-style languages like Python or Java. The piece rejects the common Lisp community explanation that unreadability is purely a matter of unfamiliarity, and instead draws on cognitive science to propose a deeper structural cause tied to parenthesis placement.

TXR Combines Pattern Matching and Lisp for Text Data Extraction

TXR is a programming language created by Kaz Kylheku in 2009 that pairs a whole-document pattern-matching and extraction system with a full data-processing language, letting users run quick one-liners or write complex scripts to pull structured data out of messy text. The project has grown substantially over the years, with its reference manual now spanning hundreds of pages and offering many ways to solve the same extraction problem.