I have a lot of respect for the FSF. I think GPL v2 is probably the best license out there. I certainly don't think Android is an unalloyed good the way does. And yet, this makes me incredibly sad:

The whole goal of GNU was to combat proprietary software. Deliberately over-engineering software just to distinguish itself from another that also has a permissive license (BSD), how is this making the world better?

· · Web · 4 · 1 · 1

Thanks to Kragen Sitaker ( for educating me that the goal isn't to distinguish itself from BSD but from proprietary Unixes. The more complex an implementation, the less likely it is to be found infringing AT&T or other distributions who just happened to encode some code fragment first. Proving that a fragment of code is too simple to copyright is too uphill a battle to systemically rely upon.

@akkartik This is precisely why llvm was created, because gcc is deliberately written as a monolith so it can't be co-opted by nonfree interests. People tried for many years to modularize it to simplify the architecture so it could be used in a wider variety of situations; rms said no.

@akkartik I had no idea that this was the case with legacy software, is this why.. *cough* is this why Rust?!

@akkartik re "I often find it challenging even to figure out where to ask. Going from a program to its package, dealing with interactions between packages, etc. All of which goes back to simplicity as a core goal."

Programs should strive to have a beginning and end—or at least a well-understood beginning—and for the author to care as much about human reader as the machine.

@akkartik I've come to realize that, as intrinsic as it is in everything exactly like Nelson says it is, uncontrolled hypertextuality is the enemy.

Consider the plot of a book or a movie. Plenty exist that use non-linear storytelling or jump into and out of scenes happening in parallel. Yet we still manage to package them up into consumables.

The act of "linearizing" is an art, but it's doable. It should not be overlooked.

@akkartik the biggest problem, as I see it, is that by the time we get to the point where we're competent to both write programs and notice that we should be striving for this thing, our minds are poisoned by the influence "industrial" software development. Your analysis about Knuth's LP mistakes are extremely salient.

How do we keep from backsliding into, "Some #includes for our program -- don't mind these"?

@akkartik there's a restatement of the problem in the Glen Chiacchieri episode of the Future of Coding podcast. Choice quote (around 1:45:50):

"Code is open source, but who cares? Nobody can understand it."

@colby Funny you (Adam, really) brought up Smalltalk. I've been poking around recently with Glamorous Toolkit, trying to figure out if I should focus there instead of my Because my goal is exactly what's stated in that blog post draft: always ship sources with any software, and make it easy to rebuild sources with a single click. Even if nobody can immediately understand it, push-button releases will massively improve things and lay the foundations for more.

@akkartik this is _exactly_ what I'm trying to achieve with

> Under the current regime, without triple scripts, it is essentially a given that every programmer will spend some time struggling with their toolchains, pouring untold effort into the steps that are usually described as "setting up a development environment".

From <>

@colby Sorry for the delay but I _have_ been thinking about your project.

I like the SDIPD principle. But why does compilation need to be reversible? What can you not achieve just by bundling sources with the app and providing an editing environment?

@akkartik if I understand what you mean, wouldn't that be reversible? If an executable package P includes as part of its payload bundled source code, then a process R(P) that produces the source code can be defined, and the file format family that P belongs to would be said to enable reversible compilation.

@colby Ah cool, if that's all you need why didn't you just say so?! 😂 "Reversible" sounds a lot more exotic. But if it's just a packaging problem we could do this to C! Python! Just about anything. It's just a matter of how large the binary becomes.

I've started thinking about performing this transform on Mu, which seems particularly well-suited. The toolchain is only 300KB, and it's very hard for edits in one function to corrupt another. Most languages have at most one of those two properties.

@akkartik maybe you prefer the terminology of "non-destructive compilation" better? I have generally focused on it more than "reversible".

You could do it in C, stuffing the sources into e.g. an ELF section. The problems you will run into are more social than technological; you'd have to insist that people abandon their urge to strip them. Baking Loper's IV law into the system design from the beginning is probably the only way, realistically, to achieve this.


@akkartik re C:

AIUI, Justine Tunney does something similar for APE <>. She reports this makes binaries grow 10x.

One strategy for ensuring that SDIPD isn't compromised might be to change the kernel/loader so that there is no chmod-style x bit. Instead, the two work in concert to check for the presence of a source payload and reject anything that doesn't have one, refusing to run that program. There are still downsides to this (e.g. integrity/synchronization).

@colby Ah, I see. I'm not really thinking in terms of graceful degradation yet. Like what happens if people run `strip` on a binary or whatever. I think this idea is still in the "convince people it's cool" phase, not the operationalization and "provide guarantees" phase.

I do have some concerns about doing it with either C or Python. C's unsafe writes will now go to the code segment and be hard to debug. Python includes a lot, that makes it harder to provide a good experience for everything.

@colby So my attitude right now is:

a) Keep it memory safe (unlike C).

b) Keep the available libraries minimal, so we have a better sense of all the different things someone might want to put into an application. If we start with a web app, maybe don't include direct screen graphics, etc. Libraries should be relevant to the app.

Putting these constraints together, I'm thinking of some experiments with minimalist interpreted languages. Maybe Lua, femtolisp, etc.

@akkartik re Smalltalk: also not coincidental. Availability of sources is crucial; compilation must be a reversible process.

> SDIPD stands for "package distribution is source distribution [sic]".

From <>

A lot of the attention that has gone into this work so far—and will go into it in the future—is greatly informed by Smalltalk. Specifically, Objective Smalltalk (see <>), and a lot of what Bracha talks about when he describes Newspeak.

(Oops. s/Objective Smalltalk/Modular Smalltalk/)

@akkartik from Future of Coding #3:

> as I was just telling you, I spent the last, like... I spent 5 hours over the last two days[...] trying to install software to get something to run. And it's just ridiculous to have to spend hours and hours. If you want to get Xcode to run, it takes— first of all you need a Mac, which is crazy, and then second of all it takes, depending on your internet connection, it could take you a whole day just to get up and running. Why isn't it ``?

@colby On the flip side, I can't even with JavaScript.

I'm still thinking about this thread. I wrote a long post on the FoC Slack about it. Right now I'm leaning towards hacking on the Lua interpreter to build in an editing environment.

@colby I spent the last 3 or so years trying to escape C, and it's just too hard. But having given up on that, I don't want to rebound too far in the other direction. Parsimony still has value even if I don't care about it quite as much. Lua feels the most parsimonious of the options. Best performance and features for lowest outlay of C code, no other libraries, and no other notations. The target stack is now C -> Lua+Linux -> some expression of triplescripts/end user programming principles.

Sign in to participate in the conversation

Revel in the marvels of the universe. We are a collective of forward-thinking individuals who strive to better ourselves and our surroundings through constant creation. We express ourselves through music, art, games, and writing. We also put great value in play. A warm welcome to any like-minded people who feel these ideals resonate with them.