Overall, I'm pretty happy with the level of scrutiny the claims here are being subjected to over on HN. https://news.ycombinator.com/item?id=27880905

(One of the rare times on HN in recent memory where a potentially attractive position on what could have been a contentious issue involving techno-pessimism related to the Web seems to thankfully be overwhelmingly opposed, in recognition that the arguments are not sound.)

The formatting of this link is messed up.

It was only 6 days ago that an effective takedown of this type of argument was hoisted to the top of the discussion on HN:

This latter error leads people into thinking the characteristics of an individual group member are reflective of the group as a whole, so "When someone in my tribe does something bad, they're not really in my tribe (No True Scotsman / it's a false flag)" whereas "When someone in the other tribe does something bad, that proves that everyone in that tribe deserves to be punished".

and:

I'm pretty sure the combination of those two is 90% of the "cyclists don't obey the law" meme. When a cyclist breaks the law they make the whole out-group look bad, but a driver who breaks the law is just "one bad driver."¶ The other 10% is confirmation bias.

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

It reminds me of The Chronicle's exhorting ordinary people to support the then-underway cause intended to banish Uber and Lyft from Austin, on ostensibly populist grounds, when in reality the cause was aimed at preserving the commercial interests of an entrenched, unworthy industry. I saw a similar thing with the popular sentiment against Facebook's PATENTS.txt—a clever hack on par with copyleft which had the prospect of making patent trolls' weapons ineffective, subverted by a meme that ended with people convinced to work against their own interests and in favor of the trolls.

Maybe it's worth coining a new term ("anti-rebellion"?) for this sort of thing. Se also: useful idiot

Like the parent comment by derefr, my actual, non-hypothetical practice is saving to the Wayback Machine. Right now I'm probably saving things at a rate of half a dozen a day. For those who are paranoid and/or need offline availability, there's Zotero https://www.zotero.org. Zotero uses Gildas's SingleFile for taking snapshots of web pages, not PDF. As it turns out, Zotero is pretty useful for stowing and tracking any PDFs that you need to file away, too, for documents that are originally produced in that format. But there's no need to (clumsily) shoehorn webpages into that paradigm.

If you do the print-to-PDF workflow outlined earlier in the thread, you'll realize it doesn't scale well, requiring too much manual intervention and discipline (including taking care to make sure it's filed correctly; hopefully you remember the ad hoc system you thought up last time you saved something), that it's destructive, and that it ultimately gives you an opaque blob. SingleFile-powered Zotero mostly solves all of this, and it does it in a way that's accessible in one or two clicks, depending on your setup. If you ever actually need a PDF, you can of course go back to your saved copy and produce a PDF on-demand, but it doesn't follow that you should archive the original source material in that format.

My only reservation is that there is no inverse to the SingleFile mangling function, AFAIK. For archival reasons, it would be nice to be able to perfectly reconstruct the original, pre-mangled resources, perhaps by storing some metadata in the file that details the exact transformations that are applied.

Yes. The problem also with relying on programmers' blogged opinions for advice and understanding is that a lot of the material is the result of people trying to work things out for themselves in public—hoping to solidify their own understanding by blogging—and it's not expert advice. Aspiring programmers further run the risk of mistaking any given blogger's opinion for deep and/or widely accepted truths. (And JS in particular certainly has lots of widely accepted "truths" that aren't actually true. Something about intermediate JS programmers has led to an abundance of bad conventional folk wisdom.) Indeed, spot-checking just a few of the links collected in the list here reveals plenty of issues—enough to outright recommend against pointing anyone in its direction.

On the other hand, the problem with the ECMAScript spec is that it has gotten incredibly complicated (in comparison to the relative simplicity of ed. 3). There is a real need for something that is as rigorously correct as the spec, but more approachable. This was true even in the time of the third edition. In the early days of developer.mozilla.org, the "Core JavaScript Reference" filled this hole, but unfortunately editorial standards have dropped so low in the meantime that this is no longer true. Nowadays, there is not even any distinction between what was originally the language reference versus the separate, looser companion for learners that was billed as the JavaScript guide. The effect that it has had is the elevation of some of the bad folk wisdom to the point of providing it with a veneer of respectability, perhaps even a "seal of approval"—since it lives on MDN, so it's gotta be right, right?

Better to use querySelectorAll and then filter based on figure designation (e.g. nodeValue.startsWith(" (Fig. 1) ")).

Unused!

(Caller should also probably look more like:

let system = new SystemB(document);
system.attach(document.querySelectorAll("script"))

... where the querySelectorAll return value's role is to act as a list of document figures, for the reasons described elsewhere https://hypothes.is/a/-n-RYt4WEeu5WIejr9cfKA.)

it looks like my comment got moderated out, and I didn't save a copy. Not going to retype it here, but the gist is that:

• Ward invented the wiki, not just the sliding panes concept.
• Sliding panes are a riff on Miller columns, invented by Mark S. Miller
• Miller columns are like a visual analog of UNIX pipes
• One obvious use case for Miller columns is in web development tools, but (surprisingly) none of the teams working on browsers' built-in devtools at this point have have managed to get this right!

Some screenshots of a prototype inspector that I was working on once upon a time which allowed you to infinitely drill down on any arbitrary data structures:

https://web.archive.org/web/20170929175241/https://addons.cdn.mozilla.net/user-media/previews/full/157/157212.png?modified=1429612633

https://web.archive.org/web/20170929175242/https://addons.cdn.mozilla.net/user-media/previews/full/157/157210.png?modified=1429612633

Addendum (not mentioned my original comment): the closest "production-quality" system we have that does permit this sort of thing is Glamorous Toolkit https://gtoolkit.com/.

Possibly true, but dubious.

Typo; should "philanthropic".

See https://en.wikipedia.org/wiki/Fragile_base_class

Should be "mistakes".

As an experienced user, this claim strikes me as false.

I often start in a graphical file manager (nothing special, Nautilus on my system, or any conventional file explorer elsewhere), then use "Open in Terminal" from the context menu, precisely because of how much more efficient desktop file browsers are for navigating directory hierarchies in comparison.

NB: use of a graphical file browser doesn't automatically preclude keyboard-based navigation.

something, something, Erlang

This could benefit from examples.

See also: woodworkers

Later, Why do we need new terminology?.

http://web.archive.org/web/20061210231152id_/http://akamai.infoworld.com:80/weblog/udell/gems/ju_mynewgig.mp3

http://jonudell.net/udell/gems/ju_mcgraw.mp3

http://jonudell.net/udell/gems/ju_burbeck.mp3

http://jonudell.net/udell/gems/ju_gemignani.mp3

http://jonudell.net/udell/gems/ju_rosenfeld.mp3

http://jonudell.net/udell/gems/ju_frost.mp3

http://jonudell.net/udell/gems/ju_idehen.mp3

http://jonudell.net/udell/gems/ju_HillMcFarland.mp3

http://jonudell.net/udell/gems/ju_linqMay06.mp3

http://jonudell.net/udell/gems/ju_singleton.mp3

http://jonudell.net/udell/gems/ju_martinez.mp3

http://jonudell.net/udell/gems/ju_rodgers.mp3

http://jonudell.net/udell/gems/ju_rayhill.mp3

http://jonudell.net/udell/gems/ju_dcstat.mp3

http://jonudell.net/udell/gems/ju_hudack.mp3

http://jonudell.net/udell/gems/ju_glushko.mp3

http://jonudell.net/udell/gems/ju_patrick.mp3

http://jonudell.net/udell/gems/ju_mayfield.mp3

http://jonudell.net/udell/gems/ju_xbrl.mp3

http://jonudell.net/udell/gems/ju_suber.mp3

http://jonudell.net/udell/gems/ju_fielding.mp3

http://jonudell.net/udell/gems/ju_windley.mp3

http://jonudell.net/udell/gems/ju_navizon.mp3

http://jonudell.net/udell/gems/ju_fahlberg.mp3

http://jonudell.net/udell/gems/ju_ullman.mp3

http://jonudell.net/udell/gems/ju_ericson.mp3

http://jonudell.net/udell/gems/ju_liu.mp3

http://jonudell.net/udell/gems/ju_schneider.mp3

http://jonudell.net/udell/gems/ju_russell.mp3

http://jonudell.net/udell/gems/ju_securent.mp3

http://jonudell.net/udell/gems/ju_wilkin.mp3

No, it isn't.

Nevermind LibreOffice Draw, you can use LibreOffice Writer to author the actual content. That this is never seriously pushed as an option (even, to my knowledge, by the LibreOffice folks themselves) is an indictment of the computing industry.

Having said that, I guess there is some need to curate a set of templates for small and medium size businesses who want their stuff to "pop".

This is simply not true. The unique character of software under the conventions that most software is published (effectively obfuscated, albeit not for the purpose obfuscation itself, but for the purposes of producing an executable binary) means that reciprocal licenses like the GPL are very much reliant on the existing copyright regime. Ubiquitous and pervasive non-destructive compilation would be a prerequisite for a world where copyright's role on free software were nil.

Nope, doesn't work:

Loading failed for the <script> with source “http://assets.annotateit.org/annotator/v1.2.10/annotator-full.min.js”. annotatorjs.org:242:1

(assets.annotateit.org is unreachable, and the annotateit.org landing page contains a farewell message "July 14, 2019. The service has now been fully shut down.")

It would be nice if these were still functional, for historical reasons.

At the risk of saying something that might not now be correct due to recent changes in the language spec, this has historically not been true; Array objects are more than syntax sugar, with the spec carving out special exceptions for arrays' [[PutValue]] operation.

There is a classic mistake being committed here. Private policy does not the law make.

The Wine project wants to exclude you if you've seen laid eyes on Windows sources? That's fine; that's their right. But the Wine devs are neither writing legislation nor issuing binding opinion.

We see this everywhere. Insurance company wants to have their adjusters follow some guideline when investigating/settling claims? Again, that's fine, but their stance may or may not have anything to do with actual law. Shop proprietor wants to exclude you from the store if you are (or are not) wearing a mask? Okay, just don't infer that this necessarily has any bearing on what is law in the eyes of the courts. Imposing keto on yourself except one cheat meal on Sundays? Fine again, but not law.

Indeed. I've argued for awhile that WebKit is an excellent basis for a new, community-developed browser, both strategically and technically. That is, it makes sense to start a browser project based on WebKit even now, whether Hachette exists or not.

An alternative, don't create a service. Let the Web be the platform.

If I'm a contributor to the project, then the extension's about.html (or whatever) should both credit me and at my option include a link to the place where I publish or link to useful scripts. This goes for all contributors. The way to share would be to (a) publish their scripts somewhere online and (b) contribute to the project and add their entry to about.html. Alternatively, for people not interested in contributing (and to maintain code quality and avoid poorly aligned incentive structures), the project itself can keep a simple static page up to date, linking to various others' pages as the requests to do so come in.

I've mentioned before that the era we're currently living in is incredibly different from the era of just 10–15 years ago. I've called the era of yesterdecade (where the author of this piece appeared on Colbert a ~week or so after Firefox 3 was released and implored the audience to go download it and start using it) the "Shirky era", since Shirky's Here Comes Everybody really captures the spirit of the times.

The current era of Twitter-and-GitHub has a distinct feel. At least, I can certainly feel it, as someone who's opted to remain an outsider to the T and G spheres. There's some evidence that those who haven't aren't really able to see the distinction, being too close to the problem. Young people, of course, who don't really have any memories of the era to draw upon, probably aren't able to perceive the distinction as a rule.

I've also been listening to a lot of "old" podcasts—those of the Shirky era. If ever there were a question of whether the perceived distinction is real or imagined these podcasts—particularly shows Jon Udell was involved with, which I have been enjoying immensely—eliminate any doubts about its existence. There's an identifiable feel when I go back and listen to these shows or watch technical talks from the same time period. We're definitely experiencing a lowpoint in technical visions. As I alluded to earlier, I think this has to do with a technofetishistic focus on certain development practices and software stacks that are popular right now—"the way" that you do things. Wikis have largely fallen by the wayside, bugtrackers are disused, and people are pursuing busywork on GitHub and self-promoting on social media to the detriment of the things envisioned in the Shirky era.

The title here is a reference to the William Gibson quote "The future is already here — it's just not very evenly distributed."

This piece is syndicated here from its original appearance as a post in Wired Insights https://www.wired.com/insights/2013/02/rebooting-web-comments-wire-them-to-personal-clouds/.

Jon's followup is here http://jonudell.net/tpc/28.html.

Indeed. Web literacy among the masses is pitifully low. Browsermakers are certainly to blame for being poor stewards. Hot Valley startups are responsible as well. (See https://quoteinvestigator.com/2017/11/30/salary/.)

This is more or less how linked data notifications work. (And Solid, of course, goes beyond that.)

I used to think this. (That isn't to say I've changed my mind. I'm just not convinced one way or the other.)

Another foreseeable outcome, relative to the time when the friend here was making the comment, is that it would lead to people being nastier in real life. Whether that's true or not (and I think that it might be), Twitter has turned out to be a cesspool, and it has shown us that people are willing to engage in all sorts of nastiness under their real name.

I Huffduffed @judell's episodes ("Interviews with Innovators":

https://huffduffer.com/crussell.

For some reason, this page doesn't link back to the item's overview/collection entry. It can be found here:

https://archive.org/details/conversationsnetwork_org

no u

You Just Chip Away Everything That Doesn’t Look Like David

(Found while looking into this, since it's said to be an "old saw" here, but I'm much more familiar with the draw the rest of the fucking owl from the modern meme-o-sphere.)

This guy gets it.

Great way to put it. One thing that I keep trying to hammer is that the "minimum thing" here looks more like "open up a word processor, use the default settings, focus on capturing the content—i.e. writing things out just as you would if you were dumping these thoughts into a plain text file or keeping it to, say, the subset of Markdown that allows for paragraph breaks, headings, and maybe ordered and unordered lists—and then use your word processor's export-to-HTML support to recast it into the format that lets use their browser to read it, and then FTP/scp/rsync that to a server somewhere".

This sounds like I'm being hyperbolic, and I kind of am, but I'm also kind of not. The process described is still more reasonable than the craziness that people (HN- and GitHub-type people) end up leaping into when they think of blogging on a personal website. Think about that. Literally uploading Microsoft Word-generated posts to a server* is better than the purpose-built workflows that people are otherwise coming up with (and pushing way too hard).

(*Although, just please, if you are going to do this, then do at least export to HTML and don't dump them online as PDFs, a la berkshirehathaway.com.)

I'm not sure this is true! The intended use has a lot more influence over how people do things than people think!

I can't wait for the people pushing GitHub Pages and building products/integrations on top of it to realize this, but I'm not sure they ever will.

Because of of the responses that this got, this makes for a great example of people's inability to get the question right before trying to get the answer right.

From the commentary in the video "Workflow: Universal project folder structure"

"I can intuit that this has something to do with[...]"

"I look at this folder[...] and I get some sense[...]"

"It's got this package dot bin thing, oh okay, so that means there's also a special command that I can run with this[...] you understand there is a command here"

This would be good as a bookmarklet--when viewing an image, you invoke it, and it writes over the image with the details of the underlying structure.

See also: "Select a window, click the 'flip' button to see what is 'behind' the window, as a metaphor to see what the application is doing"

select * from users

We can preview the data, and since that looks good, let's add a table to the canvas to display it. When we do this, it helpful pre-fills the data from our last query.

This differs from LDN, where the the annotation service is squarely under the control of the document author. This is also using sensor attachment in a different sense that the way it first appears above. The application is more akin to RSS. With RSS, the links exist in some other "document" (or something like it; generall can be modeled as OPML, even if it's really, say, an sqlite store).

Okay, so this is back to looking like LDN, except the (novel?) idea that after sending the annotation to the annotation service responsible for annotations to the report, her final annotation gets sent to that that annotation service corresponding to a different document—Jack's mailbox. Interesting!

(Maybe this is explicitly laid out as a possibility in one of the several pieces associated with LDN and I just never noticed?)

Linked data notifications?

(I like the "sensor" imagery.)

Surely RDF already has something like this...? I tried looking around briefly but couldn't find it.

Conjecture: (almost?) every instance of reimplementation by anyone should be considered fair use on the basis that it is ipso facto transformative.

I've done absolutely no actual work in this part, but this is what the third part (the C) in the "ABCs of triple scripts" is supposed to be about.

This is a direct response to the question, so it makes sense to write it out, but Spitz's piece (linked earlier) Open source is not enough describes the problem adequately.

This is eventually supposed to be the default client on graph.5apps.com.

TODOs, bugs, and ongoing development notes are organized in a semi-private Hypothesis group—invitation is required, but invitations open to anyone with the link. That includes you; here's the link to join the group: https://hypothes.is/groups/y6v5zd8n/streamline-w2g-client

Invitation link for this semi-private group:

https://hypothes.is/groups/y6v5zd8n/streamline-w2g-client

If you look at the incomplete graph.js implementation, you can see that it's actually using a class instead. This is good! However, I advocate for class names that happen to also be a hostname + resource (i.e., like URL, but omitting the http:// part).

(I suppose that, alternatively, if someone wanted to use a shorter class name, such as "w2g-tag", then graph.js could be configured to allow for that, but it would need to be explicit configuration on the author/publisher's part.)

Probably not a universal sentiment!

Revisiting this some months later while thinking about programming in general, I realize that that what I want from a nextgen magic development environment are are live comments.

Take this _parseDefinition method, for example, and now compare it to the RSCAssembler's getRR method. The latter has a comment (with an interesting diagram), and the former does not. Suppose even that there were a comment for the _parseDefinition method—it might contain a snippet that's meant to be sample input to help visualize what the method is doing—there would still be the matter of needing to simulate the program in your head. Really, what I want is to be able to write out a snippet and then while reading the code here, anyone can mouse over each statement in the method definition and see what effect it has—say a caret moves along, pointing at the scanner "tip", and visually chunking the tokens.

One should also be able to dynamically modify that snippet—let's say they wanted to "link" the live, scrubbable execution to a particular point in Fig. 1 (the fixT entry instead of fixP, for example)—in this case that snippet should "take over" the live comment, so we can concretely visualize execution of it instead. We should go further than that, even, and not even require the reader know which part of Fig. 1 is actually handled by this section of the code. We should be able to dynamically discover, based on the Ctrl+Space activation, that _parseDefinition is used to handle the fixP, fixD, and fixT lines, and then then reader can point to them (like the difference between a command-line interface where you have to know what you're allowed to do and how to say it, compared to a graphical interface that visually communicates the program's affordances).

The closest I've seen to this are the Moonchild editor :https://harc.github.io/moonchild/ and REPLugger :https://github.com/Glench/REPLugger.

Here's a novel(?) way to explain it that should appeal to those who claim that the host revealing the goat behind door #3 doesn't "matter":

You are given the choice of 3 doors to pick from. Someone else is given the compulsory opportunty to "bet" against your pick. (Stop here and think of your odds of getting it right compared to their odds of beating you.)

Now, the host reveals door #3. Your adversary originally had 2/3 odds of winning, and indeed this is where the door #3 revelation doesn't "matter": your adversary's odds that you were wrong are still 2/3. Let's mix up the game, though: suppose the host gives you the opportunity to switch places with the person betting against you—so if you switch then your adversary gets stuck with whatever your original guess was, and in the event that your original guess was wrong, then you actually win the game. This is exactly the balance of odds presented to you in the original formulation.

Widely relevant questions beyond even the selected topic.

That neither content creators nor browser vendors are particularly concerned with the production and consumption of documents, as such, is precisely the issue. This is evident in the banner that the majority of the work has occurred under over the last 10+ years: they're the Web Hypertext Applications Technology Working Group.

No one, not even the most well-intentioned (such as the folks at Automattic who are responsible for the blogging software that made Christina's post here possible), see documents when they think of the Web. No, everything is an app—take this page, for example; even the "pages" that WordPress produces are facets of an application. Granted, it's an application meant for reading the written word (and meant for occasionally writing it), but make no mistake, it's an application first, and a "document" only by happenstance (i.e. the absence of any realistic alternative to HTML & co for application delivery).

In fact, HTML makes it very easy (true for the reasons that lead Mark to write that it can be copied and manipulated). It's contemporary authoring systems and the typical author-as-publisher and the choices they make that are what makes this difficult.

The future of rich media lies in striving to be more like dead media (or at least mining it for insights by better understanding it through thoughtful study), rather than the misguided attempts we've been living inside.

(This is something that I've done a 180 on in the last year or so.)

It is exactly that "timid" ("tepid"?) attempt at dynamism that has led to these circumstances.

I've advocated for a different approach.

Most of these "rich formats" are, let's just be honest, Microsoft Office file formats that people aren't willing to give up. But these aren't binary formats through-and-through; the OOXML formats are ZIP archives (following Microsoft's "Open Packaging Conventions") that when extracted are still almost entirely simple "files containing lines of text".

So rather than committing your "final-draft.docx", "for-print.oxps" and what-have-you to the repo, run them through a ZIP extractor then commit that to the repo. Then, just like any other source code repo, include a "build script" for these—which just zips them back up and gives them the appropriate file extension.

(I have found through experimentation that some of these packages do include some binary files (which I can't recall offhand), but they tend to be small, and you can always come up with a text-based serialization for them, and then rework your build script so it's able to go from that serialization format to the correct binary before zipping everything up.)

really kickass metaphor

Why does the Edit link point to /contact/edit, but the Unpin link point to /derp/contact/unpin?

What is this referring to? Can't tell without diving into the source.

Also broken. See also https://hypothes.is/a/frWkbqLxEeuwwRsPcM5VcQ

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".)

This links me to /derp, which returns a 404 ("This page is missing. Are you sure it was ever here?")

When dark mode is enabled, both this link and the "now" link appear as blue-on-black, which is too hard to read.

"JavaScript" (or "JS")

"JavaScript" (or "JS")

For "untitled" posts, this should probably be the post date, or maybe something like "April 20, 2021 (qo1uj5qae3)", where the autogenerated ID is de-emphasized (greyscale or something).

gaps between lines is off here.

No close fence?

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?

Need to eliminate the overlap between this page and the Development Setup page.

See also: https://hypothes.is/a/CSposKLsEeu7iideSalB8w

Should be U+2014

This should be an em dash (U+2014). Here, it is an en dash (U+2013).

"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.

Need to eliminate the overlap between this page and the Getting Started page.

See also: https://hypothes.is/a/DyLhNKLsEeufFONBnjpvDw

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

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

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

@2:00+ Subscribe widget not shown on index pages. Should be replaced with an inline deep link that addresses the widget on the actual post (shown in the video immediately afterward) by a fragment identifier.

Take inspiration from the mailto URI scheme here; ideally, we should be able to re-use almost exactly the same style of URL construction.

I'm very interested in this, but it's a lot of work — at least if you want to get it "right" (and I do). That would involve:

• parallel implementations with perfect feature parity, one each in golang (for the backend) JS (for ProseMirror, which may itself need to be hacked to support our alternate impl? don't know—I haven't dived deep on ProseMirror at all, but I have some reasonable suspicions, based on some familiarity with marijnh's past work)

Having looked into this before for my own reasons, I would probably not use any existing library from the Go or JS ecosystems. I'm pretty sure what I found the PowerShell folks settled on was the best at the time. Written in C#; would need to be ported. I expect this to be at least a couple months work, full time.

(Not a good first bug, or even a good undertaking right now—which is why I hadn't already done it on my own.)

I created an account (related to this) that can/should be deleted: https://write.as/test-t654/

Web Annotations > Webmention

Is this the kind of claim we want to be making at the WriteFreely level? Ideally, this statement is true on all instances, but I fear a cavalcade of hacked together versions powering instances where various promises like this get broken.

This "link" (and the "Make default editor" button) are "broken" (presumably because I don't have a pro account, but there is no clear call-to-action here).

This matrix is confusing. I'm not sure I get it even now. (What's the last line "user + blogs + posts" about?)

For cross-reference: Embed pkg in Go 1.16

Not a real domain name.

This would greatly benefit from something like Glen Chiacchieri's REPLugger. See:

• :https://github.com/Glench/REPLugger
• :https://www.youtube.com/watch?v=F8p5bj01UWk

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.

Everyone should "take control" of their project like this. I've said it before. The tools are already there, with GitHub pages. It should be the norm to link to e.g. ghost.github.io/foo instead of github.com/ghost/foo, and for the former to give the viewer everything that the latter gets them (except for anything that would require auth).

This is what I'm aiming for with triplescripts.org. Initially, I'm mostly focused on the reproducibility the build process for software. In principle, it can encompass all kinds of use, and I actually want it to, but for practical reasons I'm trying to go for manageable sized bites instead of very large ones.

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"

"allow"? "enable"?

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?