Geez.

"Interoperable", you mean.

... why? Maybe it was only clear in hindsight, but Gruber's lack of response to the request is functionally equivalent to a pocket veto.

No.

The thing about syntax errors is that even if the build takes a long time (project is huge), syntax errors can be detected quickly.

Good way to describe ANPD.

Social barriers important, too, but underappreciated.

It is different. However, they're similar enough to draw lessons from.

I use similar, non-specced canaries all the time. E.g. small fixes for things in projects that are nonetheless obvious errors, or determining whether someone is going to try to frame my attempt to contribute by "upperhanding" me, whether they're hostile to messages attached to a name that they don't recognize, etc.

For example, if it takes too much back and forth to get a typo or link fixed in the docs (or any sort of review process for content on what is purported to be a "wiki"), then odds are, things are messed up at a greater level that are going to be a source of frustration later. At that point, I'm out.

A surprisingly large number of projects fail these, in what we are otherwise expected to consider the present Renaissance of FOSS...

Stanford runs their own archive instance (https://swap.stanford.edu/). Why shouldn't the LOC, too?

Does it? It's pretty much just as easy or easier than doing it the way that everyone else insists is correct. I'm more than half convinced, in fact, that the npm install way being unnatural is the reason why it's sacrosanct. You can't just let things be easy—people dislike any state of affairs where their experience/participation isn't some combination of necessary and valuable.

I've tried making this case. People flip their shit and then for lack of a good argument they start doing that thing where they try to shut you down because of how weird it is—and you don't want anyone thinking you're weird, do you?

It is unusual. It's not a bad thing to do, but it is still, in the literal sense of the word, unusual. That doesn't say anything about the practice itself so much as it says something about how bad the "usual" way of doing things is.

I've noted elsewhere that despite the reputation of WYSIWYG editors' tendencies for handling HTML, modern mainstream Web development practices are so bad today that just typing a bunch of junk into LibreOffice and saving as HTML results in one of the most economical ways to do painless authoring of Web content...

This gets it right. The similar essay "The JavaScript Trap" is anathema. As Richard was later cajoled into clarifying:

to be philosophically clear, the language JavaScript, as such, is not morally better or worse than any other language. What's bad is running code immediately as it arrives from someone else's server

The clarification is needed. With the existence of "The JavaScript Trap", people are under the (silly) impression that JS or programs written for the browser and executed by its JS engine are inherently bad.

Broken link. (And it's an antipattern, anyway.)

In "FactForge: A fast track to the Web of data", Bishop et al give this criterion as, "Use URIs as identifiers for things".

There may need to be a zeroeth step here, which is "don't make the mistake of designing systems in such a way that things can't be identified by name".

Weird statement. WebKit is an element in the set defined as "the 2 major browser engines".

Two things that still need to be addressed in section 7:

• the top module is special
• an uncluttered root directory is good practice

That's not right... should be "./src/LineChecker.src". (The fact that the compiler isn't throwing an error on this is a bug in and of itself...)

Spurious close paren here.

s/.*/Let's discuss an implementation strategy/

Someone should launch a "No regressive GitHub bullshit club".

This loop showcases a UI pattern that I think could be improved. There is an "edit" button visible, which opens the sidebar. The principles should more closely resemble the Hypothesis sidebar. Instead of requiring an explicit edit button which the user clicks, the editor should operate on object selections. Merely clicking any of the displayed values should select it, which should provide a handle to the underlying object, which should reveal the editor sidebar (with, ideally, the relevant field focused).

The current incarnation of the tutorial (https://raw.githubusercontent.com/akkartik/mu/7195a5e88e7657b380c0b410c8701792a5ebad72/tutorial/index.md) starts by describing "Prerequisites[:] You will need[...]", and then goes on to list several things, including various software packages—assuming a Linux system, etc.

This is the idea I'm trying to get across with the self-containedness I've been pursuing (if not with triple scripts then at least with LP docs).

That prerequisites list should be able to replace with two requirements, i.e.:

"You will need: (1) this document, and (2) the ability to read it (assuming you have an appropriate viewer [which in 2021 is nowhere close to the kind of ask of the old world])"

Another way of saying that the use of V8 means that JS isn't actually an "interpreted language" (not that that's even a real thing).

Fielding's MOMspider, one of the very first web tools, does this, albeit not at build time in a static site generator.

Just say no to backslash for path separators, even on Windows.

(I can't believe the Powershell people got this right originally and then chose to fuck it up.)

"burden"

Good example of why leveraging the browser's runtime is better. i wouldn't have guessed that the md2blog creator was using Windows. (And I didn't. I just assume that everyone is using a Mac, even though I'm on neither.)

See also Translating Type Hierarchies: Framework Analysis and a Proposal (Malone 1988) http://hdl.handle.net/1721.1/49308

First(?) published in JEP Vol. 1 Issue 1: https://doi.org/10.3998/3336451.0001.137

Any known previous occurrences to this phrase? It's used today in the Solid Project.

From the WebNet 96 Conference Proceedings (San Francisco, California, October 15-19, 1996). https://eric.ed.gov/?id=ED427649

This paper covers various shades of Semantic Web problems (not yet coined at the time) and several problems being dealt with by the Solid Project folks today.

See Market-like task scheduling in distributed computing environments (Malone, 1987).

Fuck this shit. Would you think it was a good idea to show your appreciation to someone by tipping them -$1?

It's stupidly easy to achieve the intended effect without fucking it up. If you want to send your thanks but there is no obvious way to do that, then congratualations you have found a bug. File a bug report about that instead of subjecting the recipient and everyone else in the project orbit to your public wankery.

Every item filed in a bugtracker should correspond to a defect.

Stop encouraging people to misuse project infrastructure.

The single best piece of advice in a column filled with bad advice.

This should go without saying. The fact that it doesn't is an indicator of a bigger issue that probably calls for a drastically different approach.

"... then consider not".

The problem with lots of these examples is that they read like a robot emulating what they think genuine sentiment sounds like. This example is no different.

Again: maybe modelling your approach off something that is broken is not the best thing to do.

If these techniques are supposed to work and this is the result, maybe consider the possibility that all the advice here is not the way to go about doing things.

Bad execution of mostly acceptable advice, in contrast to much of the earlier stuff, which constitutes bad advice.

Things that you say should be true.

Please, no (unless you're actually writing an email and introducing yourself).

Bugtrackers are not message boards.

On the contrary, this kind of PR speak is a good example of how to piss people off by sounding like you think they're too stupid to recognize this "trick".

"Open source" doesn't make this hard. How you're advocating that open source has to be done is what makes that hard. So stop doing that.

Gross.

You can.

Gross.

If the costs are high, then start charging people for it.

Please, no. This is a big reason why the relevant problems here exist in the first place.

It's almost like the way that GitHub is typically used is an example of how things shouldn't be done!

Because with the rise of GitHub, the behavior of most other bug reporters makes for a plethora of bad role models and a dearth of good ones.

Yeah, and that could certainly use fixing. I'm getting a dreadful sense of foreshadowing here that making contact with this observation has led the author to an entirely different conclusion—e.g., that this is an argument by analogy where what follows is going to be a bunch of suggestions that ultimately make other things worse.

Strong disagree. The tendency to the latter is awful. developer.mozilla.org committed this sin in the early days and then never shook it, despite many opportunities to do so and the many problems it caused.

Guessable URLs for stuff like reference works especially are an amazing affordance on the user end but also a much more economical use of resources on the implementor's end, because it eliminates both the fixed upfront creation cost as well as the recurring cost associated with waffling or bikeshedding about the hierarchy.

Probably one of the best things that any single person or organization can do is to identify stuff that looks like it's productive work but isn't, and then eliminate both it and the conditions that allowed it to occur, made it seem like a good idea, etc.

No. Geez.

Should be "serve".

Should be "their".

Should be "websites".

Memex began and remained as an ambiguous an not too original concept

I think memex is valued as a touchstone rather than an invention, and that's how it should be treated.

The movie "Moneyball" is a good example of how this can go wrong. People like Philip Seymour Hoffman's character create self-fulfilling prophecies of failure.

Let's go further than this: details matter. It's weird how many people don't get this, despite the fact that we have an aphorism ("the devil is in the details") baked into our language.

Instead of mentioning sha1sum(1) or linking to some seedy third-party service, dding a button right here to do calculate the SHA-1 for a given file would be trivial...

Should be "tld", not "tdl". (But really should be something RFC 2606-compliant like "you@mailhost.example".)

This is a port of Michael Schierl's OberonXref from Java. Instead of requiring a JVM, you can run it directly in the browser.

• Point it at a directory containing a Mod/ subdirectory and a resources/ subdirectory. The latter should be a copy of the directory of the same name from the original repository https://github.com/schierlm/OberonXref/tree/master/src/main/resources. The former should contain the sources for the modules of interest.

Lars Bak makes this point in a Channel 9 interview. I think it was this one (can't tell; dead link): http://channel9.msdn.com/Shows/Going+Deep/Expert-to-Expert-Erik-Meijer-and-Lars-Bak-Inside-V8-A-Javascript-Virtual-Machine

One of his interlocutors can't wrap his head around it. He makes a "but C# and Java are compiled languages"-type of argument comes off like Limmy's confused protest that "steel is heavier than feathers...".

The rise of non-algorithmic "algorithms".

A question of ontology: Does battling the build system and the various tools mentioned count as "debugging"?

Wrong. Licklider is not an author on this. No one is except for Cawkell. Cawkell mentions the others in his letter.

Missing:

• "An On-Line Information Network" (1965) [from the Project Intrex report]

These are all wrong. Cawkwell is the only author for this. The other names come from a list of others appearing in Cawkwell's letter (a list of the most cited authors, excluding self citations).

Should be "The".

Should be "extension".

Should be "bizarre".

Modern JS development is rampant with this, with the profligate misuse of triple equals (===) almost everywhere where double equals would be appropriate as one example.

"Resist it" might be a better way of putting it.

From p. 145:

I would hope that it would extend in an atmosphere of professional interchange and frankness which is characteristically American.

The metaphor itself is pretty interesting considering that the premise already involves using an iPad. I remember when in the first few years after (capacitive) touchscreen devices became available to the mainstream, someone quipped that tablets are convenient and all until they're not—that trying to get real work done, especially when it requires typing, is like being forced to "think through a straw".

wat. We're starting on page 104! This is running backwards.

The state of the world is worse than what is implied here. The implication, as I understand it, is that it's so difficult to conceive of a world that works any differently from the way Tim considers that it works today—that someone could live in a world without the Web and not know what's missing, and just as easy to exist in a world with the Web and not see it as anything other than obvious—because why would it ever have worked any differently, right? But I know empirically (and painfully) that people (whether millennial types of people or not) exist in a world where we do have this stuff and don't even understand what we have. I've had firsthand dealings with knowledge workers who still have the "I don't get it; so what?" reaction, to an exasperating degree. We are way, way short of Engelbart's vision.

"Library Networks: Should They Deal With Containers or Contents of Knowledge?"

Searching around, it doesn't seem like the outside world (e.g. Google Scholar, bibliographers) are aware that this piece Licklider wrote even exists, despite it being digitized and sitting here in the open.

This piece presages the Internet Archive and, given the juxtaposition of its lofty goals with the piece's own obscurity, there's a perverse irony here.

Licklider writes in section 2:

It is high time that librarians reach out into computer networks to create order and functionality out of what is now chaos. (The author would- estimate that 90 per cent of the computerized information in EDUCOM universities "trickles down" to back-up or dead storage tapes within two years and that less than one per cent ever "perks up" again.)

"Perking up" is more than what I'm talking about here—again, I can't find evidence that this piece is even catalogued anywhere.

Pretty sure it's because the ZIP files were expected to be written to multiple disks (floppies), and as alluded to earlier, if you wanted to delete a file, you could just insert the last disk containing the directory and "delete" it, therefore not requiring you to insert the disk(s) containing the actual file record to null it out (or overwrite with some other file record, potentially requiring 3 disk swaps). Thus, the ZIP format constitutes something like a filesystem implemented in userspace. 30 years ago, this was "obvious" and that's why you were expected to know this. There was no assumption that tradition and path dependencies would lead to ZIP still being widespread for cross-platform data interchange among machines capable of fast writes to local disks that have terabytes (although sometimes "merely" gigabytes) available.

Lots of weird reactions to this post.

In How to Stop Endless Discussion https://candost.blog/how-to-stop-endless-discussions/, the author explains the NABC model—"The model starts with defining the Need, followed by Approach, Benefits, and lastly, Competitors. Separating the Need from the Approach is very smart."

Commenting in support, Simon Willison writes:

We implemented a RFC-style process at a previous employer. [...] One thing that was particularly valuable was ensuring every proposal came with a "alternatives" section (called "competitors" in the NABC model). We also made sure that every proposal included "do nothing" as one of the alternatives

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

I scarcely think that the majority of people who are behaving as if React and/or the NPM-heavy workflow are things that simply must be dealt with have ever done on honest NABC and evaluated the foregone conclusions biased towards their preferred workflow against the do-nothing alternative of just not bringing all the heavyweight NodeJS-centric tooling into the picture.

The build tools are irrelevant (or rather, a red herring).

JS has import statements. The build tools are (or at least should be) approximating what you get without the build tools interposing themselves into the development process, but doing it in a way that reinforces The Iron Law of Bureaucracy.

See also: Knuth on Dijkstra in "Coders at Work".

Still a problem.

Still a problem.

Missing:

• Hard and Fast Thoughts for a Softcopy World `https://archive.org/details/hftorl01tedn/page/n19/mode/2up`

More annotations (to the HTML version): https://hyp.is/IEwiCEjEEeyw_H-lrHY4-Q/www.theatlantic.com/magazine/archive/1945/07/as-we-may-think/303881/

More annotations (to the PDF): https://hyp.is/IVIKog0bEeinX_so5P4fLA/csclassics.com/papers/Bush%20-%20As%20We%20May%20Think.pdf

Also available at https://monoskop.org/images/7/73/Nelson_Ted_1965_A_File_Structure_for_the_Complex_the_Changing_and_the_Indeterminate.pdf

Also available at http://csis.pace.edu/~marchese/CS835/Lec3/nelson.pdf (apparently with Ted's blessing; see `https://archive.org/details/HardAndFastThoughts1966`).

Missing:

• Annotation Engine (1999) https://web.archive.org/web/19990831231813/http://cyber.harvard.edu/projects/annotate.html
• JotBot (1998) https://web.archive.org/web/20000916234251/http://www.icc3.com/ec/architecture/webannotations.html
• ComMentor (1994) https://web.archive.org/web/19981202225348/http://www-pcd.stanford.edu/commentor/
• CoNote (1994) https://web.archive.org/web/19990422160552/http://dri.cornell.edu/pub/davis/annotation.html

That's just how the software works.

You're looking for https://doi.org/10.18352/lq.8036 (https://liberquarterly.eu/article/view/10623 as of this writing).

You're looking for https://doi.org/10.18352/lq.8036 (https://liberquarterly.eu/article/view/10623 as of this writing).

Missing:

• "We Are In Danger Of Building A Tower Of Babel" (1953)

Missing:

• Science Is Not Enough (1967)

See also:

https://web.archive.org/web/20100224081424id_/http://coscripter.researchlabs.ibm.com/download/history/history-complete.xpi

https://web.archive.org/web/20120419033715id_/http://coscripter.researchlabs.ibm.com/download/history/history-complete.xpi

(These are ZIP files.)

PDF: https://www.projectoberon.net/jmlc/paulreed2003.pdf

PDF: https://www.projectoberon.net/jmlc/paulreed2000.pdf

DRY (Don't Repeat Yourself) < TRY (Try Repeating Yourself)

Second panel syndrome.

This is a porn site today...

missing: BURKE, COLIN B. 1994. Information and Secrecy: Vannevar Bush, Ultra, and the Other Memex. Metuchen, NJ: Scarecrow Press; 1994. 466p. ISBN: 0-8108-2783-2.

I think the early 2000s transition to actor-based indexing from topic-based indexing should be examined in depth. I think stronger identitarianism is at the root of polarization, and actor-based indexing laid the foundation for it. Likes were the fuel.

Foundation for Individual Rights in Education http://www.thefire.org/

No idea what point Troy thinks he's making here, but he certainly sounds very satisfied with it.

Except, notably, for GitHub Flavored Markdown's terrible handling of ASCII CR and LF.

Most Markdown that gets published to GitHub is clearly written by people who have no problem grinding their muddy shoes all over this design principle.

(Vanilla Markdown's syntax for inline links doesn't do a particularly good job upholding this principle itself.)

I've long contended that this is one of the main reasons that the NodeJS ecosystem has evolved in the direction that it has and snubbed the original strengths of JS.

This query doesn't behave as expected. Consider by way of comparison to a Google search for anything -site:pinterest.com.

Alternatively: wikis. (The document editor is trivially reachable from the document viewer.)

Unused. Caller can/should be passing this in so we can handle the quota check internally.

Should the content of an HTTP "transcript" itself be addressable?

Consider https://hypothes.is/a/WCrtIjv9EeyPLa-hEwFgRg.

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

In a computer system or network, a runbook is a compilation of routine procedures and operations that the system administrator or operator carries out. System administrators in IT departments and NOCs use runbooks as a reference.

(Great sounding word, by the way.)

I've noticed that Python programmers are particularly bad about this, believing their language to be some sort of lingua franca, unable to see the dark corners, and unaware that the times that the program meanders into those corners can't be understood on first sight.

Excellent turn of phrase.

@30:25:

In most institutions there are too many layers of "no"

Specifically, answering the queston "Chesterton's fence or Rhesus ladder?". See https://hypothes.is/a/viXUiPZOEeu5Ty9zljmwFg

Excellent turn of phrase that I'm only just now hearing.

We have a word for this: "sophomoric".

Sounds like literate programming.

One of several recurring claims that make me feel like an alien. Do so many people really think this? It sure does end up getting said a lot.

I'm comfortable using text to communicate, but I hardly ever write in the sense people mean when they speak of it.

broken links

broken link

This passage and blurbs earlier in the letter goes against the common narrative that Engelbart's happening upon the article was life-altering as a result of being made into an instant convert to Bush's vision.

I don't know if Howard is trying to give us a nudge and wink here, but if so then the subsequent retelling that Doug was "by his own story very influenced by Vannevar Bush's As We May Think article" is certainly relevant to what Howard is suggesting, given that in Doug's own letter to Bush in 1962, he claims not to have even had Bush's ideas on his radar (no pun intended) until having rediscovered the Atlantic article after already having his own serious pursuits underway at SRI (and getting on at SRI was no small feat according to Howard's telling in Tools For Thought).

See https://web.stanford.edu/dept/HPS/sloanconference/papers/lenoir/STIMPresentations/Presentation/LetterToVBush.html

Taylorism gets a bum rap. Taylor's fans know it and seem to be at work on Wikipedia. See scientific management.

Fuck off.

Full version: https://www.dougengelbart.org/content/view/266/177/

It's here: https://www.dougengelbart.org/content/view/266/177/.

See also Ted Nelson's opening line from Xanalogical Structures, Needed Now More Than Ever:

Project Xanadu, the original hypertext project, is often misunderstood as an attempt to create the World Wide Web.

Bristly pop cultural misuse of the term "algorithm" notwithstanding, a better solution that I haven't come across anyone else mention: make them explicit, not hidden.

When it look like Dat might've had enough steam to take off (ca. 2017–2018), I wrote a draft straw proposal for how to solve the "discovery problem" with e.g. Fritter—i.e. the problem that because you only "receive" replies and other messages by checking the feeds of the people you're following, you'll be unable to reply engage with strangers who appear (or have a stranger engage with you in their thread) unless something happens like a mutual acquaintance alerting you out of band ("hey, did you see @foo's reply dat://foo.example.net/posts/ukifxdgbh.json?").

The idea is that there is a special kind of feed operated by some service provider that specializes in doing exactly that. If you find Facebook valuable, for example, then you are free to opt in and subscribe to the Facebook analog that pays attention to all feeds and works to surface interesting content for you. Under this model, unlike the Facebook regime, "leaving" is as simple as unsubscribing to that feed (and going with a different provider if you want).

Dear reader: you want https://www.rfc-editor.org/rfc/rfc1630.html.

Around @0:25:52

Krouse: Another subset of "shit just works" would be—

Leung:"No installation required"?

Krouse: Yeah. "No installation required". [...] as I was just telling you, I spent the last, like... I spent 5 hours over the last two days installing... 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 xcode.com/create?

Is "overly-educated" the right thing here? As a substitute for the traditional euphemism "well-heeled", I think something like "highly credentialed" fits better.

When logged in, the page in question requests (using XHR) the URL https://www.pbs.org/watchlist/page/1/, which returns something with a shape that looks like this: