gaps between lines is off here.

Since a lot of this is guaranteed to be seen as arcane magic, maybe this is an opportune place for the UI hooks for a conversational/palette-based UI? Maybe >> to set it off?

This is a good place to prompt people to use Write.as itself as a way for voicing other kinds of feedback.

Or selling reader subscriptions, too, right?

Interesting (generous) definition of non-commercial.

"Write.as Pricing"

These aren't declared as phony targets in the Makefile.

How about a writefreely probe command that performs basic checks for this stuff?

"one"?

bad hygiene; unnecessary

This step prompts me for superuser privileges (it shouldn't; probably installing lessc as a global utility (it shouldn't)) and then still fails.

Should be https://github.com/writefreely/writefreely.

"allow"? "enable"?

Link to docs on this.

"the write.as guide"?

Inconsistency here between "Dates are shown" and "No dates shown" (and "Latest posts listed first", for that matter).

Change the "mood" (?) here for unselected options so that it's quasi-subjunctive(?) so we'd say e.g. "Only you will be able to read this blog [...]". (Should probably also eliminate ambiguity about "while you're logged in qualifier".)

I'm using this tag fo keep notes about the changes that need to be made now that Writefreely exists in its own organization on GitHub. See https://discuss.write.as/t/moving-the-writefreely-repo-on-github/2568

This is the URL for the podcast episode A conversation with Allen Wirfs-Brock about the history of Smalltalk and the future of dynamic langu[ages].

@29:39

In the Smalltalk community, I always had the reputation as the guy who was trying to make Smalltalk more static so it was more applicable for industrial applications. In the Microsoft environment, which is a very static world, you know, I go around pushing people to make everything more dynamic.

"text"

"vector graphics"

This requires some expertise (which I don't have) and/or some market research. How are writers actually writing? Do they use Microsoft Word and then email it or...?

How about a Twitter thread? A poll, similar in spirit to usesthis.com?

@7:40:

We're aware that some students might actually revel in the gymnastics of a sophiscated writing and retrieval system like this. Now, we don't want to subordinate the material to the system, nor is the system merely being used to provide an alternative to a classroom experience. What we are striving for is to make a flexible system with lots of interesting material so that we may serve the needs of a genuinely contemporary student.

foo

Not sure of the significance of this sentence.

I have to admit that I'm totally making excuses here. Really, at the time of publication, I was just eager to get something out there, and I was (and am) not entirely motivated or sure of how to fully document the subject in the "literate" style. (Although it has to be said [see Kartik on Knuth] that it's possible no one else, even LP practitioners, really grok how to use LP, either.)

Okay, so the real goal of this publication is supposed to highlight the application of a new method literate programing. I think the obscurity of the chosen subject matter (and, unintentionally, the length of the text) compromises this goal.

Better, probably, would be something like the ZIP file format (sans compression), or maybe the under-appreciated Unix ar file format? The latter also has some nice properties that would make it tangentially relevant, too. (An archive containing only plain text files in Unix ar format is itself plain text.)

I'm pretty satsified with these bit-level diagrams.

This would probably be better as:

Tokenizer.KEYWORD_GROUP_BOUNDARY =

Tokenizer.IMPORTS = 129;

I think these two lines give away the "surprise". The bit-shifting could at the very least benefit from an explanation.

I think I'd prefer in a future revision a name like orient instead of align.

Typo; should be "people"?

This telling is also relayed in the Dragon Book (subsection "Bootstrapping", 11.2 Approaches to Compiler Development), which ends up citing, in a roundabout way, McCarthy's paper on LISP for HOPL I (1981).

Typo; should be "revisit".

As noted above (see https://hypothes.is/a/oHvCzI1DEeuC9IvJw8DOYw), g-blocks are most appropriate.

The link here should point to /format/#t-block instead of /format#t-block.

This construction is actually illegal in the triple script dialect. It needs to be parenthesized, as in:

foo = ((bar) => { /* ... */ })

Should be /// export for the same reason as above. (See https://hypothes.is/a/oHvCzI1DEeuC9IvJw8DOYw.)

Should be using //? here, now that g-blocks are a thing.

"before"? We only just mentioned it!

Of course, this should say 0xD 0xA and not the other way around.

Note that the following two sites are the same:

• thefutureoftext.org (see archive index at https://web.archive.org/web/*/http://thefutureoftext.org/*)
• futureoftext.org (see archive index at https://web.archive.org/web/*/http://futureoftext.org/*)

Note that the following two sites are the same:

• thefutureoftext.org (see archive index at https://web.archive.org/web/*/http://thefutureoftext.org/*)
• futureoftext.org (see archive index at https://web.archive.org/web/*/http://futureoftext.org/*)

There's a notable omission from this page. Hypothes.is.

Interesting but also not surprising to anyone who has met firsthand the problem of trying to change programmers' minds in the face of established inertia.

I'm surprised that Hypothes.is doesn't support this.

The quintessential use case should be Nelsonian "visible connections" between legal texts—all judicial opinions, petitions, briefs, etc ever filed that cites/quotes a piece of some other text, discoverable from the text cited.

Great descriptor.

(Also, did I just accidentally run headlong into my own personal epiphany about what it means, in the terms of internet culture, to describe something as "based" and exactly how that term came to be via its relation to other words? "Based": inverse of "debased".)

This neatly captures the divide between mobile apps and websites. They both seek to solve a problem with their respective approaches each being rooted in near diametrically opposing philosophies.

The only solution is probably to advocate for moving away from "REST" entirely—for all parties. Mend the discord by coining two new terms and clearly articulate the two meanings that should be attached to them.

("Indian" is another word like this, but that did not get fully deprecated. This is resulted in lots of confusion. "'Indian'? Like Native Americans?" "No, Indian as in 'from India'" "Oh, all right." A similar thing is happening with "open source".)

This probably involves making the terms (or at least one of them—so long as it's the right one) somewhat cool. Maybe the non-REST term should be AROH (pronounced like "arrow") for "Application RPC Over HTTP".

I've explained such a system, and promised Andy Chu an example that I've yet to be able to complete, but it comes down to this:

A website is fundamentally a document repository. One of the first documents that you should store in that repository is one which explains, in detail, the procedures for provisioning the host powering the site and how content gets published. (Even better if it's so detailed that the procedures exhibit a degree of rigor such that a machine can carry them out, rather than requiring manual labor by a human.)

Self-reflection and intellectual honesty is the shit. You don't have to commit yourself to your past errors.

Invitation link to the Hypothesis group for triplescripts.org:

https://hypothes.is/groups/Pk6nxawk/triplescripts-org

This is a spam account.

This is a spam account.

A great case study in how the chest-puffing associated with the certain folks in certain segments of the compiled languages crowd can be cover for some truly embarrassing blunders.

(Also a great antidote against a frequent argument by self-taught "full stack" devs; understanding the runtime complexity is of your program is important.)

It would be too much of a digression to justify this point here

I'm stealing this.

There is only one reasonable approach, and it's not even mentioned as an option here: the browser edition. (I.e., written to target the ubiquitous WHATWG/W3C hypertext system.)

Maybe something is wrong with my brain at the moment, but this is almost totally incomprehensible to me.

"A multi-dimensional erector set that will go on forever..."

No, unfortunately not forever.

Interesting that Cheyer is/was at Samsung. In my work experience, Samsung (at least its semiconductor division) is the company I've seen most in need of Doug's methodology and the one that was least amenable to it. The way I would sum up the environment at SAS is one where folks aren't even aware of how much low-hanging fruit could be had with just plain ol' "B-level" thinking, in Doug's terms, let alone Doug's exhortation to strive for C-level.

This is something I "confronted" TBL and the Solid group about recently: complete lack of dogfooding—they're all using GitHub and Gitter and whatnot, not their own tools. (Natural question arises: "if you aren't even using your own tools in your own work, how/why should we believe you when you say it will be good for us?") It's a phenomenon that I've seen commonly summarized as "X for thee, not for me".

It also reminds me of McCarthy's response to Steve Russell's proposal to actually implemeent eval: "ho, ho, you're confus[ed]".

Dan's slides are here: https://docs.google.com/presentation/d/1PT2Q1snyn5z-zRlZbKZr9ykIxSq6NRKDcPnk2UJPx4c/present?includes_info_params=1#slide=id.g4a3a5071a1_4_44

Unfortunately, the drag-and-drop event handler overrides the ability to drag-and-drop a URL into the text input.

We need a new generation of SSGs that use custom elements, and are easier to learn, with reduced complexity and simpler installation.

Agreed on the "new generation of SSGs"; disagree on the approach that relies on custom elements.

Having written tons of XUL and XBL (the forebears to Web components), I think they're great for their use case, but documents on the Web are a different use case. Documents (like this one) should still be documents—not late-bound portholes plugged by the browser. To really explore this space, XSL (or something like it in spirit) is still a better way to achieve the effect desired (even if XSL itself is gnarly and unattractive).

Hypothesis is unable to cope with annotating this page, for example, because as far is it's concerned, there is no content on it.

Build steps aren't all bad. Most of what the industry has produced in the way of tooling for the "frontend", and the threshold of acceptability those in the industry have tacitly established by use of workflows that incorporate that tooling, on the other hand, is fails to satisfy reasonable expectations.

Food for thought: consider a website that employs a static site generator that itself lives as just another piece of content available on the site—only meant primarily for the reference needs of those authoring the site content, rather than the public at large. I.e., the website as a true dynamic knowledge repository for the associated organization, and one such piece within that repository being an active paper documenting/describing how the site is put together—to such a degree of rigor that the processes and procedures described in the paper can be performed by machine, rather than needing to be carried out by a human operator.

The sidebar cuts off the page content here:

Using a half-width (1080p / 2) window in Firefox.

The irony is that there is very little that is "standard" about their favored approach. In fact, where there are standards, the community associated with the tools in question actually diverges from the standards.

("Standard" being what TC-39—including the browser makers—settled on, and NodeJS/NPM and related tools being very non-standard, advocating for incompatible abstractions. NPM, Webpack, and Babel are no more standard than TypeScript, which is no more standard than, say, ASP.NET...)

Change to lowercase in the source and style with caps using CSS?

Some questions non-technical (and even technical) people might ask:

• why am I signing up for so many services?
• can't a just "deploy" my site on GitHub?
• if I use a non-GitHub platform to deploy, do I really need a GitHub account? couldn't I just deploy from a folder on my computer?

Too much duplication between this line and the "Give a website title" heading.

How about, "Give some details", and, "Fill out some details about your website, including its title, a description, etc"?

The font size here is almost illegible tiny on my screen in combination with the other style applied.

This is pretty jarring! I know it's supposed to be cute. It should be noted, though, that the button that appears inline here is not styled the same as the ones below.

If the style were fixed, and there were a click handler added here that scrolled down and highlighted buttons in question, then the gimmick might prove useful.

These links appear to point to fragments for non-existent IDs.

The image here is blown up (oversized to take up too much space, and the jagged pixelated edges are showing).

The hover effect on these menuitems puts them in light grey on a white background--very low contrast.

The tooltip here is cut off at the top and on the left. (Using Firefox.)

The GitHub link in the top bar points to the wrong URL. It should be https://github.com/yaxdotcom/stackless-community.

Around 9:15:

"I'm telling you, that I don't know what to do. I'm completely lost."

"Then you need a guide"

[...]

"Why don't we just start at the beginning?"

The frustration of non-linear presentation in a nutshell.

On HN, William Woodruff writes:

Interestingly, I can open this just fine in LibreOffice 5. The alignment is slightly off, but the graphics appear just fine.

https://news.ycombinator.com/item?id=12793157

I think this example reveals a problem with attempts at literate programming in general, including something responsible for many of the things that Kartik brings up in his critique.

The only way to do literate programming is top-down. According to Kesteloot, the only decent way to do any programming is top-down, and bottom-up straight up doesn't work. I think he's wrong on the latter point (for reasons intrinsic to what follows), but not because I disagree with him about top-down design being superior.

The reason why literate programming hasn't caught on is because programmers aren't sufficiently interested in escaping their mind shackles. Too many of the programmers who are exploring the space, including Knuth, are bottom-up programmers and they either refuse or are unable to escape the trap of doing things in a bottom-up way, which actively works against literate programming.

In the kilo example, in fairness, they've taken somebody else's code and tried to turn it into a literate program, so (AFAIUI) the final result matches antirez's original published source for kilo.

Go in and replace the main implementation with a proper top-down rendition, progressively filling in the functions that are called, and then ask a programmer who is a fan of the idea of literate programming and agrees with Kartik's points what's wrong with it. Their reason almost certainly is going to hinge on efficiency. But that's the rub! They're subconsciously, even while acknowledging the shortcomings of the Knuthian approach, still themselves making arbitrary decisions to satisfy the compiler, not for the sake of readability! In fact, in this case, they're actively working against readability.

Literate programs, with few exceptions, have to be designed and written top-down, even at the function/method level.

typo (should be "my")

This is "The Copenhagen Interpretation of Ethics".

See also: occurrences of "copenhagen interpretation of ethics strikes again" on Hacker News

Another anti-endorsement for protocols that require this level of power.

In thinking about the best way to capture the essence of the editorial style in this piece and others from The New York Times in recent memory, I've settled on this: "carefully heavy-handed"—full just the right kind of subtext (which, funnily enough, can be considered a motte-and-bailey).

Not unlike the Manhattan eruv, or a case of a co-worker at the office thinking they're clever in their use of passive aggression, it makes me wonder who they think they're fooling. Is this thought of as some sort of board game and there's an unsavvy rulekeeper to be hoodwinked? That sitting in the backseat with a finger hovering half an inch from their sibling's cheek while exclaiming, "I'm not touching you!" is sufficient to keep the adults from turning around and saying to cut the bullshit?

If you do view this document on via.hypothes.is as suggested and you notice some extra script cruft here near the "bottom" of the text, know this: this is in fact not part of the original document, but instead part of the support code that gets inserted by Hypothesis. This could be avoided by more care on the part of Hypothesis. Refer to a series of posts by me from last week (motivated by this case):

If you're writing bookmarklets or Web extensions or you run a tool like the Wayback machine that requires you for some reason to inject "invisible" elements into the page, then don't just assume they aren't going to show up (especially if adding them to the body and not the head).

Always include a style attribute on the injected element to mark it "display: none". Always—even if it's a "script", "style", "link", "meta", or whatever other element that makes you think you don't "need" to.

If you really want to be a pal, also set the class on the injected element to an abbreviated address like <style class="example.org/sidebar/2.4/injected-content/">. And then drop a page there explaining the purpose and requirements (read: assumptions) of your injected element. This is virtually guaranteed not to conflict with any other class use (e.g. CSS rules in applied style sheets), and it makes it easier for other add-ons (or the page author or end user) to avoid conflicts with you.

The "size", defined by the expression `varsize + strx + comsize + (pc + nofimps + nofent + nofptrs + 1)4; (varsize includes type descriptors*), where these names match those used by the code generator ORG.Mod. Used by the module loader for determining how big of a hole needs to be used to accommodate the module in main memory when imported by another module or invoked to service a user command.

The version/class of the object file format used here. Special class 0 is used for the bootloader.

The module "key"—a signature computed by the Oberon compiler, used for verification by the linker.

Note that this is stored as a little-endian 32-bit word. This is the native byte order. (Signed integers use two's complement arithmetic.)

NUL-terminated module name, as ASCII.

This syntax has been adapted as a variation of the <URL:[...]> convention from RFC 1738 (refer to its Appendix).

The form appearing here is a more general derivation, which (a) allows the omission of the "role" atom† ("URL" in RFC 1738), with clients instructed to intepret the omission to mean that "URL" is implied; (b) better accommodates more recent conventions that omits both this atom and the colon separator entirely, encoding instead just the URL, as in <https://example.com>; (c) doesn't lead to interference with the HTML5 parsing algorithm. The latter is crucial for compatibility with mainstream browsers--the leading colon prevents the the bracketed plain text from being interpreted as HTML.

Maybe if we were to spec this out, we'd allow an alternative for plain links of the form <@https://example.com/> (which permits no "role"--and is therefore only used where "URL" can be inferred)?

We also want there to be a way to denote links not meant for direct navigation, but rather things that you would otherwise use the Link HTTP header or the link HTML element for. Some candidates:

• <@!https://example.com/foo> (extending the syntax further)
• <:link:https://example.com/foo> (i.e. a link URI, no special syntax)

† NB: '"role" atom" is terminology of my own choosing. The RFC's authors only ever refer to it as a "prefix".

It's not clear that this ever became common--most use in the wild seems to omit the "prefix" entirely.

At https://www.colbyrussell.com/LP/debut/plain.txt.htm, I adopt an alternative "concise" form that permits the "URL" atom to be omitted, while still allowing for the colon to be left in, for reasons explained in an annotation left there:

doesn't lead to interference with the HTML5 parsing algorithm [...] crucial for compatibility with mainstream browsers--the leading colon prevents the the bracketed plain text from being interpreted as HTML

The idea is that the form with the leading colon should be treated equivalent to the form that omits the prefix entirely, except it may be used in contexts sensitive to parsing constraints as described above.

A nice turn of phrase that I really like. It goes well with the observation about the fragility of most software that is created.

This reads string data one character at a time into the module's "address space". So why is the on-disk format for RSC string data aligned by word? The cost of instructions executed by the CPU for a call to Files.Read for a single extra NUL byte is going to be more expensive than padding up to the nearest word boundary here, in the module loader, instead of in laying them down that way by the compiler's ORG module--and that's without even considering the additional cost for disk IO!

On the Yax landing page right now, the steps are labelled in Chinese:

Use a bookmarklet + BYFOB

What's really inexcusable (hello, from anagram year 2021) is that a "proper server or test environment" should even be required. There's no inherent virtue in this. We should have the appropriate infrastructure by now that allows this to be handled using nothing more than a commodity document viewer—i.e. a web browser. The notion that you should need to drop down and run a daemon—and that this is the "proper" way it should be done—is totally backwards.

This does not follow.

Unfortunately true! Daniel Kehoe has been working on an antidote to this at yax.com, which he refers to as the "stackless" way of development.

True and succinct in a way that lets it serve as a good memetic mindworm.

Hell, yeah!

Definitely. The way I wrote this in my own notes once upon a time was:

Conjecture:¶ Attempting to write a literate program and landing somewhere off the mark produces a program that is worse than if it were written in the ordinary tradition.

One of the perils that most programmers are probably familiar with, especially in the early years.

This is great and a restatement of the laconic truth that the slowest build toolchain is the one that the user is never able to coax to successful completion.

(Reproduced from the inaugural note to the Hypothesis group for triplescripts.org)

Hello, triplescripts.org!

Hypothesis is the official channel for feedback and community discussions related to triplescripts.org. And don't forget that we have a wiki at wiki.triplescripts.org (but please avoid using the Mediawiki "Talk" pages—use Hypothesis instead).

To use Hypothesis for feedback, create an account at https://hypothes.is if you haven't already, get the browser extension or bookmarklet, and join the triplescripts.org group. (The last step is critical; make sure you're sending your annotations to the correct group and not the hypothes.is's default "Public" stream.) This is a semi-private group in the sense that you need to use the invitation link, but it's open to almost everyone willing to abide by the community rules. For more info, refer to the page on community values on the triplescripts.org wiki. Feel free to use the invitation link to invite others.

As we progress in settling on a set of community processes and practices, they will gradually be documented both on the wiki and the official pages here on triplescripts.org.

Our thanks to those at 5apps, Hypothesis, and Miraheze for hosting the services essential our project and many others.