-
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 RES... -
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 RES... -
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 own... -
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 ar... -
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 connecti... -
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 each and every one of these options. Human-readable text is a good medium for data, but it is too flexible to be the data interchange format, by itself, and lacks out-of-band capabilities, as I've said before. Breaking down functionality into entirely separate programs/processes is way, way too hard... -
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 mostly irrelevant and useless, or doing shockingly productive work in a field that ultimately won't produce anything that's actually useful to you or anyone else, you need to use w... -
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 (including... -
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 ... -
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 simply not optimized for multiple cursors. I'm not a big fan of multiple cur... -
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 the AI search result tells you everything you need, why wou... -
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 just doe... -
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 languages, which in turn are better in many re... -
Stallman needs to die
See also: Kill the author. -
Structural type systems and multiple dispatch are the future of type systems
-
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 ... -
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. 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 holds will b... -
The phenomenology agentic coding
AI coding agents are important because they fundamentally alter what it is like to program. That is what this essay is about: not whether this transformation is good or bad for programmers as a labor bloc, or economically, or socially; not whether it makes us more or less productive in the odd Taylorist sense that seems prevelent whenever the subject pops up. What interests me and, I believe, should interest you about this whole enterprise, is the phenomenology of how this new human-machine asse... -
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 — yes, LLMs are stochastic, but so is m... -
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 specification, but an act of design, where we're feeling out how things should be executed and constructed as we ... -
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 headline, doesn't deny the fact that there are some programmers... -
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 becoming obsolete -- or more n... -
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. I did pick up my XBows Knight on eBay for 300 MSRP, so that may be biasing my opinions with regard to whether it's worth it, but I really don't think so -- while many of the XBows's features aren... -
Formal methods and dependant types are a 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 with this approach is that is that it doesn't actually solve the p... -
Hand tools and workbench tools
It might seem strange that I am a big proponent of malleablesystems 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 terms i... -
UNIX, Lisp Machines, Emacs, and the Four User Freedoms
Any true hacker knows these principles by heart. Even though I hold many disagreements with Stallman and the FSF-hardliners — for instance, I see free vs proprietary software, and the software freedoms, as a matter of structural critique and industry ethics, not personal purity; proprietary software is being unethical against me for the way it treats me, I am not unethical for using it, because I am the one on whose side the rights lie — I agree with them, fundamentally, on so many more issu... -
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 MIT approach, valuing correctness, completeness... -
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 meaning must be arbitrarily constructed on the... -
Imbuing text with meaning
Some of the most important meanings that you can imbue into text, in my opinion, are:For a concrete example of the first, the package Marginalia looks for any lines annotated with the file symbol in the minibuffer, and uses those lines as paths to look up file information, which it then adds as further metadata to those lines. This means that anything that provides completions in the minibuffer, independent of Marginalia knowing about the specifics of that code, or that code even needing to know... -
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. One might be tempted to bring out the stenographer's keyboard as a counterexample to my statements, but that's not so. The stenographer's keyboard reaches its ... -
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 simplest s...
Tag: programming
32 files