Kartik Agaram

I find that sort of causality hard to draw, though. My choices are either to make it a hard correlation with a minor accomplishment (I tried programming in lisp, and came up with these few programs I found interesting: http://akkartik.name/lisp.html) or to make it a more fuzzy correlation with something bigger ("Everything I have done and everything I will do, would have been less good if you hadn't written what you did." http://akkartik.name/about. Or "When I write I try to imagine how you would react to each sentence." http://akkartik.name/?f=Me) Neither seems satisfactory, especially since other people influenced these accomplishments as well. Let me attempt a middle ground -- using examples. Eliezer, I still maintain an interest in blackboard systems to this day. For example, here's a program I wrote a couple of weeks ago: http://github.com/akkartik/brooks-ruby-warrior/tree/master. Thanks to reading Hofstadter and you and Brooks, I knew when I approached this problem that finding the heuristics to solve a particular AI problem is relatively easy. What is hard is finding an open-ended architecture to integrate lots of heuristics together. I ended up with a faint likeness of an idea others have explored in far harder domains. PG, as I hinted above, inspired me to come to silicon valley 2 years ago. I do what I love. That was not something I could say a few years ago. Agh, this is more squirm-inducing. Here's a program that came out of conversations when I spoke to PG at…

Here are plenty of small apps developed with LÖVE: https://git.sr.ht/~akkartik, see also https://akkartik.name/

From A Deepness in the Sky by Vernor Vinge (and https://akkartik.name/post/deepness) Pham Nuwen spent years learning to program/explore. Programming went back to the beginning of time. It was a little like the midden out back of his father’s castle. Where the creek had worn that away, ten meters down, there were the crumpled hulks of machines—flying machines, the peasants said—from the great days of Canberra’s original colonial era. But the castle midden was clean and fresh compared to what lay within the Reprise’s local net. There were programs here that had been written five thousand years ago, before Humankind ever left Earth. The wonder of it—the horror of it, Sura said—was that unlike the useless wrecks of Canberra’s past, these programs still worked! Programmer Archeologists was his idea.

Kartik Agaram [1], The paper about his Mu project [2] presents a rationale for a particular kind of minimalism, and its realization. 1. https://akkartik.name 2. https://akkartik.name/akkartik-convivial-20200315.pdf

Oh, hey Kartik! (Just merged your PR into wigwam.directory haha thanks!) For those who don't know, Kartik's "freewheeling" apps are incredible. Very much fits in the spirit of Uxn and other small ecosystem projects. I recommend watching his short lecture and following along with the slides: [1] https://archive.org/details/freewheeling [2] http://akkartik.name/freewheeling/ He totally sold me on the viability of Lua, LOVE, and small apps for making better software. He also has a lovely VM called mu that's worth checking out: [3] https://github.com/akkartik/mu

Highly recommend the short story, ”Wang’s Carpets” by Egan titled in honor of mathematician Hao Wang. See http://akkartik.name/post/wangs-carpets

The Universe of Discourse by Mark Dominus: https://blog.plover.com Kartik Agaram: http://akkartik.name compudanzas: https://compudanzas.net/ Pete Elmore: http://debu.gs Joey Hess: http://joeyh.name

Off-topic: @hacker_9 just saw one of your recent comments (https://news.ycombinator.com/item?id=13267106) and you seem to be thinking along similar lines to me and akkartik (https://news.ycombinator.com/user?id=akkartik). You can read more about our work here (http://akkartik.name/about). Would love to hear any thoughts you have!

Try the README: https://github.com/akkartik/mu/blob/master/Readme.md It's a new programming language. edit: The source seems to be structured intentionally in a recommended reading order. See the comment at the top of https://github.com/akkartik/mu/blob/master/000organization.cc Layers of code are filled in as you read down the list of files. It's an interesting concept, similar to literate programming. (And FWIW, these source files are C++ code for the compiler, not an example of Mu code.) The author also has a blog post up here: http://akkartik.name/post/mu

I've really enjoyed your writing on your blog at http://akkartik.name which I found through your guests posts at Ribbonfarm. Have you been writing anywhere else about your work or thoughts about readable programs?

One of the things I find myself needing to push both junior _and_ senior developers to do is "if you are thinking about code being anywhere adjacent to 'subtle' or 'weird,' or think that something might become a design pattern for future code, or something that was copied from other code but differs subtly, or you consulted StackOverflow... write the comment that's in your head/leave a breadcrumb as an actual comment in the codebase." And, frankly, this sometimes means commenting-out rather than deleting code, if the historical code was necessary to understand the context for why the improvement is warranted. I wholeheartedly agree with the OP that "churn" can result not only from staff members leaving, but also from them shifting focus to other projects or even just growing in skillsets over time. Which is why it's vital to document the mindset you had as you were coding. One of my favorite books, Vernor Vinge's Hugo-winning _A Deepness in the Sky_, uses the term "programmer-archaeologist" - https://akkartik.name/post/deepness is a great (spoiler-free) quote on the notion. Writing for your future archaeologists - who may very well happen to be your future self! - is a great mental model to have. (And read Deepness - despite its branding as book 2 in a series, it's arguably best to read it standalone first! It's simultaneously an action-packed popcorn novel and a mind-bending set of discussions on linguistics and cultural relativism as they pertain to mechanisms for…

Thanks for the thoughtful response, but I don't think I can say I agree with your conclusion. One example I cited was Knuth's Adventure. Even knowing C well enough, I'm not struck by how Knuth's presentation makes it easier to understand in the way he desires. Knuth very much seems to advocate for programs that can be read cover-to-cover (e.g. while, say, sitting in your favorite chair). I think the failure in his literate programs come down to the blindspots he's developed working on his own programs, from having focused so much on the trees in their respective forests. You can see something similar at play in Graham Nelson's struggles to make Inform 7 appropriately "literate", which funnily enough exhibits the opposite of expectations of familiarity with the original implementation language. <http://inform7.com/talks/2020/06/07/narrascope-ii.html> Have a look at this slide in particular: <http://inform7.com/assets/images/NS2/slide036.jpg> Here's an excerpt: "Once The Historian is done, the instructions are passed to Instruction::read, which parses them more fully (see below) and returns an intest_instructions object". It goes on in that style. This is reminiscent of every bad attempt I saw during Java's heyday to ensure that a given codebase was 100% commented. People just end up writing "documentation" that consists of low-level repetition of what the code is doing, but without explaining why it's doing those things, and that why is key. It's the only real…

Thinking about the state of the software world in the last several years always makes me think of Vernor Vinge's notion of a "Mature Programming Environment" from _A Deepness in the Sky_ (1999), "The word for all this is ‘mature programming environment.’ Basically, when hardware performance has been pushed to its final limit, and programmers have had several centuries to code, you reach a point where there is far more significant code than can be rationalized. The best you can do is understand the overall layering, and know how to search for the oddball tool that may come in handy" (Longer excerpt with an earlier bit about rewriting things always eventually just moving around the set of bugs, inconsistencies, and limitations rather than improving them here: http://akkartik.name/post/deepness ) And and Danny Hillis' idea about the Entanglement ( excerpt from a 2012 interview with SciAm) - "But what's happened though, and I don't think most people realize this has happened yet, is that our technology has actually now gotten so complicated that we actually no longer do understand it in that same way. So the way that we understand our technology, the most complicated pieces of technology like the Internet for example, are almost like we understand nature; which is that we understand pieces of them, we understand some basic principles according to which they operate, in which they operate. We don't really understand in detail their emerging behaviors. And so it's perfectly…

Here are a bunch of blogs from my RSS reader that I think are worth reading. Some of them haven't updated in a while, but the archives may be worth a look anyway. * Blogs with a math focus: http://blog.sigfpe.com http://bit-player.org http://mathr.co.uk/blog/ https://www.johndcook.com/blog/ * Blogs with a programming languages focus: https://existentialtype.wordpress.com https://bluishcoder.co.nz http://blog.ezyang.com http://akkartik.name http://lambda-the-ultimate.org http://mrale.ph * Blogs with a UI design focus: http://www.brandonwalkin.com/blog/ http://ignorethecode.net/blog/ http://interuserface.net * Blogs with a graphics / 3D rendering focus: http://c0de517e.blogspot.com http://diaryofagraphicsprogrammer.blogspot.com https://directtovideo.wordpress.com http://graphicrants.blogspot.com http://www.reedbeta.com http://www.realtimerendering.com/blog/ https://blog.demofox.org http://eelpi.gotdns.org/blog.wiki.html * Other interesting / more general programming blogs (many of these have a "systems" focus): http://danluu.com http://ewontfix.com http://chneukirchen.org/blog/ http://neverworkintheory.org http://apenwarr.ca/log/ https://www.snellman.net/blog/ https://www.pvk.ca http://psy-lob-saw.blogspot.com https://randomascii.wordpress.com http://fastcompression.blogspot.com https://fgiesen.wordpress.com http://blog.plover.com http://chneukirchen.org/trivium/ http://rachelbythebay.com/w/

Once there were three tribes. The Optimists, whose patron saints were Drake and Sagan, believed in a universe crawling with gentle intelligence. Surely, said the Optimists, space travel implies enlightenment, for it requires the control of great destructive energies. Any race that can't rise above its own brutal instincts will wipe itself out long before it learns to bridge the interstellar gulf. Across from the Optimists sat the Pessimists, who genuflected before graven images of St. Fermi and a host of lesser lightweights. The Pessimists envisioned a lonely universe full of dead rocks and prokaryotic slime. The odds are just too low, they insisted. Too many rogues, too much radiation, too much eccentricity in too many orbits. If the galaxy were alive with intelligence, wouldn't it be here by now? Equidistant from the two tribes sat the Historians. They didn't have many thoughts on the probable prevalence of intelligent, spacefaring extraterrestrials. But if there are any, they said, they're not just going to be smart. They're going to be mean. The reason wasn't merely Human history, the ongoing succession of greater technologies griding lesser ones beneath their boots. No, the real issue was what tools are for. To the Historians, tools existed for only one reason: to force the universe into unnatural shapes. They treated nature as an enemy, they were by definition a rebellion against the way things were. Technology is a stunted thing in benign environments, it never…

Does anybody know a widely used and open source project using literate programming? (Edit: please include only programs expressed "as a web of ideas" that Knuth mentions - apparently otherwise it's not literate programming, just loads of inline documentation?) From what I've seen, literate programming is great in theory and worse than useless in practice. It's so far away from reality. I have had the misfortune of working on a FunnelWeb codebase, and it was one of the most incomprehensible codebases I've ever seen. Preprocessing the code is an awful step in any language. Somehow, the "not documentation" still goes out of date. There are several other problems, explained at [0] better than I can in a comment. Specifically about this project: While I enjoy writing blogs in markdown because of its constraints, reStructuredText (reST) is more powerful/expressive (by design). Because you can easily express semantics/relationships, the resulting links in the generated documentation make the "web" of source code easier to navigate - something Knuth was trying to do with literate programming. [0] http://akkartik.name/post/literate-programming

Re a) and b), I replied below your comment about your Vim plugin. > That is very close to my heart, though my theory is that reading code only becomes easier when the very representation of software projects undergoes a sea change: http://akkartik.name/about. I'd love to hear your thoughts! I read the page you linked (though I didn't browse the other parts it links to - I'll have to leave that for later). Quite a lot of interesting ideas you have there. I've added the Mu project to check out later. It seems we have similar general goals in mind, but different ideas of making it happen. You seem to be focusing on how to change the programming practice to facilitate understanding of large codebases. I am thinking more along the lines of tools that would help one explore and get the picture of existing codebases in current languages. So far, I've briefly explored areas like: - software for generating diagrams of the code - software for generating runtime diagrams - time travelling debuggers - printing out code on paper (per edw519's advice) and annotating it - annotating code in PDF readers and word processors I think what resonates with me most in the text you linked is "Deemphasize abstractions in favor of traces". I actually went into the first three bullet points of mine because I had to refactor some code that I couldn't figure out the exact flow of. What I wanted was exactly the "trace" of execution I could inspect. Unfortunately, the time travelling debuggers I…

Fair, but I didn't get to it until ~2010. And yeah, Vinge uses the exact phrasing https://akkartik.name/post/deepness

Eating Cap'n Crunch (From Cryptonomicon by Neal Stephenson): https://akkartik.name/post/capn-crunch

Technology implies beligerence http://akkartik.name/post/2012-11-21-07-09-03-soc The problem i see, that someone might send our "primitive" AI into a hostile environment, were it has to compete against other AI, creating a "take-over" and a "devensive" monster, similar to the go automaton. While the real world training data might be dripping, the speed in which a NN under evolutionary pressure against itself might evolve could go through the roof.

I assume the author may be referring to the projects at http://akkartik.name/code, notably Mu - though not 100% sure, doesn't seem to really extend to the "computer" part at a glance.

Software archaeology in a mature programming environment http://akkartik.name/post/deepness (An excerpt from A Deepness in the Sky by Vernor Vinge)

In http://akkartik.name/post/mu-2019-1 if you search for the pattern '/89' you'll find the first two versions. The 3rd one is here: https://github.com/akkartik/mu/blob/master/apps/factorial.subx#L23 Can you explain in a sentence what rules are used to complete the encoding for the variant: > 89/<- %ebp 4/r32/esp

http://akkartik.name/about provides more info about the submission. About half way down, "... I've been exploring some promising mechanisms in my current project, an idealized assembly language and OS for teaching programming called Mu"

Software archeology in a mature programming environment http://akkartik.name/post/deepness

I'm not the person you're replying to, but I think you mean http://akkartik.name/about (and not http://akkartik.name/post/about). And though you didn't ask me, I read it (having been annoyed by your LP post for a few years now) and it strongly resonates with me — the mission, and everything until the start of the “Constraints on a solution” section. IMO the way to give more people more understanding of programs is not to write an entire new programming language / operating system and hope that enough people switch to it, but to work on delivering that “understanding” for existing programs in existing languages. It may be harder, but is more likely to be useful, and you also get feedback on what kind of understanding people want and lack.

Hey, can I ask you what prompted you to just go reading nginx code? As pointed out recently, most people - even people who advocate reading source code for its own sake - don't actually read code unless they have to. (http://akkartik.name/post/comprehension) So it's interesting to see a counterexample. What led you to go spelunking in nginx?

The surprised are referred to Mr. Vonnegut's description of the "money river": http://akkartik.name/post/money-river

1. Search for "aspect-oriented programming". 2. http://akkartik.name/post/wart-layers

I recently ran across this piece, "Literate programming: Knuth is doing it wrong", whose author contends that > the ends are insufficiently ambitious by focusing on a passive representation [0] After practicing literate programming seriously for over a year on a large project, I believe that our notion of documents themselves is insufficiently ambitious, for the same reason. Computer-based media should not be limited to the static forms imposed by paper. It's unfair to critique literate programming per se until we have a truly dynamic mode of representation. (edit, yes, technically we have that now, but it's an order of magnitude more work to create. I'm saying that live, dynamic representations should be our tool for thinking, building, and writing about things in the first place, not after the fact.) [0] http://akkartik.name/post/literate-programming