# LISP

Published articles for LISP.

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

## From RSS to Atom

DevFeed: [From RSS to Atom](<https://devfeed.tech/articles/from-rss-to-atom-37668.md>)

Original publisher: [Read original article](<https://susam.net/from-rss-to-atom.html>)

Published: 2026-05-04T00:00:00Z

Content type: opinion

Language: en

Sources: [Susam Pal](<https://devfeed.tech/sources/susam-pal.md>)

Topics: [Atom Feed](<https://devfeed.tech/topics/atom-feed.md>), [RSS Feed](<https://devfeed.tech/topics/rss-feed.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>), [Git](<https://devfeed.tech/topics/git.md>), [XML](<https://devfeed.tech/topics/xml.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [git](<https://devfeed.tech/tags/git.md>), [git-commit](<https://devfeed.tech/tags/git-commit.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [rss](<https://devfeed.tech/tags/rss.md>), [xml](<https://devfeed.tech/tags/xml.md>)

### AI overview

The author describes switching a personal website from RSS feeds to Atom feeds in 2026. The change was implemented in Common Lisp, took about an hour, and included replacing RSS item identifiers with UUID-based Atom entry identifiers and updating feed templates.

### Source excerpt

Yesterday, I switched my website from RSS feeds to Atom feeds. In case you are wondering whether you have somehow landed on an ancient post from 2010, no, you have not. Yes, this is the year 2026, and I have finally switched from RSS feeds to Atom feeds. Yes, I am fifteen, or perhaps twenty, years too late. Contents Impulse Coding Atom Entries Temporary Workaround Does It Matter? References Impulse Coding I have always wanted to do this but could never make the time for it. Finally, it happened while I was giving my brain some rest from my ongoing algebraic graph theory studies. That's when I felt like spending a little time on my website and doing a little Lisp to change the feeds from RSS to Atom. I suppose this was impulse coding, a bit like impulse buying, except that I ended up with an Atom feed instead of a new book. I find it quite surprising that when I have plenty of time, it usually does not occur to me to do these things, but when I am too busy and really short of time, these little ideas possess me during the short breaks I take. My personal website is one of my passion projects. Common Lisp is one of my favourite programming languages. So any time spent on this passion project using my favourite programming language is a very relaxing experience for me. It serves as an ideal break between intense study sessions. It took about an hour to implement the changes needed to make the switch from RSS to Atom. In the end, I could go back to my studies reinvigorated. In case you are curious, here is the Git commit where I implemented the change from RSS to Atom: 596e1dd. As you might notice, a large portion of the change consists of replacing the key attribute in each post with the uuid attribute. The key attribute value was used as the value of the <guid> element in the RSS feeds. While an arbitrary short string could serve as the <guid> element for the items in an RSS feed, the <id> element of the entries in an Atom feed needs to be a URI. It turns out UUID URN

## RSC for LISP Developers

DevFeed: [RSC for LISP Developers](<https://devfeed.tech/articles/rsc-for-lisp-developers-36194.md>)

Original publisher: [Read original article](<https://overreacted.io/rsc-for-lisp-developers/>)

Published: 2025-06-01T00:00:00Z

Content type: tutorial

Language: en

Sources: [Dan Abramov](<https://devfeed.tech/sources/dan-abramov.md>)

Topics: [Lisp](<https://devfeed.tech/topics/lisp.md>), [modules](<https://devfeed.tech/topics/modules.md>), [React](<https://devfeed.tech/topics/react.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [client](<https://devfeed.tech/topics/client.md>), [Back end](<https://devfeed.tech/topics/backend.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [client](<https://devfeed.tech/tags/client.md>), [code](<https://devfeed.tech/tags/code.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [modules](<https://devfeed.tech/tags/modules.md>), [react](<https://devfeed.tech/tags/react.md>)

### AI overview

This article explains React Server Components to LISP developers by comparing RSC's treatment of client modules as deferred code with LISP quoting, where code can be treated as data. It describes how bundling and client-side evaluation enable modular behavior across server and client stages.

### Source excerpt

Quoting for modules.

## Repost: Why Are Layer-2 VPNs So Popular?

DevFeed: [Repost: Why Are Layer-2 VPNs So Popular?](<https://devfeed.tech/articles/repost-why-are-layer-2-vpns-so-popular-11072.md>)

Original publisher: [Read original article](<https://blog.ipspace.net/2024/09/l2vpn-versus-l3vpn/>)

Published: 2024-09-03T06:35:00Z

Content type: opinion

Language: en

Sources: [ipSpace.net blog](<https://devfeed.tech/sources/ipspace-net-blog.md>)

Topics: [Virtual Private Network](<https://devfeed.tech/topics/vpn.md>), [Provisioning](<https://devfeed.tech/topics/provisioning.md>), [Network](<https://devfeed.tech/topics/network.md>)

Tags: [bridging](<https://devfeed.tech/tags/bridging.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [customers](<https://devfeed.tech/tags/customers.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [mpls](<https://devfeed.tech/tags/mpls.md>), [network](<https://devfeed.tech/tags/network.md>), [providers](<https://devfeed.tech/tags/providers.md>), [provisioning](<https://devfeed.tech/tags/provisioning.md>), [vpn](<https://devfeed.tech/tags/vpn.md>)

### AI overview

The article explains that Layer-2 VPNs are popular because they require less configuration coordination and are easier to provision and automate than Layer-3 VPNs. It also notes that L2VPNs can support Network-as-a-Service models, while requiring customers to install edge routers.

### Source excerpt

Béla Várkonyi wrote a succinct comment explaining why so many customers prefer layer-2 VPNs over layer-3 VPNs: The reason of L2VPN is becoming more popular by service providers and customers is about provisioning complexity. Read more ...

## Repost: State of Lisp Implementations (2024)

DevFeed: [Repost: State of Lisp Implementations (2024)](<https://devfeed.tech/articles/repost-state-of-lisp-implementations-2024-11010.md>)

Original publisher: [Read original article](<https://blog.ipspace.net/2024/05/repost-state-of-lisp-implementations/>)

Published: 2024-05-07T06:21:00Z

Content type: opinion

Language: en

Sources: [ipSpace.net blog](<https://devfeed.tech/sources/ipspace-net-blog.md>)

Topics: [Lisp](<https://devfeed.tech/topics/lisp.md>), [Cisco](<https://devfeed.tech/topics/cisco.md>), [Networks](<https://devfeed.tech/topics/networks.md>), [iOS](<https://devfeed.tech/topics/ios.md>), [evpn](<https://devfeed.tech/topics/evpn.md>)

Tags: [cisco](<https://devfeed.tech/tags/cisco.md>), [design](<https://devfeed.tech/tags/design.md>), [development](<https://devfeed.tech/tags/development.md>), [evpn](<https://devfeed.tech/tags/evpn.md>), [ios](<https://devfeed.tech/tags/ios.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [mobility](<https://devfeed.tech/tags/mobility.md>), [network-design](<https://devfeed.tech/tags/network-design.md>), [networks](<https://devfeed.tech/tags/networks.md>), [routing](<https://devfeed.tech/tags/routing.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

This repost discusses the uncertain state of LISP support, including its removal from IOS XR and concerns about Cisco's future support. It describes the consequences for extreme-mobility and safety-critical networks, including possible parallel LISP and PMIPv6 backbones and the need for supplier and technology diversity.

### Source excerpt

You might remember Béla Várkonyi's use of LISP to build resilient ground-to-airplane networks from last week's repost. It seems he's not exactly happy with the current level of LISP support, at least based on what he wrote as a response to Jeff McLaughlin's claim that "I can tell you that our support for EVPN does not, in any way, indicate the retirement of LISP for SD-Access.": Nice to hear the Cisco intends to support LISP. However, it is removed from IOS XR already. So it is not that clear... If Cisco will stop supporting LISP, then we will be forced to create our own LISP routers, since we need it for extreme mobility environments. Read more ...

## Repost: The Real LISP Mobility Use Case

DevFeed: [Repost: The Real LISP Mobility Use Case](<https://devfeed.tech/articles/repost-the-real-lisp-mobility-use-case-10989.md>)

Original publisher: [Read original article](<https://blog.ipspace.net/2024/04/repost-lisp-mobility/>)

Published: 2024-04-30T05:59:00Z

Content type: article

Language: en

Sources: [ipSpace.net blog](<https://devfeed.tech/sources/ipspace-net-blog.md>)

Topics: [Lisp](<https://devfeed.tech/topics/lisp.md>), [BGP](<https://devfeed.tech/topics/bgp.md>), [networking](<https://devfeed.tech/topics/networking.md>), [Publish-subscribe pattern](<https://devfeed.tech/topics/pubsub.md>)

Tags: [bgp](<https://devfeed.tech/tags/bgp.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [mobility](<https://devfeed.tech/tags/mobility.md>), [networks](<https://devfeed.tech/tags/networks.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [routing](<https://devfeed.tech/tags/routing.md>)

### AI overview

The article discusses using LISP with PUBSUB for multilink mobility in ground-to-airplane networks. It argues that LISP may handle frequent mobility events, scale, and safety-critical requirements better than BGP in this use case, while noting that several protocol extensions and standardized reliable transport are still needed.

### Source excerpt

Béla Várkonyi is working on an interesting challenge: building ground-to-airplane(s) networks providing multilink mobility. Due to its relative simplicity, he claims LISP works much better than BGP in that environment. In some newer routers BGP would not be such a big bottleneck, but you need a lot of knob turning in BGP to get it right, while in LISP it is quite simple. If you have many thousands concurrent airplanes with multi-link and max. 16 subnets with different routing policies on each, and the radio links are going up and down, then you have a large number of mobility events. Read more ...

## LISP vs EVPN: Mobility in Campus Networks

DevFeed: [LISP vs EVPN: Mobility in Campus Networks](<https://devfeed.tech/articles/lisp-vs-evpn-mobility-in-campus-networks-10981.md>)

Original publisher: [Read original article](<https://blog.ipspace.net/2024/04/mobility-campus-networks-lisp-evpn/>)

Published: 2024-04-11T06:29:00Z

Content type: opinion

Language: en

Sources: [ipSpace.net blog](<https://devfeed.tech/sources/ipspace-net-blog.md>)

Topics: [evpn](<https://devfeed.tech/topics/evpn.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>), [networking](<https://devfeed.tech/topics/networking.md>), [BGP](<https://devfeed.tech/topics/bgp.md>)

Tags: [bgp](<https://devfeed.tech/tags/bgp.md>), [churn](<https://devfeed.tech/tags/churn.md>), [evpn](<https://devfeed.tech/tags/evpn.md>), [latency](<https://devfeed.tech/tags/latency.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [mobility](<https://devfeed.tech/tags/mobility.md>), [networking](<https://devfeed.tech/tags/networking.md>), [networks](<https://devfeed.tech/tags/networks.md>), [protocol](<https://devfeed.tech/tags/protocol.md>)

### AI overview

This opinion examines whether LISP handles campus mobility better than EVPN. It argues that the LISP-versus-EVPN scaling debate can become irrelevant when the switch CPU-to-ASIC bus is the bottleneck, and questions claims that EVPN cannot handle the churn associated with wireless endpoint roaming. It also discusses possible latency spikes after MAC move events.

### Source excerpt

I decided not to get involved in the EVPN-versus-LISP debates anymore; I'd written everything I had to say about LISP. However, I still get annoyed when experienced networking engineers fall for marketing gimmicks disguised as technical arguments. Here's a recent one: Read more ...

## Difftastic: A Structural Diff Tool for Programming Languages

DevFeed: [Difftastic: A Structural Diff Tool for Programming Languages](<https://devfeed.tech/articles/difftastic-the-fantastic-diff-22024.md>)

Original publisher: [Read original article](<http://www.wilfred.me.uk/blog/2022/09/06/difftastic-the-fantastic-diff/>)

Author: Wilfred Hughes

Published: 2022-09-06T00:00:00Z

Content type: tutorial

Language: en

Sources: [Wilfred Hughes](<https://devfeed.tech/sources/wilfred-hughes.md>)

Topics: [Parsing](<https://devfeed.tech/topics/parsing.md>), [Tree-sitter](<https://devfeed.tech/topics/tree-sitter.md>), [Parser](<https://devfeed.tech/topics/parser.md>), [Code](<https://devfeed.tech/topics/code.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [emacs](<https://devfeed.tech/tags/emacs.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [parsing](<https://devfeed.tech/tags/parsing.md>), [programming](<https://devfeed.tech/tags/programming.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

The article explains how difftastic implements structural diffs for programming languages. It describes parsing source code with tree-sitter, converting parse trees into a uniform s-expression representation, and calculating diffs as a shortest-path problem on a directed acyclic graph.

### Source excerpt

I've always wanted a structural diff tool, so I built difftastic. This has been the most fascinating, most frustrating, and most challenging program I've ever written. How Hard Could It Be? If you write Lisp code for a while, you start to see code like JSON. Everything is basically a list. json-diff example json-diff already exists, and it's pretty good. I wanted something similar for programming languages. After a huge amount of experimentation, I have something that works. In this post, I'll show you how it works. I won't show the many, many dead ends and failed designs along the way. We can pretend that I got it right first time. Parsing The Code If I want to compare two programs, I first need a parse tree for each program. I need an accurate lexer, a basic parser, and I need to preserve comments. tree-sitter was a great fit here. You define a grammar in JSON or JS, and it generates a C library that anyone can use. It's not 100% accurate (e.g. the C++ parser doesn't have preprocessor data) but it's more than good enough. list: ($) => seq("(", repeat($._sexp), ")"), vector: ($) => seq("[", repeat($._sexp), "]"), Here's an excerpt from my Emacs Lisp grammar. There's a ton of tree-sitter parsers available too. Difftastic now supports 44 different syntaxes, and adding new ones is so straightforward that my manual includes a worked example. Using difftastic with Emacs Lisp After parsing, difftastic converts the tree-sitter parse tree to an s-expression. Everything is a list or an atom. This uniform representation enables the diffing logic to work on any language that I can parse. For example, given a JavaScript program like this: foo(1, 2) tree-sitter parses it to this parse tree: expression_statement call_expression identifier "foo" arguments ( number "1" , number "2" ) difftastic then converts the tree to this s-expression representation: List { open_content: "", children: [ Atom "foo", List { open_content: "(", children: [ Atom "1", Atom ",", Atom "2", ], close_con

## Graydon Hoare: 21 compilers and 3 orders of magnitude in 60 minutes

DevFeed: [Graydon Hoare: 21 compilers and 3 orders of magnitude in 60 minutes](<https://devfeed.tech/articles/graydon-hoare-21-compilers-and-3-orders-of-magnitude-in-60-minutes-29487.md>)

Original publisher: [Read original article](<http://lambda-the-ultimate.org/node/5648>)

Published: 2022-02-27T14:47:26Z

Content type: opinion

Language: en

Sources: [Lambda the Ultimate](<https://devfeed.tech/sources/lambda-the-ultimate.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [Code](<https://devfeed.tech/topics/code.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>)

Tags: [bytecode](<https://devfeed.tech/tags/bytecode.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [ml](<https://devfeed.tech/tags/ml.md>), [pdf](<https://devfeed.tech/tags/pdf.md>), [presentation](<https://devfeed.tech/tags/presentation.md>), [talk](<https://devfeed.tech/tags/talk.md>), [theory](<https://devfeed.tech/tags/theory.md>)

### AI overview

The article discusses Graydon Hoare's 2019 undergraduate talk about compiler design, summarizing different approaches ranging from large traditional compilers to variants using selective optimization, compiler-friendly languages, theory-driven tools, intermediate representations, interpretation, partial evaluation, or hand-written implementations.

### Source excerpt

In 2019, Graydon Hoare gave a talk to undergraduates (PDF of slides) trying to communicate a sense of what compilers looked like from the perspective of people who did it for a living. I've been aware of this talk for over a year and meant to submit a story here, but was overcome by the sheer number of excellent observations. I'll just summarise the groups he uses: The giants: by which he means the big compilers that are built the old-fashioned way that throw massive resources at attaining efficiency The variants, which use tricks to avoid being so massive: Fewer optimisations: be traditional, but be selective and only the optimisations that really pay off Use compiler-friendly languages, by which he is really taking about languages that are good for implementing compilers, like Lisp and ML Theory-driven meta-languages, esp. how something like yacc allows a traditional Dragon-book style compiler to be written more easily Base compiler on a carefully designed IR that is either easy to compile or reasonable to bytecode-interpret Exercise discretion to have the object code be a mix of compiled and interpreted Use sophisticated partial evaluation Forget tradition and implement everything directly by hand I really recommend spending time working through these slides. While much of the material I was familiar with, enough was new, and I really appreciated the well-made points, shout-outs to projects that deserve more visibility, such as Nanopass compilers and CakeML, and the presentation of the Futamura projections, a famously tricky concept, at the undergraduate level.

## Algebraic Effects for the Rest of Us

DevFeed: [Algebraic Effects for the Rest of Us](<https://devfeed.tech/articles/algebraic-effects-for-the-rest-of-us-36160.md>)

Original publisher: [Read original article](<https://overreacted.io/algebraic-effects-for-the-rest-of-us/>)

Published: 2019-07-21T00:00:00Z

Content type: tutorial

Language: en

Sources: [Dan Abramov](<https://devfeed.tech/sources/dan-abramov.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [React](<https://devfeed.tech/topics/react.md>), [hooks](<https://devfeed.tech/topics/hooks.md>), [OCaml](<https://devfeed.tech/topics/ocaml.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>)

Tags: [callback](<https://devfeed.tech/tags/callback.md>), [code](<https://devfeed.tech/tags/code.md>), [error-handling](<https://devfeed.tech/tags/error-handling.md>), [hooks](<https://devfeed.tech/tags/hooks.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [ocaml](<https://devfeed.tech/tags/ocaml.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [react](<https://devfeed.tech/tags/react.md>)

### AI overview

An accessible introduction to algebraic effects, explaining them as a research programming-language feature and connecting the concept to mental models used in React. The article notes that production support remains limited, with ongoing work in OCaml and similar capabilities available in some Lisp languages.

### Source excerpt

They're not burritos.

## Why Small Programming Languages Can Encourage Implementations Instead of Use

DevFeed: [Why Small Programming Languages Can Encourage Implementations Instead of Use](<https://devfeed.tech/articles/the-siren-song-of-little-languages-22023.md>)

Original publisher: [Read original article](<http://www.wilfred.me.uk/blog/2019/03/24/the-siren-song-of-little-languages/>)

Author: Wilfred Hughes

Published: 2019-03-24T00:00:00Z

Content type: opinion

Language: en

Sources: [Wilfred Hughes](<https://devfeed.tech/sources/wilfred-hughes.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [Esolang](<https://devfeed.tech/topics/esolang.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>), [Clojure](<https://devfeed.tech/topics/clojure.md>), [Racket](<https://devfeed.tech/topics/racket.md>)

Tags: [clojure](<https://devfeed.tech/tags/clojure.md>), [languages](<https://devfeed.tech/tags/languages.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>)

### AI overview

This commentary examines how small, elegant programming-language specifications can encourage developers to build implementations rather than use the language. It discusses BF, Scheme, Shen, Forth, Clojure, and Racket, and argues that language designers should consider the risk while recognizing that multiple implementations can also indicate language health.

### Source excerpt

Some programming languages languish due to obscurity. They lack breathless blog posts exclaiming how much nicer they are to use. Other languages are too ambitious. They aspire to support so many features that the original implementers struggle to get a first version working. For example, the type system in Fortress required constraint solving which took exponential time. Sometimes a usable language struggles simply because it's too much fun to write your own. Developers end up building their own implementation rather than actually using the language. The most obvious implementation-focused language is BF. Despite having many implementations, BF programmers have to encourage the implementers to actually try using the language! Scheme is also susceptible to this. Wikipedia lists 31 different Scheme implementations, not to mention the many toy implementations. Writing a Scheme is a great introduction to interpreters, especially once you get beyond the minimal lisp featureset. I've certainly written more implementation code than Scheme code. The problem seems to be languages with a small, well written specification. Shen is a multiparadigm lisp defined in terms of an elegant base language with only 46 system functions. This has resulted in a remarkable 15 third-party implementations, but only a small number of libraries implemented in the language. This phenomenon is not limited to lisps. Forth is also a language that developers often prefer to implement rather than use. Jones Forth is both a Forth tutorial and a discussion of how to build a Forth compiler. There are even stories of people spending years working on implementations without learning much of the language. Designing a language with a straightforward implementation is not a bad thing. It's just a pitfall that language designers need to be aware of. Some crypto systems have this problem too. It seems that we need languages to be big enough that new users write hello world in the language, not write a tool for

## Nerd Sniped by BINFMT\_MISC

DevFeed: [Nerd Sniped by BINFMT\_MISC](<https://devfeed.tech/articles/nerd-sniped-by-binfmt-misc-35180.md>)

Original publisher: [Read original article](<https://blog.jessfraz.com/post/nerd-sniped-by-binfmt_misc/>)

Published: 2018-03-04T15:25:24Z

Content type: article

Language: en

Sources: [Jessie Frazelle](<https://devfeed.tech/sources/jessie-frazelle.md>)

Topics: [Containers](<https://devfeed.tech/topics/containers.md>), [Kernel](<https://devfeed.tech/topics/kernel.md>), [Common Lisp](<https://devfeed.tech/topics/common-lisp.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>), [Scripting](<https://devfeed.tech/topics/scripting.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>)

Tags: [containers](<https://devfeed.tech/tags/containers.md>), [go](<https://devfeed.tech/tags/go.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [scripting](<https://devfeed.tech/tags/scripting.md>)

### AI overview

The author explores using BINFMT_MISC to run scripts in different languages without installing their runtimes on the host. They combine it with binctr, a project that embeds a container image into a static executable, and demonstrate the approach with a Common Lisp container.

### Source excerpt

This is a story about how I got nerd sniped by a blog post from Cloudflare Engineering. The TLDR on their post is that you can script in Go if you use BINFMT_MISC in the kernel. BINFMT_MISC is really well documented and awesome. In the end, all they had to do to script in Go was to mount the filesystem: $ mount binfmt_misc -t binfmt_misc /proc/sys/fs/binfmt_misc Then, register the Go script binary format: $ echo ':golang:E::go::/usr/local/bin/gorun:OC' | sudo tee /proc/sys/fs/binfmt_misc/register :golang:E::go::/usr/local/bin/gorun:OC Then you can ./ any go file on your host: $ chmod u+x helloscript.go $ ./helloscript.go Hello, world! They go through all the extraordinary details of exit codes for the shell and blah blah blah. It's a great post you should really read it. Do it, go read it, then come back here and I will take it to 11. ... Okay, cool, you are back. That post was dope right? I kinda want to do this with all languages. Because I LOVE SCRIPTING. Have you seen my cloud native dotfiles? My bash scripts smell like roses. Right, so I want to do this with all languages... but what I also hate is installing shit on my host. Ew, we have containers for those silly things. Luckily, I know a thing or two about containers... A few years ago I made a project called binctr. It creates fully static, unprivileged, self-contained, containers as executable binaries. (Wow that was a lot of words, let's break it down.) What binctr does is embed an entire container image (aka rootfs) into a fully static binary and when you execute the binary it will unpack the image and run it as a container. So you get containers without a daemon or privileges and without even having the image for the rootfs of the container. You just need this one binary. (Huge thanks to @lordcyphar who got rootless containers into runc so I could actually archive my gross hack for binctr.) Kinda seems like the perfect match for trying to use all languages with BINFMT_MISC. So I tried it. (Preface: this post s

## Remacs II: New Rust Features, GNU Emacs Compatibility Updates, and Build Improvements

DevFeed: [Remacs II: New Rust Features, GNU Emacs Compatibility Updates, and Build Improvements](<https://devfeed.tech/articles/these-weeks-in-remacs-ii-22015.md>)

Original publisher: [Read original article](<http://www.wilfred.me.uk/blog/2017/07/15/these-weeks-in-remacs-ii/>)

Author: Wilfred Hughes

Published: 2017-07-15T00:00:00Z

Content type: release

Language: en

Sources: [Wilfred Hughes](<https://devfeed.tech/sources/wilfred-hughes.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Emacs](<https://devfeed.tech/topics/emacs.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>), [Docker Compose](<https://devfeed.tech/topics/docker-compose.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [macOS](<https://devfeed.tech/topics/macos.md>)

Tags: [docker](<https://devfeed.tech/tags/docker.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [emacs](<https://devfeed.tech/tags/emacs.md>), [github](<https://devfeed.tech/tags/github.md>), [linux](<https://devfeed.tech/tags/linux.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [macos](<https://devfeed.tech/tags/macos.md>), [pull-requests](<https://devfeed.tech/tags/pull-requests.md>), [rust](<https://devfeed.tech/tags/rust.md>)

### AI overview

This Remacs project update describes new Elisp primitive functions, Rust support, GNU Emacs compatibility documentation, platform fixes, a restructured codebase, procedural macros, Rust crates, and Docker Compose support for building without a local development toolchain.

### Source excerpt

It's been six months since the last Remacs update, and many new features have landed! Community We now have a Gitter chat room! Do drop by if you have any questions or wish to discuss Remacs. There's a low traffic Remacs Subreddit too. We've added @jeandudey and @birkenfeld to the GitHub collaborators, bringing us to five fine people who can approve your pull requests. Elisp Features We're still tracking upstream GNU Emacs master, so new features there are landing in Remacs (1, 2). We've added a lot new elisp primitive functions: Strings: characterp, multibyte conversions (1, 2, 3), and comparisons Vectors: type definitions, functions Buffers: type definitions, functions Symbols: various functions A much requested feature, adding Rust support to find-function, has been added. This was an unusual PR as it includes some elisp changes in Remacs. We now have documentation on our compatibility with GNU Emacs. This covers all known implementation differences, platform support differences, and describes how to detect Remacs in elisp code. Cleanup Platforms: We've dropped MS-DOS support. The Remacs build has been fixed on 32-bit Linux and 32-bit macOS. The codebase has been split out: remacs-lib (Rust equivalents of gnulib) remacs-sys (type definitions of Emacs types and C functions) remacs-macros (procedural macros supporting elisp primitive functions in Rust) src (Rust implementation code of elisp) Signal name mapping is pure Rust code. We now run rustfmt on every PR. If you fancy building Remacs without installing a dev toolchain (compilers, C libraries etc), there's now a docker-compose.yml to make your life easy. Macros It wouldn't be a proper lisp project without some macro magic. After several PRs and discussions, Remacs now includes a procedural macro to simplify defining elisp functions in Rust. For example, here's vectorp: /// Return t if OBJECT is a vector. #[lisp_fn] fn vectorp(object: LispObject) -> LispObject { LispObject::from_bool(object.is_vector()) } Lever

## Find The Missing Integer

DevFeed: [Find The Missing Integer](<https://devfeed.tech/articles/find-the-missing-integer-34556.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2017/05/find-the-missing-integer/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2017-05-30T17:56:54Z

Content type: article

Language: en

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

Topics: [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [math](<https://devfeed.tech/topics/math.md>), [Common Lisp](<https://devfeed.tech/topics/common-lisp.md>), [Computer science](<https://devfeed.tech/topics/computer-science.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>), [Python](<https://devfeed.tech/topics/python.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [math](<https://devfeed.tech/tags/math.md>), [python](<https://devfeed.tech/tags/python.md>), [set](<https://devfeed.tech/tags/set.md>), [sorting](<https://devfeed.tech/tags/sorting.md>)

### AI overview

The article examines ways to find missing elements in a list. It contrasts sorting and the Gauss-sum method for one missing integer with set difference, which can handle multiple missing entries and arbitrary data types in Common Lisp and Python.

### Source excerpt

A recent interview question that I had to review was spelled like this: Find missing int element into array 1..100 Of course at first read I got it wrong, you have only one integer to look for into the array. So while the obvious idea was to apply classic sorting techniques and minimize array traversal to handle complexity (time and space), it turns out there's a much simpler way to do it if you remember your math lessons from younger. But is it that much simpler?

## Checked vs. Unchecked Exceptions in Java: A Historical Perspective and Comparison

DevFeed: [Checked vs. Unchecked Exceptions in Java: A Historical Perspective and Comparison](<https://devfeed.tech/articles/checked-vs-unchecked-exceptions-in-java-why-it-s-so-confusing-24997.md>)

Original publisher: [Read original article](<https://codeahoy.com/java/2016/04/02/checked-vs-unchecked-exceptions-in-java/>)

Author: umer

Published: 2016-04-02T00:00:00Z

Content type: tutorial

Language: en

Sources: [Code Ahoy - Articles](<https://devfeed.tech/sources/code-ahoy-articles.md>)

Topics: [Exception](<https://devfeed.tech/topics/exception.md>), [Java](<https://devfeed.tech/topics/java.md>), [Error Handling](<https://devfeed.tech/topics/error-handling.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [C](<https://devfeed.tech/topics/c.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [error-handling](<https://devfeed.tech/tags/error-handling.md>), [exception-handling](<https://devfeed.tech/tags/exception-handling.md>), [exceptions](<https://devfeed.tech/tags/exceptions.md>), [java](<https://devfeed.tech/tags/java.md>), [lisp](<https://devfeed.tech/tags/lisp.md>)

### AI overview

A tutorial for new Java developers that explains the historical motivation for Java's exception-handling mechanism and examines the debate between checked and unchecked exceptions, contrasting them with error-code patterns in C.

### Source excerpt

This blog post is intended for new Java developers. It starts with a historical perspective and a look at what motivated the design and creation of Java's exception handling mechanism. It also explores the hotly debated checked vs unchecked exceptions debate with some personal insights. Let's start. Historical Perspective Back in the time of the "C" programming language, it was customary to return values such as -1 or NULL from functions to indicate errors. This was practical for small applications but didn't scale well for larger applications - developers had to check and track every possible return value: a return value of 2 might indicate "host is down" error in library A whereas in library B, it could mean "illegal filename". Although, developers tried to fix this and attempts were made to standardize error codes by setting global variables, but it didn't help much. #define ENOENT 2 /* No such file or directory */ #define ESRCH 3 /* No such process */ #define EINTR 4 /* Interrupted system call */ #define EIO 5 /* I/O error */ #define ENXIO 6 /* No such device or address */ #define E2BIG 7 /* Argument list too long */ #define ENOEXEC 8 /* Exec format error */ #define EBADF 9 /* Bad file number */ #define ECHILD 10 /* No child processes */ #define EAGAIN 11 /* Try again */ #define ENOMEM 12 /* Out of memory */ James Gosling and other designers felt that a similar approach would go against the design goals of Java programming language. They wanted: a cleaner, robust and portable approach built-in language support for error checking and handling. Essentially, one of their main design goals was to build a language that's robust and able to cope with errors during execution or at least recognize when going go wrong. This principle is at the core of Java's error handling design, as we'll see later. James Gosling explains in one of his interviews: One of the traditional things to screw up in C code is opening a data file to read. It's semi-traditional in the C world to

## SICP in Clojure - Chapter 4

DevFeed: [SICP in Clojure - Chapter 4](<https://devfeed.tech/articles/sicp-in-clojure-chapter-4-22367.md>)

Original publisher: [Read original article](<http://www.afronski.pl/sicp-in-clojure/2015/10/05/sicp-in-clojure-chapter-4.html>)

Author: Wojtek Gawroński (afronski)

Published: 2015-10-05T14:00:00Z

Content type: tutorial

Language: en

Sources: [Wojtek Gawroński](<https://devfeed.tech/sources/wojtek-gawronski.md>)

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>), [Code](<https://devfeed.tech/topics/code.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>)

Tags: [abstraction](<https://devfeed.tech/tags/abstraction.md>), [c-sharp](<https://devfeed.tech/tags/c-sharp.md>), [canvas](<https://devfeed.tech/tags/canvas.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [css](<https://devfeed.tech/tags/css.md>), [css3](<https://devfeed.tech/tags/css3.md>), [erlang](<https://devfeed.tech/tags/erlang.md>), [functional](<https://devfeed.tech/tags/functional.md>), [html](<https://devfeed.tech/tags/html.md>), [html5](<https://devfeed.tech/tags/html5.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [mono](<https://devfeed.tech/tags/mono.md>), [net](<https://devfeed.tech/tags/net.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [sicp](<https://devfeed.tech/tags/sicp.md>), [structure](<https://devfeed.tech/tags/structure.md>), [syntax](<https://devfeed.tech/tags/syntax.md>), [vagrant](<https://devfeed.tech/tags/vagrant.md>), [webgl](<https://devfeed.tech/tags/webgl.md>)

### AI overview

This chapter in a series on SICP in Clojure explains Lisp concepts including homoiconicity, metalinguistic abstraction, and metacircular evaluators. It describes how homoiconic languages represent program structure as data and introduces evaluators written in the language they interpret.

### Source excerpt

SICP in Clojure - Chapter 4 In one of the previous blog posts I have announced that I would like to start a new series of posts. It is a persistent journal from my journey through aforementioned book. I hope that you will enjoy it and find it useful - the main goal is to make this series a place where we can return in future, recall ideas and thoughts that accompanied reading process. Introduction By finishing the previous chapter we learned more about functional programming, designing and dealing with stateful computation and a little bit about laziness. It was pretty much a general purpose programming book till now. Last two chapters of the book are really ... Lispy. :wink: Chapter which will be discussed today is focused on Lisp core values built around universal evaluator, homoiconicity and linguistic abstractions. What is homoiconicity? Very concise, I would say a mathematical, definition will explain it as a isomorphic relation between language AST (Abstract Syntax Tree) and its syntax. In more human friendly words - it is a property of a programming language in which the program structure is similar to its syntax. If such language is homoiconic, it allows all code in the language to be accessed and transformed as data, using the same representation - because AST is exactly the same as the language itself. All languages from Lisp family have this property, also languages like Io, Julia or Prolog also have this ability (to a certain degree of course). Keep in mind that it does not mean that having a macros system in the language makes it homoiconic. Metalinguistic abstraction Title of this section sounds like a difficult concept, where the core idea is really simple. Aforementioned abstraction is an ability to create new languages. We have done that previously (e.g. by creating various Domain Specific Languages when solving exercises). By the creation, authors also mean ability to evaluate (or interpret) constructs written in that newly created dialect, by calcul

## Quicklisp and debian

DevFeed: [Quicklisp and debian](<https://devfeed.tech/articles/quicklisp-and-debian-34553.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2015/05/quicklisp-and-debian/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2015-05-02T14:06:00Z

Content type: tutorial

Language: en

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

Topics: [Common Lisp](<https://devfeed.tech/topics/common-lisp.md>), [Debian](<https://devfeed.tech/topics/debian.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>), [Software](<https://devfeed.tech/topics/software.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [releases](<https://devfeed.tech/topics/releases.md>)

Tags: [automate](<https://devfeed.tech/tags/automate.md>), [automated](<https://devfeed.tech/tags/automated.md>), [debian](<https://devfeed.tech/tags/debian.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [library](<https://devfeed.tech/tags/library.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [releases](<https://devfeed.tech/tags/releases.md>)

### AI overview

The article describes using Quicklisp as an upstream source for packaging Common Lisp libraries for Debian. It explains how the ql-to-deb software reads Quicklisp metadata, compares releases with managed Debian packages, automates updates, and supports testing and signing packages before upload.

### Source excerpt

Common Lisp users are very happy to use Quicklisp when it comes to downloading and maintaining dependencies between their own code and the librairies it is using.

## Make a Lisp in Nim

DevFeed: [Make a Lisp in Nim](<https://devfeed.tech/articles/make-a-lisp-in-nim-30824.md>)

Original publisher: [Read original article](<https://hookrace.net/blog/make-a-lisp-in-nim/>)

Published: 2015-03-03T23:00:00Z

Content type: tutorial

Language: en

Sources: [Dennis Felsing](<https://devfeed.tech/sources/dennis-felsing.md>)

Topics: [Nim](<https://devfeed.tech/topics/nim.md>), [Lisp](<https://devfeed.tech/topics/lisp.md>), [Code](<https://devfeed.tech/topics/code.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [make](<https://devfeed.tech/topics/make.md>)

Tags: [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [build](<https://devfeed.tech/tags/build.md>), [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [nim](<https://devfeed.tech/tags/nim.md>), [programming](<https://devfeed.tech/tags/programming.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

The article describes implementing a Lisp interpreter in Nim by following the Make a Lisp guide. It explains how to build, run, and test the implementation, and reports rough benchmark results comparing Nim with several other languages. The author notes that the measurements are not optimized or definitive.

### Source excerpt

I spent the last weekend working through the amazing guide for Make a Lisp, writing a Lisp interpreter in Nim. The final result just made it into the repository. Running the Nim version is pretty simple. You need the Nim compiler from the devel branch and nre which can be installed through nimble. After installing those you can build and run the MAL interpreter: $ cd nim $ make # OR $ nimble build $ ./stepA_mal Mal [nim] user> 12 12 user> (+ 2 3) 5 Running the tests: $ cd .. $ make "test^nim^step1" # A single test $ make "test^nim" # All tests $ make "perf^nim" # All benchmarks There is a nice presentation in MAL about MAL you can read: $ cd nim $ ./stepA_mal ../examples/clojurewest2014.mal And you can run MAL implented in MAL itself using the Nim interpreter: $ ./stepA_mal ../mal/stepA_mal.mal Mal [nim-mal] mal-user> The benchmark results from Joel Martin, the author of MAL, don't look bad for Nim. Edit: Note that these are just rough measurements to see that the Nim implementation is doing fine. Don't judge the other languages for their numbers, which may not have ideal implementations performance-wise. In the short benchmarks Nim is the fastest, in the long benchmark only the JVM can beat it. I didn't really try to optimize and oriented mostly on the Python implementation, which is quite a lot slower as you can see. So it's pretty nice to see idiomatic Nim performing well: perf1 perf2 perf3 macros math macros ms ms iters/sec java 6 24 17969 scala 47 87 15963 nim 1 1 11121 ocaml 1 3 7063 cs 10 11 5414 vb 12 13 4523 rust 2 5 4084 c 1 4 3649 go 1 6 3048 racket 3 10 2461 coffee 5 11 2326 js 6 14 1726 ruby 4 15 1255 haskell 4 14 1163 clojure 11 23 1174 forth 9 29 563 php 13 51 331 python 14 51 304 bash 1673 9000 276 perl 18 69 215 ps 41 332 48 R 116 490 28 miniMAL 779 3448 4 matlab 1688 5844 2 make 3427 28453 0 I also didn't really aim for a low amount of code but rather good readability, but it may still be interesting to look at. I guess Nim's size being so close to

## Pgloader Post Gains Attention on Hacker News and Postgres Weekly

DevFeed: [Pgloader Post Gains Attention on Hacker News and Postgres Weekly](<https://devfeed.tech/articles/my-first-slashdot-effect-34547.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2015/01/my-first-slashdot-effect/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2015-01-22T00:48:00Z

Content type: opinion

Language: en

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

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Common Lisp](<https://devfeed.tech/topics/common-lisp.md>), [backups](<https://devfeed.tech/topics/backups.md>), [FOSDEM](<https://devfeed.tech/topics/fosdem.md>)

Tags: [backups](<https://devfeed.tech/tags/backups.md>), [hacker-news](<https://devfeed.tech/tags/hacker-news.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>)

### AI overview

The author says a Pgloader post received attention in Postgres Weekly issue #89 and on the Hacker News front page, creating a surge in traffic described as a first Slashdot effect. The post also mentions upcoming pgloader talks at FOSDEM and PGDAY, including PostgreSQL migration and tested backups.

### Source excerpt

Thanks to the Postgres Weekly issue #89 and a post to Hacker News front page (see Pgloader: A High-speed PostgreSQL Swiss Army Knife, Written in Lisp it well seems that I just had my first Slashdot effect...

## Why is pgloader so much faster?

DevFeed: [Why is pgloader so much faster?](<https://devfeed.tech/articles/why-is-pgloader-so-much-faster-34540.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2014/05/why-is-pgloader-so-much-faster/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2014-05-14T12:59:00Z

Content type: article

Language: en

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

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Common Lisp](<https://devfeed.tech/topics/common-lisp.md>), [CSV](<https://devfeed.tech/topics/csv.md>), [Streaming](<https://devfeed.tech/topics/streaming.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [csv](<https://devfeed.tech/tags/csv.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [python](<https://devfeed.tech/tags/python.md>), [streaming](<https://devfeed.tech/tags/streaming.md>)

### AI overview

The article explains why a rewritten version of pgloader became much faster. Moving from Python to Common Lisp addressed performance and threading limitations while retaining PostgreSQL's COPY streaming protocol; a cited CSV import case was up to 30 times faster.

### Source excerpt

pgloader loads data into PostgreSQL. The new version is stable enough nowadays that it's soon to be released, the last piece of the 3.1.0 puzzle being full debian packaging of the tool.

## 7th European Lisp Symposium

DevFeed: [7th European Lisp Symposium](<https://devfeed.tech/articles/7th-european-lisp-symposium-34624.md>)

Original publisher: [Read original article](<https://tapoueh.org/conf/7th-european-lisp-symposium/>)

Published: 2014-05-04T22:00:00Z

Content type: opinion

Language: en

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

Topics: [Lisp](<https://devfeed.tech/topics/lisp.md>), [Common Lisp](<https://devfeed.tech/topics/common-lisp.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [Python](<https://devfeed.tech/topics/python.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [language](<https://devfeed.tech/tags/language.md>), [lightning](<https://devfeed.tech/tags/lightning.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [modern](<https://devfeed.tech/tags/modern.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [python](<https://devfeed.tech/tags/python.md>), [rewrite](<https://devfeed.tech/tags/rewrite.md>), [switching](<https://devfeed.tech/tags/switching.md>), [talk](<https://devfeed.tech/tags/talk.md>)

### AI overview

A lightning talk at the 7th European Lisp Symposium discusses rewriting pgloader from Python in Common Lisp. The stated motivation was wanting a modern programming language.

### Source excerpt

A lightning talk about pgloader and why I chose to rewrite it enterily, switching from Python to Common Lisp. TL;DR -- I wanted a Modern Programming Language.

## Homoiconicity: Code as Data in Lisp Macros

DevFeed: [Homoiconicity: Code as Data in Lisp Macros](<https://devfeed.tech/articles/just-what-does-code-as-data-mean-anyway-32173.md>)

Original publisher: [Read original article](<https://adambard.com/blog/what-is-homoiconicity/>)

Published: 2014-01-19T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [Lisp](<https://devfeed.tech/topics/lisp.md>), [syntax](<https://devfeed.tech/topics/syntax.md>), [Clojure](<https://devfeed.tech/topics/clojure.md>)

Tags: [lisp](<https://devfeed.tech/tags/lisp.md>), [macros](<https://devfeed.tech/tags/macros.md>), [metaprogramming](<https://devfeed.tech/tags/metaprogramming.md>)

### AI overview

An introductory explanation of homoiconicity in Lisp-family languages. It contrasts Lisp macros, which manipulate abstract syntax trees as values, with C-style string substitution and uses a macro example to show how code can generate code.

### Source excerpt

Recently, I've seen popular articles on macros and metaprogramming in Nimrod and Elixir. Both of these are wonderful metaprogramming systems, to be sure, but I couldn't help but imagine some in the audience smirking inwardly - and occasionally less inwardly. What odd syntax! How out-of-place they are! If only there existed a homiconic language, they think sarcastically, that could eliminate the need for awkward and forced syntax. Of course, these smug bastards are users of any of the LISP family of languages.

## Import fixed width data with pgloader

DevFeed: [Import fixed width data with pgloader](<https://devfeed.tech/articles/import-fixed-width-data-with-pgloader-34529.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2013/11/import-fixed-width-data-with-pgloader/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2013-11-18T11:48:00Z

Content type: tutorial

Language: en

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

Topics: [import](<https://devfeed.tech/topics/import.md>), [data](<https://devfeed.tech/topics/data.md>), [Common Lisp](<https://devfeed.tech/topics/common-lisp.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [file](<https://devfeed.tech/tags/file.md>), [import](<https://devfeed.tech/tags/import.md>), [lisp](<https://devfeed.tech/tags/lisp.md>)

### AI overview

This article revisits importing fixed-width data with pgloader, correcting earlier timing methodology and comparing results with a newer version. It reports loading times ranging from 366 to 700 milliseconds and describes a command that downloads and unpacks a ZIP source before loading and trimming the data.

### Source excerpt

A long time ago we talked about how to Import fixed width data with pgloader, following up on other stories still online at Postgres OnLine Journal and on David Fetter's blog. Back then, I showed that using pgloader made it easier to import the data, but also showed quite poor performances characteristics due to using the debug mode in the timings. Let's update that article with current pgloader wonders!

## Optimizing Integer-to-IP Conversion in Common Lisp

DevFeed: [Optimizing Integer-to-IP Conversion in Common Lisp](<https://devfeed.tech/articles/a-worthwile-micro-optimisation-34521.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2013/10/a-worthwile-micro-optimisation/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2013-10-03T20:10:00Z

Content type: article

Language: en

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

Topics: [Common Lisp](<https://devfeed.tech/topics/common-lisp.md>), [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [implementation](<https://devfeed.tech/topics/implementation.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [code](<https://devfeed.tech/tags/code.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [little](<https://devfeed.tech/tags/little.md>), [optimisation](<https://devfeed.tech/tags/optimisation.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>)

### AI overview

This article describes a Common Lisp micro-optimization for converting integer values to IP representations while loading geolocation data into PostgreSQL. It precomputes dotted-byte representations at load time, substantially reducing the transformation's added cost.

### Source excerpt

In our previous article about Loading Geolocation Data, we did load some data into PostgreSQL and saw the quite noticable impact of a user transformation. As it happens, the function that did the integer to IP representation was so naive as to scratch the micro optimisation itch of some Common Lisp hackers: thanks a lot guys, in particular stassats who came up with the solution we're seeing now.

## Loading Geolocation Data

DevFeed: [Loading Geolocation Data](<https://devfeed.tech/articles/loading-geolocation-data-34524.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2013/10/loading-geolocation-data/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2013-10-01T14:52:00Z

Content type: tutorial

Language: en

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

Topics: [Common Lisp](<https://devfeed.tech/topics/common-lisp.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [data](<https://devfeed.tech/topics/data.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [database](<https://devfeed.tech/tags/database.md>), [lisp](<https://devfeed.tech/tags/lisp.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

The article discusses rewriting pgloader from Python in Common Lisp. It explains configuration-language limitations, concerns about performance when loading larger files into databases, and the use of geolocation data as a test case for improving pgloader's data-loading workflow.

### Source excerpt

As I've been mentionning in the past already, I'm currently rewriting pgloader from scratch in Common Lisp. In terms of technical debt that's akin to declaring bankrupcy, which is both sad news and good news as there's suddenly new hope of doing it right this time.

[Next page](<https://devfeed.tech/tags/lisp.md?cursor=WyIyMDEzLTEwLTAxVDE0OjUyOjAwKzAwOjAwIiwgIjJhYTMwMzAyLWY2MGUtNDc5NC04M2NiLTkxMjYxMDczOTZlNSJd>)