awful

Terrible name choice! EscapeText (or EscapeTextForHTML if you want to be really verbose) is the most correct (and less footgun-y) way to refer to this.

I wonder how many security problems the name EscapeHtml will lead to...

The Web, you mean.

NB: This refers to the the musical artist, not the (non-existent) Madonna, Texas.

This is an ordinary bug and not worthy of note in a document about the relative strengths and weaknesses of WebDAV (or any other protocol); it's not an inherent consequence of WebDAV as designed...

should have been "[...]a=23189,00.asp"

should have been http://www.pcmag.com/print_article/0,3048,a=23189,00.asp

i.e., s/1=/a=/

should be "IETF"

should be "IETF"

This page is dense with references. It's an excellent candidate for marking up and connecting to the other documents it references, Xanadu-style

what the FSF (GPL) calls "preferred from for modification"

should be "W3C"

except TBL did imagine them -- browsermakers (outside CERN) didn't

that's a feature (not a bug)

should be "HTTP"

should have been "[...]a=23189,00.asp"

should be "IETF"

Files which render themselves when published (e.g. templates or other scripts) will be rendered when accessed from a mounted WebDAV volume. This is because WebDAV clients issue a GET (it's an extension of HTTP, after all) to hand you your data. You can't simply mount a WebDAV share and start editing PHP files, for example. Until a data type is provided for source code-based documents, this will remain a problem.

This is a node-/organization-level information architecture problem.

If /foo.php is a script that generates a Web page, then separate identifiers need to be assigned for each resource (one for the document itself, and one for the script that generates it). It is a failure of the node not to distinguish between the two. A separate content type would not solve this problem—it would just appear to cover it up (as well as create new ones).

Traveler,

Try https://web.archive.org/web/20021019234705/http://www.pcmag.com/print_article/0,3048,a=23189,00.asp

Locking: Locking protects web team members from overwriting each other’s changes. When two or more people are working on the same file, WebDAV ensures that they compare or merge changes before writing to the file.

Git solved this problem in a much cleaner and respectable way: it's an append-only log. The only thing left is to "flatten" the two namespaces into a single one. On first inspection, this seems like it would re-introduce the need for rewrites (and locking?), but this can be cleverly solved by preregistration of forward references. Locating the current "head" can be resolved in log2(n) time wrt number of "revisions" (and can also be avoided in many cases, besides).

How does WebDAV work? Each of your colleagues — whether they’re in Bangalore or Bangor — mounts a WebDAV volume located on the shared web server to his or her desktop. They can then access its files as they would any other networked volume.

This is a pretty unsatisfying description of what WebDAV (and the underlying spirit) actually offers.

Mounting a remote host like a local disk is not without its (limited) use and convenience, but it's neither the intent nor the extent behind the spirit of WebDAV.

I think there's a category error here.

See https://hypothes.is/a/V5kHYvpDEe2ilbsFpHmKKg

See https://hypothes.is/a/V5kHYvpDEe2ilbsFpHmKKg

See https://hypothes.is/a/V5kHYvpDEe2ilbsFpHmKKg

There are several points where there is a gesture/reference to something on the screen ("This is a headline", "Here is a talk"...) where what's shown on the screen is doing the heavy lifting.

Don't just say, "here [it is]", though. Mention the presentation and author by name when speaking. The screen is a complement.

Consider: there's no reason in principle why this entire presentation couldn't be a "blogcast" (a blog post in audio form).

This accounts for ~all programmers. It's not just a matter of people presenting themselves as having credentials that are just backed up by monkey-see-monkey-do IT cargo cultism. Programmers write bugs.

It's not really clear what this section has to do with the overall talk. How is this (specifically the part about all programmers creating bugs) mitigated or addressed by the contents of this talk?

There's a hard transition after this point, but it comes in such a way that makes it seem like what's next is something that will expound in some detail upon this point.

This def. needs to be more fully developed.

Maintaining access to past works due to any number of reasons including file format lock-in (even when the software in question is open source) is actually a huge deal.

(It is my contention that this accounts majorly for a bunch of the problems in e.g. the NPM ecosystem.)

This whole thing could stand to be more fully developed. I don't have any specific advice, it just seems unclear and feels like a nonsequitur upon reaching the end and moving on to the next topic.

I have a lot to say about this, but I'll be succinct and just say, "don't conflate a language with a particular community that uses that language—even if that community has achieved culturally dominance".

What does this mean, though? Concretely, I mean. (Could stand to qualify/quantify this.)

I was surprised to find about a ~month ago that LÖVE is written in C++. Its scripting support is Lua-based.

Not sure that this is a good argument. The fact that someone is using $LANG in such a way (for "conquest") doesn't have any bearing on how you have to use the language.

Coming from a place of evaluating an argument on soundness and rationality, the conclusion/advice given (use Lua) is only about half a step removed from PL hipsterism—at least when evaluating the reasons actually stated. (There may be a stronger argument here, but it's obscured by this one.)

Maybe not necessary for the intended audience but might benefit from distinguishing between bonafide forks vs what GitHub has done to the word.

Isn't that a contradiction?

Note that these two things are at odds. Literate programming (to a high standard—higher than Knuth's standards, viz [1]) is probably the single best thing that enables the former, but it works against the latter.

1. http://akkartik.name/post/literate-programming

huh?

lame

See also: http://www.ariadne.ac.uk/issue/31/web-focus/

Try https://www.w3.org/Provider/Style/URI

In a book? Yes.

You mean price guide books? If so, yes.

Yes.

Yes.

Yes.

rsync.net would be really great for repo hosting if you could trivially pair it with something else to get public repos. You can't, though.

This pretty much the basis for Kartik's criticism in Literate Programming: Knuth is doing it wrong.

Thought experiment: what if you elevated the documentation to first-class status rather than as low-stakes generated artifacts that can be blown away and regenerated? What if you modified your compiler to consume the documentation and produce the same binary as the one produced by what you now consider to be your source code?

See https://hypothes.is/a/QZJW9PPLEe2LeiNwpwbj6A

In other words, it risks undermining the intent of the API design.

Cox published a copy of this text on his homepage:

https://web.archive.org/web/20021109120553/http://www.virtualschool.edu/cox/pub/92ByteWhatIfSilverBullet/index.html

Confusingly, he labels it there "What if there's a Silver Bullet... And the Competition Gets it First?"—which seems to be the title of an ~~entirely different article (... and which itself is confusingly named 92ByteWhatIfSilverBullet, even though it is described as "An editorial for the Journal of Object-oriented Programming in June 1992. Republished in Dr. Dobb's Journal in Oct 1992.")~~

Huh?

One of the recurring things that needed to be pointed out in the fab (still does), is that Samsung is not in the business of selling workers who will suck it up and show that they're willing to ignore all the broken things around them while doing a bunch of dumb day-in-and-day-out stuff undeterred in order to not look lazy* and plausibly prove that they're badass It's in the business of fabbing chips.

* Side note: everyone who needed this pointed out was, in reality, lazy; the entire mode of attack came from obvious self-loathing.

More accurately: incentivized to make the browser runtime accommodate apps that assume a Web platform rich in APIs not dissimilar to mobile app platforms

Except not, because the domain after the @ sign is part of your handle, and it's not "creating" any challenges that weren't already a thing with email...

This definitely needs to be corrected.

Ibid. There is nothing about HTTP which makes your URIs unstable. It is your organization.

There's nothing in principle that makes blogging untrustworthy. It comes down to, as Elavsky says just a bit later, "higher [or lower] standards" for longevity. But there's a sleight of hand here. The people who are receptive to the proposal in this paper are already almost by definition selected for those who have high standards. So this is not a robust argument that there's anything superior to this approach vs "Just put it on your blog and take the same amount of care that you would when following the archival advice in this paper."

This is just a misuse of HTTP.

Prior art to the (surprisingly late entry) rel=canonical link introduced by Google.

See also: Linked Data Notifications

It's embarrassing that this isn't supported by freedesktop.org-affiliated environments.

Related: w2g/graph.global

And if you have to look up API docs to write a plugin to publish to a given service, then you have lost, too.

Things like Neocities's out-of-band WebDAV gateway are some of the most pointless things in the world. WebDAV is HTTP! Just allow a PUT to the intended URL!

There's more going on in the quoted requirements than these comments suggest.

Server-side processing for view control is gross—it's a conceptual abomination.

Consider the phenomenon of people screwing others over as as matter of course in what they consider ways small enough to be acceptable—on the assumption that the other person seems to be positioned in such a way that they can absorb the shock.

This is: Berners-Lee, Tim. “World-Wide Computer.” Communications of the ACM 40, no. 2 (February 1997): 57–58. https://doi.org/10.1145/253671.253704

See also: the brains in Futurama's Infosphere.

The Web does not yet meet its design goal as being a pool of knowledge that is as easy to update as to read. That level of immediacy of knowledge sharing waits for easy-to-use hypertext editors to be generally available on most platforms. Most information has in fact passed through publishers or system managers of one sort or another.

Apart from being a place of communication and learning, and a new market place, the Web is a show ground for new developments in information technology.

The eternal tyranny of the milieu of the Web

It is important that it work on Windows, but three-quarters of all PCs do not run Windows. Three-quarters of all traditional laptops and desktops? Sure, but most personal computers these days are mobile phones.

@17:11

The idea of portability is that you take a fully running system that is compliant with the expectations of that host system, pick it up, put it on the other platform, and it takes care of all the problems associated with living on that new platform and just works.

Presages containerization in the 2010s.

@17:03

The idea of portability is not that you take your C code and recompile it and hope it compiles and hope the compilers have the same bugs in them.

Echoes of Darwin.

@54:06:

Host: So in a way it's a regulation to drive change, or...

Anderson: Or, regulation to stop change that would upset existing safety standards social expectations, social norms.

This could be trivially solved by extending the syntax to include some notation that has the semantics of a well-defined reference but the ergonomics of a quoted string. So if the notation used the sigil ~ (for example), then ~"Bob" could denote an implicitly defined entity that is, through some type-/class-specific mechanism associated with the string "Bob".

Ugh. This is the real problem, I'd wager. Nobody wants to derp around configuring the Xresources to make xterm behave acceptably—i.e. just to reach parity with Gnome Terminal—if they can literally just open up Gnome Terminal and use that.

I say this as a Vim user. (Who doesn't do any of the suping/ricing that is commonly associated with Vim.)

It is worth considering an interesting idea, though: what if someone wrote a separate xterm configuration utility? Suppose it started out where the default would be to produce the settings that would most closely match the vanilla Gnome Terminal (or some other contemporary desktop default) experience, but show you the exact same set of knobs that xterm's modern counter part gives you (by way of its settings dialog) to tweak this behavior? And then beyond that you could fiddle with the "advanced" settings to exercise the full breadth of the sort of control that xterm gives you? Think Firefox preferences/settings/options vs. dropping down to about:config for your odd idiosyncrasy.

Since this is just an Xresources file, it would be straightforward to build this sort of frontend as an in-browser utility... (or a triple script, even).

@~8:00 one quote says:

With web articles, I think the biggest problem is that it is hard to create interactive elements in it. Some people are able to make very fancy web articles. But it takes efforts you know.

Related to ho-hoism? Or at least the Torvaldsian sentiment about not being "big and professional like gnu[sic]".

This is:

Torvalds, Linus torvalds@klaava.helsinki.fi. Reply to "What would you like to see most in minix?"; Google Groups 2005 November edition. Message-ID 1991Aug26.110602.19446@klaava.Helsinki.FI. comp.os.minix, Usenet. 1991 August 26.

Is this (self-directed/-inflicted) ho-hoism? (Maybe even a consequence of Ra?)

Huh? Hard to understand the wording here.

Traveler:

You're looking for https://txbf.org/about-us/texas-lawyers-creed/

This way of thinking should be treated with care (caution, even), lest it end up undergirding a belief in a false dichotomy.

That can be a sort of "attractive people are shallow and dumb and unattractive people are intelligent and deep"-style mindtrap.

This doesn't sound to me like they have actually been doing pair programming as I have always understood it. Neither participant needs to "engage" in those (admittedly distracting) things—least of all the person at the keyboard.

In pair programming as I have had it laid out—and not as a consequence of hearing "pair programming" and extrapolating or assuming what it involves—one person is writing the code just like when they're alone, except they're not actually controlling the computer. That's the other person's job. The first person is controlling the person who is controlling the computer. Part of the job of the second person involves shutting the fuck up and just following what the other person is saying to do. This pattern only ever breaks when the pair decides to switch places or the person dictating runs into an issue, at which point the person at the keyboard (who has been thinking all the while as an observer of what the two have been producing and is expected to know what the problem is, having already recognized the problem the first time around) should speak up. When switching roles or after reaching milestones, the two can confer about high-level concerns,immediate and distant plans to deal with things overlooked or set aside in the last round, etc.

I am aware that "two people working at a single computer" is how most people understand pair programming (and that there seems to be academic work covering the topic which lays it out in a way that contradicts what I've described here), but I regard that as wrong—for all the obvious reasons, including and especially the ones described by the commenter here...

One of them has a meeting? They both have a meeting—this one.

To put it another way: what if you received an email informing you of meeting A and then were later informed of meeting B? How would you ordinarily handle this conflict?

Being able to show up to work on time is a basic requirement for people who are, culturally, widely viewed as being not very responsible—grocery store workers, gas station attendants, etc. Being able to satisfy a similar expectation should not be difficult, then, for well-educated and well-paid folks on a regular basis.

Relative to the experience that Golang developers are used to, yes, it's a pain.

But that isn't to say it's any more or less painful on an absolute scale, esp. wrt what comprises typical experiences in other ecosystems.

Candid! I propose that this interpretation of "Modern" receive widespread recognition.

This is:

Malone, Thomas W., Keh-Chiang Yu, and Jintae Lee. 1989. “What Good Are Semistructured Objects? : Adding Semiformal Structure to Hypertext.” Working Paper. Cambridge, Mass. : Sloan School of Management, Massachusetts Institute of Technology. https://dspace.mit.edu/handle/1721.1/49393

Microdata addresses this.

Try this one: http://ccs.mit.edu/wp_toc.html

K, but the installation comes from a context that the app vendor already controls—the entire surface of their own site—so...

Even so, do what you want with your browser UI, but like... there are crazy levels of navel-gazing here.

This turn of phrase always struck me as confusing. (Still does, actually.) Maybe I lack the cultural context where "free [as in] beer" is illuminating rather than confounding. It raises questions, though—what cultural context is the one where this is a logical and widely understood sequence of words?

Complimentary beer nuts, sure, but the beer isn't free—that's why the nuts are: because they're trying to sell more beer.

When and where was "free [as in] beer" ever a thing?

This is:

Caplan, Priscilla. Support for Digital Formats. Library Technology Reports 44, 19–21 (2008). https://journals.ala.org/index.php/ltr/article/view/4227

Did Adrian White become Adrian Brown? That's what the byline in DPTP-01 actually says.

Traveler:

You are probably looking for this: https://www.nationalarchives.gov.uk/aboutapps/fileformat/pdf/automatic_format_identification.pdf

Does this mean that Drew is going to step back, then? He is after all yet another white guy himself who has few (or none) of the characteristics described, so...

The term "virtue signalling" was probably played out 5 years ago, but geez—it's hard to see this as anything except an opportunistic version of exactly that. Like greenwashing being wielded by people with ulterior motives, this seems like a straightforward case of an intellectually bankrupt attempt to conspicuously dress up one's argument in the most politically unimpeachable cause and claim that it comes from a place of wanting the best for society when ultimately a self-serving motive underlies the thing. This is very cheap and very tacky.

I'm not a vanguard for the FSF per se, but when I think about the community norms and attitudes that are most exclusionary and turn people away, it's the sort of stuff that Drew and his fans are most often associated with. Stallman at least e.g. views Emacs as something that "secretaries" can be taught. Drew's circle tends to come across as having superiority complexes and holding strong opinions about computing that stops them just short of calling you a little bitch for not being as hardcore as they are...

I didn't realize Mr. DeVault was such an admirer of NPM.

Their fault, really. What does the FSF have to do, and how much and how often do they have to do it, to make clear that this isn't their position? The culprit is right there in the sentence: the word "assume". It's not unforgivable to not be certain, but the number of people I've interacted with who insist that this is the FSF's position are exasperating.

Not Google Podcasts.

In my port of judell's slideshow tool, I made these built-ins. (They're bindings that are created in the ContentStereotype implementation.)

In that app, the stereotype body is just a return statement. Perhaps the ContentStereotype implementation should introspect on the source parameter and check if it's an expression or a statement sequence. The rule should be that iff the first character is an open param, then it's an expression—so there is no need for an explicit return, nor the escaped backtick...

This still gives the flexibility of introducing other bindings—like the ones for _CSSH_ and _CSSI_ here—but doesn't doesn't penalize people who don't need it.

I'm having trouble determining the source of this purported error. This PDF appears to have copied the content from the version published on kurzweilai.net, which includes the same "erratum". Meanwhile, however, this document which looks like it could plausibly be a scan of the original contains no such error: https://documents.theblackvault.com/documents/dod/readingroom/16a/977.pdf

I wonder if someone transcribed the memo with this "amd" error and that copy was widely distributed (e.g. during the BBS era?) and then someone came across that copy and inserted the "[sic]" adornments.

A subset of Ted Nelson's envisioned transcopyright system

wat

There's nothing implicit about it. Type annotations are explicit.

This is Olivia A. Davidson.

I have real trouble seeing that as saddening.

It isn't as if anyone is going around making the the free version arbitrarily defective. The reseller is putting in work to add value and getting paid a buck for it (literally).

It would perhaps be upsetting, too, if they were going after folks somehow. But I don't see this in the rendition above.

(In reality, a buyer would probably be fine if they took the Project Gutenberg version, bought the reseller's digitally reformatted one, extracted the TOC data and error corrections, and then slapped that onto the free version and sent it back upstream to Project Gutenberg or someone else who is distributing free copies. They would be legally in the clear, so the reseller, then, stands to make as little as $1 for their investment in that work, so in that case it seems imminently fairly priced.)

I'm not sure how this solves the problem specifically, since there will still be thousands of entries (one for each tweet) in the status/ directory...

(Unless I'm not grasping something and the problem truly is the matter of having 2^16 subdirectories in particular—without similar concerns for ordinary files.

That does raise questions about how someone would run into the original problem in the first place; vanilla ZIP has a fundamental limitation of 2^16 - 1 total files. Is Twitter using the ZIP64 extension?

Contra [1], the ZIP format was brilliantly designed and natively supports a solution to this; ZIP was conceived with the goal of operating under the constraint that an archive might need to span multiple volumes. So just use that.

1. https://games.greggman.com/game/zip-rant/

The book is: Der große Report - Die besten Internetadressen. 2000. Data Becker.

The context is 10,000 URLs, not "sites". The URL for "Wikipedia" leads to a document that is on its own not entirely interesting. It would be the URLs for individual articles that should make the cut, unless "URL" is being used as a euphemism here.

Well, they're not supposed to be ephemeral. They're supposed to be as durable as the title of whatever book you're talking about.

Need to rope this in to the delayed conversation with chubot about prehistoric ANPD thinking.

That goes against the design of URLs and also confused/annoyed me when I first landed on this blog, so...

I see this a lot—and it seems like it's a lot more prevalent than it used to be—reasoning from a proxy. Like trying to suss out how competent someone is in your shared field by looking at their GitHub profile, instead just asking them questions about it (e.g. the JVM). If X is the thing you want to know about, then don't look at Y and draw conclusions that way. (See also: the X/Y problem.) There's no need to approach things in a roundabout, inefficient, error-prone manner, so don't bother trying unless you have to.

C'mon. It's right there:

Follow the instructions given in the WebGL specifications' Context Creation sections to obtain a WebGLRenderingContext, WebGL2RenderingContext, or null; if the returned value is null, then return null;

(Not that it should even be necessary to resort to checking the spec—relying on an assumption of a non-null return value here should raise the commonsense suspicions of anyone.)

I agree that this approach is bad. I hate that this exists. The differences between doctype-triggered standards and quirks mode was bad enough. This is so much worse—and impacts you even when you're in ostensible standards mode.

Huh? Why? Why even waste the time? Just go fix your code.

"... you keep using that word"

I don't think that has been shown here? The zip.js stuff breaking is one thing, but the poor error detection regarding off-screen canvas doesn't ipso facto look like part of a larger pattern.

Answer: because they care about Web compatibility. If they delay X because Y is not ready, then that's ΔT where their browser remains incompatible with the rest of the world, even though it doesn't have to be.

This is a huge reach.

Although it's debatable whether having mismatched support is a good idea for a vendor, arguing that it breaks the commitment to compatibility is off. Construct broke not because something was removed, but because something was added and your code did not handle that well.

Two things: * Why would it have mentioned anything? It wouldn't have. It hadn't shipped yet. * MDN is not prescriptive; it's written by volunteers

The second = sign is completely superfluous here. Only one is necessary.

Well, the biggest problem is that anything can ever lead to a blank screen because Construct isn't doing simple error detection.

This is why I don't get people who bristle at the thought of writing a cover letter. What the fuck. Just write a paragraph or two saying why you want this job, specifically—why you think you'll find it rewarding and how it fits with your professional interests. Is it that hard? I'll take this a thousand times over vs pruning, rearranging, and emphasizing line-item crap from my employment history, awards I was given 20 years ago, etc.

We should be starting with the cover letter and handing that over to someone who's competent to review it (not a generic, know-nothing human pattern matcher) and then move on to hardcore testing for aptitude in a testing environment that matches as closely as possible the actual work environment where you're going to be expected to get things done on a day-to-day basis.

Why not? Do it. It is literally their job.

The alternative: "smart" resumes that are something like contact cards plus an agreement from employers to put way less stock into resumes and less organizational infrastructure towards keeping classic HR droid positions filled with people that ultimately themselves don't do very much for the company.

So from the applicant's perspective, you don't worry about creating a resume for this job. It feels more like handing out a business card with your contact info to someone who needs it, except in this case instead of it being contact info (or rather, in addition to the contact info), it contains other stuff, too.

Ugh.

Surely that's meant to say "GB"?

WTF

It might "help" but it defeats the entire purpose of the recordkeeping endeavor.

If you don't care about the recordkeeping aspect and are just using Git to sync stuff between machines, then you're not really using Git and should stop trying to use it and use something else. (A better option, of course, is to think about it long enough to understand why recordkeeping is good and then take the time to write commit messages that don't suck and not treat it as an arbitrary and pointless hurdle. It's not pointless; there's a reason it was put there, after all.)

This is why git add is git add. The students should have been told not to add anything to the repo except for the source files they're actually changing. A good rule of thumb: if the change was made by a human, and the human was you, then you can commit it; if the change was made by a machine, then don't.

This is only a problem if they were doing git config --global. Considering these were shared machines, then they shouldn't have been.

Except, of course, branching and merging mean that this hurdle isn't a necessary one. Git was designed from the beginning so that this would be a non-issue (or at least not as bad as what this class experienced); that's where the D in DVCS comes from, after all...

(And I thought that's where this was going—! Rather than just giving people the solution—in this case branches/remotes—and telling them to use it, then what you do is you let them experience the problem firsthand and then can appreciate the solution and why it's there. Really surprised that's not where this ended up.)

I had a fever dream* in 2020 or 2021 that involved an epiphany for a clear way to integrate Git's data model into mass market computing systems (a la Mac OS and its Finder) in a way that was digestible to normal people. I've basically forgotten it. I think it was something like:

1. use heuristics to figure out when someone is using the "[...]_draft", "[...]_final", etc, ad hoc versioning antipattern
2. offer to make the directory a versioned one

On systems like Mac OS where everything is tightly integrated, you wouldn't need to limit yourself to offering this in the Finder. Any time someone used the system-wide standard file save dialog in a way that exhibits the thing described in #1, the system could use the desktop notification subsystem to get the user's attention and offer to upgrade their experience. No interaction with the Git porcelain (as we know it) necessary.

I fear that MS might do this first but bungle it (i.e. unthoughtfully) and also promote/upsell GitHub to you during the ride.

* not really

It looks like it's this one: Itty Bitty Computing Machine http://aaronbloomfield.me/docs/sigcse-2011-p371.pdf

doi:10.1145/1953163.1953273

Nice use of w3doc.css. Looks good!

Yes, of course. That's another intentional feature.

Well, since you don't want to support it, then you aren't required to do that. (And good thing, because that would limit the format severely.)

It means you don't need to! (And why would you try? You have already found one, and you know there is only one, so to try to find more is to try to do something that you know is impossible.)

It means if you have a ZIP file (something that you know is a valid ZIP file) and you have found more than one end of central directory record, then there's something wrong with the method you used to find them (because there can by definition be only one).

Okay, fine. Don't use them (don't use broken software, generally—unless you're comfortable getting broken results).

I don't take the spec to mean that you can reliably stream any arbitrary ZIP bytestream. If you are the producer and the consumer, though, then you can bend the format to your will to enable streaming.

See Firefox's JAR handling for an example.

Justine Tunney covers the genius of the ZIP format in her Redbean talk (@55:31) https://youtu.be/1ZTRb-2DZGs?t=3331

See also: the brokenness of most schemes to cross-compile applications (including producing cross compilers).

Rob's clear thinking here definitely had an influence on why Go's compiler is one of the few to have a sane cross-compilation story.

This is:

S. Mirhosseini and C. Parnin. “Docable: Evaluating the Executability of Software Tutorials”. 2020. https://chrisparnin.me/pdf/docable_FSE_20.pdf

See Hinsen, "software rot".

This is the second time this appears in this paper.

Previously: https://hypothes.is/a/Mm9whNQFEe2J6Y97btVQBQ

The ambiguity (i.e. non-machine-readability) of tutorials described in this paper is a good example to demonstrate both what it means for something to be an algorithm and what it means to "code" something.

You're looking for https://news.ycombinator.com/newswelcome.html

Isn't that pretty interesting? You'd think it would be the other way around.

In fact, what if it is the other way around? What if the failure of classic/legacy Web feeds has to do with power users' insistence on calling it "RSS"?

What? That's an insane comparison. This is like the total opposite of that comment; ActivityPub is super complicated.

This is bad protocol design. It violates (a variation of) the argument for the Principle of Least Power.

Also not to be confused with the notion from the area of information theory of Kolmogorov complexity. (At least not directly—but that isn't to say there is no relation there.)

Pretty nuts that Safari isn't open source. I thought for sure that Edge was going to be fully open source, both before and after the Blink conversion. Why even build closed source browsers in 2023?