programming

Posts tagged with programming

A creation-first interface

One of the primary wonders of computing is that creation on a computer is essentially completely free, once you have one – the world of information is a post-scarcity one where the only cost is your time, and that's it. Bits can represent anything, from prose to poetry to images to film to interactive games to music, and bits can be created and infinitely duplicated (taking poetic license here, don't come after me, I know they're technically being modified not created) at zero cost, on your ow

A plea for simpler FP

Software development is a terribly young industry in comparison to other similar fields like engineering and architecture. In so many ways, we have no idea what we're doing; we can't even agree on basic methodological issues, let alone more complex questions, and we've got almost zero empirical evidence – even meaningful case-studies, let alone proper scientific studies with decent sample sizes and good design – one way or the other for most practical debates (memory safety and static types a

Agentic AI outside coding

The level of competence, adaptiveness, and general capability even qwen-code (known to be a pretty bad agent framework/app compared to the best ones) displays is genuinely insane. I can just give it a task, turn on a sandbox and YOLO mode, and it will execute exploratory find, grep, curl, ls, which etc commands to figure out the structure of its environment and the data I'm giving it, and then write and execute command line scripts (or python, and install dependencies, and use curl to access

Emacs Lisp really isn't bad

It seems to be common wisdom in the Emacs community that Emacs Lisp is just this terrible programming language that everyone hates, on the level with something like PHP. However, I just don't think that's the case. Emacs Lisp is strongly typed, has an extremely complete and extensive standard library, it has all of the power of a full Lisp including live mutation of a running system, procedural macros, symbolic programming, and homoiconicity, a copy of the Common Lisp standard library (includin

Emacs and the UNIX philosophy, part 2

See also: UNIX, Lisp Machines, Emacs, and the Four User Freedoms.

Each of the main tenets of the UNIX philosophy has essentially a kernel of truth to it:

However, it misunderstands how best to achieve e

Formal methods and dependant types are a trap

The First Trap

A response to the previous section might be that there doesn't have to be a distinction between formal methods/proofs, or writing a lot of code at the type level, and writing code that gets shit done. After all, there are things like Algebra Driven Design, where you specify your data types and function signatures to such an minute degree of detail that you can sort of derive the actual program by rote from your types.

The problem

Gap Buffers

A lot of people criticize Emacs's use of the gap buffer, and suggest that it go with a more complex data structure at the core like ropes. While I think there can certainly be room for improvement with this core data structure, I don't think ropes are a good solution, and I think this is far from a crippling issue. Let me start with the second point first.

One of the biggest arguments against gap buffers is that they're

Hand tools and workbench tools

It might seem strange that I am a big proponent of malleable systems like Emacs and Lisp, and also of Fedora Atomic and GNOME. Someone who disagreed with me on one of these preference might even be tempted to accuse me of hypocrisy, or otherwise use one preference to undermine the other. However, I'd argue it's perfectly consistent due to a crucial distinction I talk about in my GNOME Is Not 'Mobile-First' essay: the split between hand tools and workbench tools (I didn't use exactly these t

How to design software

In his classic essay Lisp: Good News, Bad News, How to Win Big, Richard Gabriel outlines two different approaches to designing software, called the MIT approach or the 'Right Thing' and the New Jersey approach or 'Worse is Better,' and describes why he thinks the latter approach to design, while worse on all the metrics he cared about – he was an MIT man himself – had "better survival characteristics."

In his estimation, this was because while the M

Hyperfiction and Org-Mode

I've been interested in parser interactive fiction for a very long time – it's a wonderful, fascinating topic which I was introduced to by one of my favorite books of all time.

The way in which the world is not just represented at the base level of the program as a cloud of points and numbers with no inherent meaning, assembled into trees of containers that are ultimately elided at compile time and cannot be directly manipulated, in such a way that

Imbuing text with meaning

Some of the most important meanings that you can imbue into text, in my opinion, are:

  1. Symbols to label the intended "thing" that region of text is supposed to represent
  2. Data structures representing the structured concrete syntax tree of the annotated text, to easily maintain an identity between the two and retrieve it
  3. Context or related pieces of data, whether textual or structured
  4. Hypertext links

For a concrete example of the first, the package Marginalia looks for any lines an

Key arpeggios versus key chords

It is my strong opinion that arpeggiated key bindings – key bindings where you press multiple single, un-modified keys in a sequence, as you would in things like Emacs god-mode or Vim – are vastly superior, ergonomically, to key chords – like you would use in traditional GUI applications, or in vanilla Emacs. This is for a few reasons.

  1. Having to hold a key down for an extended period of time is inherently more stressful and straining than just hitting it once, just like having to stand h

Language doesn't matter. Libraries do.

For all my obsession with powerful and flexible programming languages, and believe that programming languages are tools for thought, in the end, if you want to be productive in the real world, here and now, instead of spending all your time in a daydream of a better world where Lisp won, either bitter and resentful or

Limiting language expressiveness is a technical solution to a social problem (a category error)

The common objection to the idea that programming languages should be powerful enough to express almost any idea or abstraction is that this will result in certain programmers on a team – who are either much smarter than everyone else, overestimate their own intelligence, or are simply undisciplined – writing code that nobody can understand using all sorts of unnecessarily advanced features. Thus, they suggest, the correct solution is to dumb down a programming language, to hobble it, cutting

My attempt at explaining for laypeople how LLMs work

Basically, the way that large language models like ChatGPT work is that they read in chunks of words known as tokens. These are typically like short words, or sections of longer compound words, usually no more than four letters long. Large language models use an algorithm known as a transformer — originally invented for natural language translation — that reads in a large amount of tokens and then outputs the next token. To produce multiple output tokens, like it would in a chat, it jus

My opinion on large language models

There has been a lot of controversy around large language models lately.

Fundamental limitations

In my opinion, they have fundamental flaws that mean that you can't use them for many of the things people are claiming you can use them for, such as obtaining factual information, programming, or writing things for you. This becomes clear if if you look at how large language models actually work:

Natural language can still be good for programming

Since natural language sacrifices specificity in favor of painting with broad brushstrokes, many people — especially programmers and a certain kind of analytic philosopher — consider it inferior, thinking that the only "true" way to think about a problem or understand properly is to express it in formal language. While I agree that computational languages are clearly better for gaining a deep understanding of a problem than non-executable formal

Personanet and infonet, and the Semantic Web

I recently came across an article on someone's personal blog that spoke eloquently and plainitively about the reason they write online, and how a world of personal AI agents collecting and synthesizing information on-demand for users conflicts with the very reasons they write online in the first place:

There's a fair bit of talk about “Google Zero” at the moment: the day when website traffic referred from Google finally hits zero. If

Programming languages are tools for thought

Written language is a tool for thought.

When thoughts are in your head, they exist as a shifting cloud of ideas and connections, never fully locked down to a specific web of meaning and ideas, with different parts of the larger thought and context free to shift continuously in and out of your focus as you analyze different aspects of the problem. This is because human working memory is generally too small, and too unreliable in particular details, to nail down a precise set of ideas and conn

SVG Interfaces in Emacs?

One of the really interesting little things that I've seen on the margins of the Emacs world is people making use of the fact that SVGs are a really good medium for drawing arbitrary graphical user interfaces, since they allow drawing arbitrary shapes, colors, gradients, and text, in a way where it is clearly structured and you can assign relative constraints and sizes, and where that structure is coherently maintained instead of being lost when drawn to a pixel image or something, and the fact

TODO Stallman needs to die

See also: Kill the author.

TODO Structural type systems and multiple dispatch are the future of type systems

The beauty of Common Lisp

It's often said that Common Lisp is ugly. I don't necessarily disagree, but in this short essay I want to briefly defend the beauty of Common Lisp, precisely in the places where we usually find it most ugly.

Lisp-2

One of the reasons most often cited for Common Lisp being ugly is that it is a Lisp-2 – namely, a Lisp where symbols don't have only one universal meaning, but two separate meanings, depending on where they appear in a form: at the car of a form, where whatever value the symbol

The phenomenology agentic coding

The discursive trap of productivity metrics

AI coding agents are important not because they make one more productive, but because they fundamentally alter what it is like to program. That is what interests me and — I believe — should interest you, about this whole enterprise. The productivity discourse is, to a large degree, misguided noise, a discursive trap motivated by reactionary Luddism on the one hand and market hype on the other. While AI coding agents certainly make me, as a pr

The rise of "Whatever" Machines

Rewrite: refactor to remove all the border properties. If this results in args being merged with an empty :style map, then remove the styled-args variable entirely and have elem-wrapper use args directly instead

I've increasingly used my built-in LLM editor integration to essentially replace emacs macros and regular expression transformations with a syntactically and semantically aware fuzzy transformation system, because it's just infinitely more robust

The two types of programmers

I think there are really two types of programmers in this world: programmers who program because they enjoy constrained logic puzzles like the kind you would find in To Mock a Mockingbird, and programmers who enjoy making the computer do cool things. The kind of programmer who gets really deep into type-level programming and formal methods and so on tends to be the former, and the kind of programmer who wants to pragmatically adopt those things, if necessary, but generally opt for the

UNIX, Lisp Machines, Emacs, and the Four User Freedoms

UNIX

We need to get away from "systems" languages

There's been a lot of discussion over the years of how static languages effect the experience of programming. The summary is that high performance, static, compiled, typed languages come at the cost of being able to have a tight feedback loop and freely experiment as you're writing code, which is typically a bad thing because programming is not an act of mere construction following a specifi

What makes a good programmer

Disclaimer: this is just based on my personal experience programming, and knowing one or two other decent programmers, as well as a few people who bounced off programming entirely. This is not based on extensive industry experience, nor any kind of science. If you're interested in the opinions of someone with much more exprience "in the industry" than I, I recommend checking out "The 10x Programmer Myth" which, despite the clickbait hea

Why I prefer Fedora Atomic (plus BlueBuild) to Nix OS

Why I'm obsessed with Common Lisp

Although I haven't had much chance to use it yet, one of the languages that I have been utterly obsessed with for years is Common Lisp. This, of course, is not a new phenomenon amongst hackers like me. However, I think it's worth articulating why I personally am interested in Common Lisp, because the programming language landscape has changed drastically since the earliest hacker essays singing its praises were written, which has led to some of the points they make b

XBows review: the perfect hacker's keyboard?

The XBows Knight Plus that I am typing this on right now is quite possibly the best single purchase I have ever made in my entire life, hands down. In this review I'll catalog the things I like about it, the things that could be improved but are generally fine, and the things that I don't like about it.

Disclosure

I did pick up my XBows Knight on eBay for $75