JetBrains IDEs tend to have very good static analysis and refactoring, not sure to what extent the model is exposed to query freely. OpenGrok also has some semantic features. Other than that I think you covered most of it in your article.

the two products that come to mind are https://codeql.github.com/docs/writing-codeql-queries/introduction-to-ql/ and https://www.ndepend.com/docs/cqlinq-features#Object

It's a built-in feature of Smalltalk systems. And Tudor Girba's Glamorous Toolkit is extending this approch to other languages.

Our own platform is built on top of a reactive database model, and the builder assets are stored in the db, as is the executable (VM for now, soon to be wasm). This allows the interesting ability to build tools as apps in our builder, and also to have plugins that are themselves apps built using the builder. Furthermore the database is a git meets mongodb style multi versioned log structured thing so you can also access previous states of all entities.

I think many programmers have the (correct) intuition that some kind of circular bootstrapping will unlock or manifest some deep or profound power, but unfortunately can't substantiate why this is. So metacircularity is either dismissed as pointless, or recognized as automatically profound and powerful, regardless whether it's leveraged in any meaningfully powerful way.

The powerful idea behind metacircularity (which often sensed but rarely realized) is that we can potentially leverage all the power of programming, to leverage all the power of programming. Software can be is its own lever.

But this is not what you see in most "metacircular" software. It's usually more like using a robot-arm to control another identical robot-arm, versus using the arm on itself (e.g. to give itself new or improved capabilities). Less like a living cell, which contains (and thus "is") all its own apparatus for defining / executing / replicating itself; and more like a virus, which does not.

(That's the link I see between "living structure", "unfolding wholeness", and what I called "actual circular" metacircularity).

An example of what I think this would look like, is software that is actually written (and subsequently interpreted or created from) within itself.

That's way out of my expertise to argue with 🙂 Both the bio and CA angles. Though I'd weakly claim that CA's notion of living order includes the environment, particularly people. It feels tenuous to connect it to metacircularity.

Is any software metacircular by your definition? Smalltalk?

I'd say things like SmallTalk, Forth, Lisp, Glamorous Toolkit, come the closest. The gaps are in whether it's actually used that way (e.g. treating arches like bricks and building a pyramid out of them); or that it's still forced through artificial layers (like "language") that are taken as a given, but which are actually just one of a million possible "interfaces", any of which could be self-contained.

MPS has the right idea, except that it provides a plethora or set-in-stone concepts, interfaces, layers, and languages for everything -- which I find highly ironic, given what is supposed to be.

Racket gets an honorable mention for being the best "make your own language, in your own language" language; but it's very linear, and forced through the very specific paradigm of specifying, creating, etc etc, all through parsing textual language. Zero progress at escaping that, but it does it WELL.

Actually, Rebol / Red may do it better in some (but not all) respects. It's parsing util(s) treats not only the thing being parsed as a datastructure, but also the code doing the parsing! I think it's just called "parse", and there's a write-up about this that's google-able.

The principles of the moldable objects initiative (or whatever it's called) that J. Ryan Stinnett is part of, are actually pretty in line with this stuff. I don't think it's prescriptive of what I'm talking about here, alright I think the goals overlap.

I do think that "living structure" (Purpose) is the thing one is after (consciously or not), in seeking metacircularity (Mechanism); and vice versa, that metacircularity (as I've described it) is necessarily how "living structure" (e.g. organism, business, or software extension of human capability) is achieved or constituted.

Mechanism:

The living thing necessarily contains it's own code (or other self-representation -- DNA is code), interpreter(s), replication, ability to replace it's bits while preserving structure & identity, and all this is self-contained, ergo the living thing "is" / "does" these things / "has" these capabilities.

Purpose:

Capable of adapting, changing, preserving, etc, in a way that dynamically keeps it fit for it's purpose or environment, evolving / learning all the while. Conversely, a thing that must be painstakingly redesigned and/or thrown out once it is no longer fit (if it was even a good fit at all) for some very specific (perhaps very static) purpose it was rigorously designed for, is in essence "dead" at creation.

Environment does control a metacircular software thing, because that's the whole point. A car "that can do anything" really means that YOU can MAKE IT do anything (for whatever "do anything" means). That is how it can be perfectly fit and adaptable, because it provides a means to adapt "itself", including (by definition of being "fully" metacircular) those means it provides to do so.

The absurd thing about this is how much I prefer looking at the pictures rather than the code. It's like Bartosz has the "before" and "after" reversed.

I assume Factorio assemblers consume the objects you feed them?

Which functional languages do this?

I am obliged to point out that this bit..

In Factorio, the nesting of functors is drastically limited. It’s possible to produce belts, and you can put them on belts, so you can have a beltful of belts, > Belt Belt> . Similarly you can store chests inside chests. But you can’t have belts of > loaded>  belts. You can’t pick a belt filled with copper plates and put it on another belt. In other words, you cannot transport beltfuls of stuff.

... is something you can do in Hest. And it's bonkers. And it's weird. And I don't like it. It hurts to think about.

And thanks to this article, I now know why.

Realistically, that wouldn’t make much sense in real world, but in Functorio, this is exactly what we need to implement monads.

Ah. Monads. Didn't see you come in. There's beer in the fridge. I'm going out. I'll be back.. later.

@Shalabh Bartosz talks about that in the section on Linear Types.

So you're saying Hest has monads? 🤯

Such a cool idea. I knew where he was going after the first paragraph. And yet I never thought of it.

@Shalabh — It has something. You can put conveyors (loaded with stuff) on conveyors. But it's weird to think about, and I don't like it, and I'm kinda just ignoring that it is even possible for now. It's emergent from Hest's elements in the way that, say, (absent ASLR, etc) using pointers to that point at your own code is emergent. You can do it but.. don't.

Conveyors conveying conveyors even looks weird. They tend to wander around unpredictably. So maybe a good term for them would be "nomads".

Two examples:

https://twitter.com/spiralganglion/status/1145188460203872256. This is just cute for the sake of cute. It doesn't accomplish anything meaningful in terms of code.

https://twitter.com/spiralganglion/status/1153777314443849728.

I've seen the invisible-middle demo before, and kinda nodded along. But the bezier curve, whaa, what the heck is even that? Is it a single curve? Extremely mind-bending.

The bezier curve thing is just... me dialling-in what I want Hest to look like. It's not actually doing any computation*. It's literally just using the 3 essential language primitives (points, edges, and conveyance) to do the geometric construction of a bezier curve. It's playing off the fact that the programming tools are art tools.

(* thank goodness, because I don't want to even start to think about what it means to do multiple nested layers of conveyors. Gross gross yuck no get it out of my body)

I knew where he was going after the first paragraph. And yet I never thought of it.

Kartik Agaram — Have you played Factorio? Or any of the other process-oriented programming games? (SpaceChem being my favourite, though it's very imperative.)

No, not yet. It's been on my mind to do that. Especially if I do end up taking some time off from Mu.

It's been a while, but I seem to remember "points carrying points" being close to the essence of Bezier curves even if you're not doing visual programming. So, if that's a natural way to implement them in Hest, neato.

The thought of making a programming language feel like a video game is (very) exciting, but I've concluded in the past that a lot of the fun in video games is making incremental, measurable progress towards goals. Video games usually set this up by creating webs of artificial hurdles, and you obviously don't want to be doing that in a PL. For example, in Factorio you periodically run into bottlenecks in your factory, for example a belt reaches its capacity, or you start running low on a resource. It's fun to resolve these artificial constraints, and that's what most of Factorio is about. There's no analogue of these things for writing code 😕 (except perhaps performance optimization, which is rarely "fun").

Disagree, I think? The hurdles don't have to be artificial to be fun. There are lots of times in programming when you can make incremental, measurable progress. If you've got your abstractions and data model set up right, you can crunch your way through e.g. UI or web request handling (recent examples for me). At its best, writing video game code itself feels the same. TDD is (in my understanding) in large part a way to make that feedback loop more repeatable.

I've definitely had fun programming before, don't get me wrong 😛. But much of my time spent in the IDE is struggling to figure out what low-level thing needs to be done next, and the correct steps to accomplish it (and then of course, figuring out that you've done something wrong, and trying to figure out why it's wrong). That deep, low-level problem-solving is definitely not as fun as running around building conveyer belts. It tends to be much more mentally exhausting.

Isn't it folklore that programming can never be "fun" all the time, because by definition, if you can keep your mental taxation low, then it's because you're doing rote work, and rote work can (and should) be automated/abstracted?

a lot of the > fun>  in video games is making incremental, measurable progress towards goals. [lots of good thoughts excised for brevity] There's no analogue of these things for writing code

I don't believe that that's true. I can't prove it, but it doesn't feel right. But I would totally agree with There's no known analogue of these things for writing code.

I have it as one of my ambient background shower-thought processing tasks to figure out how to design game dynamics (to borrow the sorta dated "mechanics / dynamics / aesthetics" framework) that encode programming-related tasks, such that you can enjoy playing with these dynamics in a game-y system while still accomplishing actual creative / expressive work (loathe to say productive work, but sub that in if that thought doesn't irritate you the way it does me).

It's easy to imagine a ton of kinda-bad "gamification"-y visions. The most well-known bad example is probably Github's contribution tracking. It incentivizes opening and closing a lot of low-value issues, and making a lot of tiny low-value commits. But Github also fosters the social motivation to write good docs, which is very good (and very conventional) dynamics design.

I think once we're playing in the "Factorio is my IDE" space, there's plenty of unexplored possibility and very little should be taken as a given.

If you can prove me wrong, you'll be a legend Ivan 😍. I'm ready to implement (steal 😏) promising ideas at a moment's notice. But yeah, the key point is not to add artificial elements to the act of programming, such that you're able to "score points" and get dopamine hits whilst doing very little actual work. I definitely see gamification working for chores like code review, which can be quite rote.

Yes, the key is to make sure the goals or "points" are real. This probably means they need to be self-defined, seeing how measuring software productivity is an open problem and will likely remain that way forever.

I just remembered: possibly the most video-game-like experience I've had while "programming" was my brief experience trying to prove things in Coq. Real goals (of a sort, these were practice problems), with a little dopamine hit when I proved each one, including subgoals. Sometimes I had to think creatively, sometimes I could just grind through. Similar to the TDD example, I guess, treating a spec as the goal. If it's not exactly a research direction in itself, I think this is at least a potential payoff of improving the ergonomics of formal methods.

Isn't it folklore that programming can never be "fun" all the time, because by definition, if you can keep your mental taxation low, then it's because you're doing rote work, and rote work can (and > should> ) be automated/abstracted?I don't think fun comes from low mental taxation, but rather operating at the edge of one's capabilities. (See: Flow, &c). Tooling drives me crazy primarily when it breaks my flow states and makes me deal with nonsense rather than focusing my attention on the problem I'm trying to solve.

gary’s mod is a great example of a game that doesn’t seem to have artificial hurdles except those imposed by the players

man i saw an extremely good youtube video on a geometric definition of bezier curves for laypeople and now i can’t find it

Just watched the recording of "The mouse holds us". Really liked the last monologue 🙂 cool stuff.

I just find this sentiment to be so tunnel visioned and almost Luddite. I get to the point where it's just disappointing.

Also, by their pictures, they have an ironically broad definition of text.

It's a long-standing debate. I think it's natural that people lie all along the spectrum.

Why do you find the definition of text broad, though? Everything in the pictures is in Unicode? That seems a useful definition of 'text'.

I don't think it's super clear what his argument is. I think it's very true that text is the safe bet, given its flexibility and how hard it is to get that same expressiveness in other media. It would be a mistake to say that means text is the only way forever and any alternative is doomed, and I suspect that's why Graydon danced around actually saying that.

With that said, using math notation as an example in the context of computer systems is a bit iffy. I mean, he's mostly talking about encoding and transmission, but it's hard to separate "text is awesome" from the existing widespread tooling, and that latter part is not totally there for math (it exists, but in small patches relative to the larger ecosystem). Again, not exactly what he said, so I might just totally be projecting my bias here.

I would definitely say that if you're going to go beyond text, natively supporting math notation would be a good direction to go. Casually using a bar for division in a large formula would be great.

This is such a narrow minded statement - has he not heard of Tufte, Feynman diagrams, Ken Iverson, or even electrical circuits?

APL is notably dead, replaced by text-based descendants, so I think that example bears out his point. Feynman diagrams are helpful, but IIUC more combinatorial schematics than complete descriptions, for which you need... well, math, which is still closer to text than pictures. Electrical circuits and Tufte (if you mean https://www.edwardtufte.com/tufte/) are solving entirely different problems than Graydon is (granted, implicitly) considering, so I don't think those are germane examples. Graydon may be cynical here, but I don't think he's narrow-minded.

Ed: he might even consider APL text to some extent. Between the abstraction level and semi-related pictures, it's hard to say precisely what his point is and isn't.

Having read this a few times before and again now, I'm now having problems grasping the basic proposition. I agree that text is useful and powerful, but how does that imply that other visual media or, say, interactive essays ("dynamic multimedia system") are not? Is there even a dichotomy here?

Take a random video on youtube, how interesting, rich or useful is the text version of that?

(And btw, who's reading those old stone tablets now that we have youtube?)

This piece pops up every now and again. I always try to resist commenting on it, but this time I'll indulge. Leaving aside that his own examples include a writing system that's basically strings of emojis, one cannot help but notice that the "text is everything" argument is almost always made by those who have an extremely jejune notion of text. This is one of the reasons I'm forever recommending these two papers to people interested in these questions:

https://hal.inria.fr/hal-00737414

https://dl.acm.org/doi/10.1145/2661136.2661138

if text is so great, why do we need hyperlinks?

It's really cool.

Now this scratch model exisits as financial language in Cardano.

https://www.youtube.com/watch?v=GqKxLiaY4-s

The last phrase made me think of https://en.wikipedia.org/wiki/Conway%27s_law, which establishes a connection between (in this case) code structure and the social structure behind its development and maintenance. Which makes me wonder if insisting on some to-be-specified beauty criterion for software could actually fix bad social structures, at least on a small scale.

I definitely agree with the connection to Conway's law. I think this shows how software acts as a "multiplier" for existing social structure. This brings up this taxonomic idea of "additive" vs. "multiplicative" technology... What makes a technology one or the other?

V got a lot of https://github.com/vlang/v/issues/35 when it first announced because it overpromised, under-delivered, and had a very caustic founder that fought with everyone... But it's apparently smoothed out since then. Don't how good it is now.

Now I'll plug my favorite: https://nim-lang.org. Similar niche, systems level language, but with lisp style macros. (And looks more like Python or Pascal.)

There is also https://ziglang.org, http://odin-lang.org/#:~:text=The%20Odin%20Programming%20Language.%20The%20Odin%20programming%20language,for%20modern%20systems;%20joy%20of%20programming;%20Example%20Code, and https://dlang.org in the alternative systems language space.

https://scopes.readthedocs.io/en/latest/ "...was started as an alternative to C++ for programming computer games and related tools" ... "is written in about 30k lines of C++ code, supports a LLVM as well as a SPIR-V backend (targeting both CPU and GPU with a single codebase), and exports a minimal runtime environment" ... "The language is expression-based, but primarily imperative. The syntactical style marries concepts from Scheme and Python".

So yeah, perhaps check it out 🙂 I haven't play with it yet but I keep an eye over it.

I always forget about Scopes! That is a really neat language too! 😄

it sounds very interesting, but also a lil esoteric and mostly a one man project which makes it a bit risky. In that regard, Nim is a lot more established already. Me personally, I'm leaning toward Kotlin... In fact, if one considers Kotlin/Native, perhaps it could be put in this list. I'm sure there must be a way to escape the garbage collector.

Zig is very interesting, especially the comptime construct that gives a lot of stuff like generics for free. https://scattered-thoughts.net/writing/assorted-thoughts-on-zig-and-rust/

I'd be curious to know how many programmers don't ever hold down on undo to roll back a few hundred changes, do something, and then redo back up to the present. I find myself doing that at least once every few months, and I've heard other folks anecdotally talk about doing the same.

Yeah, bulk undo & redo happens every once in a while. Though mostly I try to keep commits and small and use VCS diffs, but when that fails, I'm back to hoping I haven't messed up my redo stack somehow.

I don't think I've ever done that, and had no idea it could be widespread. Version control actually does (mostly) solve this problem for me, because I don't feel shy about committing every few minutes if that's what it takes. I do however look at my current git diff a lot, and diffs of other recent changes pretty often.

It's true that it's still a pain to copy-paste out of history or otherwise partially restore it. The UI this author proposes sounds neat, but only if it transparently works with (at least) git.

As an anecdote, I spent some time yesterday yet again trying to make sense of http://paulgraham.com/bel.html. The sources are lots of tiny functions. But there's tons of calls between functions, and I'm constantly yoyoing between them. One of the things I want to enable in my project is allowing functions to be moved around independent of each other, so that I can move related functions around for the duration of a session. Kinda like Tiddlywiki (cross-link https://futureofcoding.slack.com/archives/C5T9GPWFL/p1613629318245700) I also recall that the original Light Table demo did this really well.

I think such a feature would help here?

i’m working on this problem in the context of web browsing. i genuinely think scrolling is a ux antipattern (at least most of the time) and the times i end up needing to undo, whether on git or via keyboard, almost always boil down to switching assumptions about the code i wrote that has just moved out of view. Kartik Agaram you might be interested in the https://www.google.com/search?client=firefox-b-m&q=berry+picking+search+strategy&spell=1&sa=X&ved=2ahUKEwjI-tn6uvfuAhVnQt8KHd_6CGYQBSgAegQIARAC&biw=375&bih=631&dpr=3 literature

This particular undo/redo behavior is foreign to me. I like the slider + diff interface, though. 🙂

New programming language work from Baez and Stay? How am I supposed to get work-work done with this kind of treat ripe for the picking...

I'm on the mailing list as well.