my advice is very much focused on "working for ambitious technology companies"
Good start at an ontology for different kinds of work? Samsung Austin Semiconductor, for example, does not fall within the class that Simon calls "ambitious technology companies", despite nominally being a "tech" company and ostensibly "ambitious".
This post presumes that a given candidate is looking for career in show business. There's no good reason to make that logical leap.
Bank managers (or HR folks at tech companies for that matter..) don't seem to be getting told to curate the equivalent of a GitHub profile. (LinkedIn notwithstanding—Microsoft, stop trying to make "fetch" happen.) Why should a software engineer?
This is so weird; why isn't the Etherpad project wiki an Etherpad instance?
This is:
Wright, Alex. Cataloging the World: Paul Otlet and the Birth of the Information Age. New York, NY: Oxford University Press, 2014.
the conference ultimately resulted in a series of platitudinous proclamations (as conferences tend to do)
Nice turn of phrase—"platitudinous proclamations" (p. 88)
pulling some code that could be inline into a function allows someone to more easily replace that function
There are shades of OO ideology in this, unintentionally.
As anyone familiar with software development knows, the difficulty of adding new features or modifying existing ones grows very quickly, much faster than linearly, with the total number of features. They interfere with one another. By reducing the number of shipped features, we reduce the difficulty of modification. Anybody can do it (or have somebody do it for them).The more users we try to appease out of the box, the harder things become for those we haven’t served yet. A more rigorous analysis would attempt to model costs and benefits, do the math, etc. I’ll leave it at noting that the combination of the 80/20 rule and superlinear complexity growth means we probably aren’t amortizing as much effort as we would hope by adding every feature to a single code base.
Simple but non-obvious truth.
“It’s just not [sic] gonna work.”
I'm confused about the use of "[sic]" here.
a reusable component costs 3 to 5 times as much as a good module. The extra money pays for: · Generality: A reusable module must meet the needs of a fairly wide range of ‘foreign’ clients, not just of people working on the same project. Figuring out what those needs are is hard, and designing an implementation that can meet them efficiently enough is often hard as well. · Simplicity: Foreign clients must be able to understand the interface to a module fairly easily, or it’s no use to them. If it only needs to work in a single system, a complicated interface is all right, because the client has much more context. · Customization: To make the module general enough, it probably must be customizable, either with some well-chosen parameters or with some kind of programmability, which often takes the form of a special-purpose programming language. · Testing: Foreign clients have higher expectations for the quality of a module, and they use it in more different ways. The generality and customization must be tested as well. · Documentation: Foreign clients need more documentation, since they can’t come over to your office. · Stability: Foreign clients are not tied to the release cycle of a system. For them, a module’s behaviour must remain unchanged (or upward compatible) for years, probably for the lifetime of their system. Regardless of whether a reusable component is a good investment, it’s nearly impossible to fund this kind of development.
a reusable component costs 3 to 5 times as much as a good module. The extra money pays for: Generality[...] Simplicity[...] Customization[...] Testing[...] Documentation[...] Stability[...] ¶ Regardless of whether a reusable component is a good investment, it’s nearly impossible to fund this kind of development.
Sure but if the job listings are saying “College Degree in something” applicants without a degree are likely to get rejected well before interviews because it is an easy filter for HR.
Why do we never try to address how obviously inadequate most who are hired into HR are? Filter those.
tech’s focus on prioritizing output over credentials
Is this even real? It feels to me, as someone outside the Bay Area, like something that is either a result of Bay Area parochialism (for lack of a better word) or a mistake: tech does prioritize "credentials"—they're just credentials in the form of résumé-driven data points related to tech stacks (e.g. React, Kubernetes, Docker...) and employment history, rather than academic credentials.
Crow and Dabars explain that most universities aspire towards offering a Michelin star experience to students, but what we actually need is a ‘fast casual’, Cheesecake Factory-like option that can provide an affordable, quality education to millions
I'm conflicted by this analogy, because I think that in a certain sense a fast-casual Cheesecake Factory for degrees is exactly what universities have turned themselves into. NB: that's "for degrees", not for "quality education" as nayafia relates here.
that does a disservice to what tech culture increasingly stands for today: a beacon for people who care about finding and spreading great ideas
Is this what the tech world achieves in practice?
you might remember ASU’s reputation as a party school for hot people. In 2002, Crow was appointed ASU’s 16th president, and he set about both developing and implementing a vision for reform. Today, ASU ranks as a top 100 research university worldwide [1], and has managed to do so while increasing affordable access to higher education. ASU is an example of what President Crow and his colleague, William Dabars, call the “New American University”, a model that they hope other public research universities will emulate. There are a bunch of interesting aspects to this model, but the most striking, in my view, has been to throw away the Ivy League playbook, rejecting the idea that a university’s prestige is defined by whom they exclude. Instead, ASU has significantly improved their rankings while accepting and graduating more students. Given the widespread critique of academia, especially within tech, I was surprised that, after asking around, none of my peers had come across ASU as a case study for reform, despite its reputation among university administrators. So I’m summarizing what I’ve learned about ASU here in hopes that it might help others learn
This raises an (un?)interesting issue: if ASU's ranking improves, but its reputation does not—because the news never reaches those who have internalized its status as a party school—what then? You can imagine someone returning to school now, picking ASU, and then showing up to a job interview or landing within a pool of coworkers or an after-work social event where attendance is dominated by B players who remain uninformed. It's not hard to imagine someone "losing" so many arguments on the basis that that person went to ASU, ASU is for dumb people, and ipso facto they are wrong.
So exclusion is the answer: we should seek to exclude the types of people for whom this strain of intellectually lazy argument is an attractive weapon, and ideally also exclude those who respond positively to its use.
This is not a well-written blog post.
(That isn't to say it contains no insights or that the insights are not true. Only that it is not well-written.)
a paper called the Open Data Model in 1998
Myers, Brad A. “The Case for an Open Data Model,” August 1998. http://reports-archive.adm.cs.cmu.edu/anon/1998/CMU-CS-98-153.pdf
If you look at your home, did you hire an interior designer to put everything in the right place in your house? Some people do but most people don't.
Important to note that what's also left out of this picture of software design being left up to designers is the staggering amount of software with positively bad UI and UX that people have forced on them all day in the form of e.g. awful enterprise software. The notion that the masses somehow need designers' (proper designers) involvement in software is just flatly contradicted by reality.
And on that note there's also the matter of choice—if you were to hire a designer who did something you didn't like, you'd get rid of them. Among all the software that people interact with every day, whether it's terrible enterprise junk or an iOS app designed with a self-anointed designer, there isn't one in which the user actually hired anyone to do the UI. The publisher/whomever just makes the thing and says, essentially, "here you go; take it or leave". That's what's really on offer in the world made too favorable to designers and not malleable enough to users.
go sample from A gallery of interesting Jupyter Notebooks. Pick five. Try to run them. Try to install the stuff needed to run them. Weep in despair.
throwing the JavaScript world into temporary insanity
No. Throwing the NPM world into insanity. The author of the Guardian article got this right. (The slug is literally npm_left_pad_chaos.) There's no excuse for this sort of equivocation.
Of all the stuff in the world, JS is the one thing that's closest to having the robustness values desired in this blog post. TC-39's motto is literally "Don't break the Web".
our systems do not really support reproducibility, mostly due to software collapse issues as defined by Hinsen
So stop building within those systems (i.e. on crummy foundations).
The bedrock choice is possible, as demonstrated by the military and NASA, but it also dramatically limits innovation, so it’s probably not appropriate for research projects
I think this is too curt of a dismissal. The browser environment, while not suitable for computationally expensive, long-run experiments, is certainly adequate for a great many things that could be "solved" by targeting it, even though they currently are not. Things like converting a simple assembly listing into a 512-byte program.
(Compare: https://www.colbyrussell.com/LP/debut/plain.txt.htm.)
our culture and our institutions do not reward reproducibility
This is a real problem/the real problem.
Unless all systems are to collect their own data directly from eachcitizen (an appalling prospect),
This is an interesting remark from the vantage point of 50 years in the future.
I tried writing a serious-looking research paper about the bug and my proposed fix, but I lost a series of pitched battles against Pytorch and biblatex
you start by (for example) importing Tomcat
Worth pointing out that this (Tomcat) comprises a component in and of itself. It is because this component was available that this step can be dashed off as "[just] importing Tomcat"—rather than "write a program that binds to port 80 and returns a 404 for any resource requested".
It costs be-tween ½ and 2 times as much to build amodule with a clean interface that iswell-designed for your system as to justwrite some code
I believe it, but I would have liked to have seen a reference for this claim.
For the most part, component libraries have been a failure, in spite of muchtalk and a number of attempts.
It would be nice to hear a 20-year retrospective from Lampson on this, in light of the creation and rise of e.g. npm and other npm-like "language package managers". (He doesn't really acknowledge this in his 2020 omnibus report Hints and Principles for Computer System Design.)
only a small fraction of the features of each component, and your program con-sumes 10 or 100 times the hardware resources of a fully custom program, butyou write 10% or 1% of the code you would have written 30 years ago.
You use only a small fraction of the features of each component, and your program consumes 10 or 100 times the hardware resources of a fully custom program, but you write 10% or 1% of the code you would have written 30 years ago.
This is:
Lampson, Butler W. “Software Components: Only the Giants Survive.” In Computer Systems: Theory, Technology, and Applications, edited by Andrew Herbert and Karen Spärck Jones, 137–45. Monographs in Computer Science. New York, NY: Springer, 2004. <doi:10.1007/0-387-21821-1_21>.
Broadly speaking, there are two kinds of software, precise and approximate, with the contrastinggoals “Get it right” and “Get it soon and make it cool.”
A different take on the "pick two" quip ({on time, within budget, bug-free})
This is:
Lampson, Butler. “Hints and Principles for Computer System Design,” November 2020. https://www.microsoft.com/en-us/research/publication/hints-and-principles-for-computer-system-design-3/.
The trend here wouldn't be so bad if, in practice, public libraries didn't become such hostile environments for the two classic use cases for libraries—that is, "places to: a) read quietly; b) study". It's unfortunate, then, that they have (at least in my experience).
We need to legally regulate remote attestation.
Hear, hear! This is a great response to anyone calling for regulation aligned with Google's Web Environment Integrity proposal (and similar forms of DRM): "Regulation? Okay, let's regulate you—so you cannot do this thing you're trying for."
It's like how copyleft was invented to allow the GPL to use copyright to work against the prurient interests of those normally wielding it.
Google's new effort to DRM the web
Very concerning. "DRM the Web" is a very apt descriptor for what's at the end of that link. I seem to have missed the news.
It really looks like this isn't related to libxml2's strlen implementation but that you're hitting a quadratic performance problem caused by naive string concatenation.
Yes, it does look like that, which is a little frustrating/baffling already, but the bug is "xmlStrlen is 2–30 times solwer than glibc strlen". That's a well-defined issue. Respond to that, not the context (which is out of scope). The bug is not, "help us speed up our application".
The Web needs to be stud-ied and understood as a phenomenonbut also as something to be engineeredfor future growth and capabilities.
I'd rather we focus for now on maximizing it to its current potential as a more convenient digital equivalent for pre-Web physical resources. Just getting people to embrace URLs—truly embrace them—is a big enough task itself. It's been 30+ years, and not even Web professionals and other (ostensibly smart) people on the periphery (e.g. techies) reliably get this stuff right. Indeed, they're often the biggest offenders...
However, in many ofthese courses, the Web itself is treat-ed as a specific instantiation of moregeneral principals. In other cases, theWeb is treated primarily as a dynamiccontent mechanism that supports thesocial interactions among multiplebrowser users. Whether in CS studiesor in information-school courses, theWeb is often studied exclusively as thedelivery vehicle for content, technicalor social, rather than as an object ofstudy in its own right.
I'd argue that this is a good thing. I think the tech industry's navelgazing does perhaps some of the worst harm wrt the problems articulated earlier.
f you look at CS cur-ricula in most universities worldwideyou will find “Web design” is taught asa service course, along with, perhaps,a course on Web scripting languages.You are unlikely to find a course thatteaches Web architecture or protocols
Pretty fucked up, actually! It's true. And it's probably why software engineers (incl. e.g. CACM folks...) do such a poor job of managing their digital document depositories and generally fulfilling the potential of the Web as it was meant to be.
This is:
Hendler, James, Nigel Shadbolt, Wendy Hall, Tim Berners-Lee, and Daniel Weitzner. “Web Science: An Interdisciplinary Approach to Understanding the Web.” Communications of the ACM 51, no. 7 (July 1, 2008): 60–69. https://doi.org/10.1145/1364782.1364798.
Amazon.com, for example, grew into a huge online bookstore, then music store, then store for all kinds of goods because it had open, free access to the technical standards on which the Web operates. Amazon, like any other Web user, could use HTML, URI and HTTP without asking anyone’s permission and without having to pay.
Amazon doesn't, however, as TBL has already noted, make its A/V media available as first-class Web resources. (What's the URL for a recent blockbuster available for streaming through Amazon's Prime Video program?)
I originally called the naming scheme URI, for universal resource identifier
It was really "UDI" (Universal Document Identifier) even before that. See:
Berners-Lee, Tim, Jean-François Groff, and Robert Cailliau. “Universal Document Identifiers on the Network,” 1992.
Yet people seem to think the Web is some sort of piece of nature, and if it starts to wither, well, that’s just one of those unfortunate things we can’t help.
Also: computing generally.
my thesis on the form of the web browser and its social effects
This one:
Marco, Matthew Tangco. “The Form of the Web Browser and Its Social Effects.” PhD Thesis, Georgetown University, 2011. http://hdl.handle.net/10822/552929
Not to be confused with https://www.w3.org/History/1989/proposal.html
These indexes are maintained using existing FIND* software.
See also: https://www.w3.org/History/1990/WWW/FIND/Hyperizing_FIND.wn/
Sorry, Insufficient Access Privileges
Traveller:
You may benefit from this link, instead https://www.w3.org/History/1991/HTRejected.wn/WNDocument.wn
(Not sure if it's actually the same as what's supposed to be available here.)
It appears to be a "MacWrite II document" according to http://mark0.net/onlinetrid.aspx
Note that as of this writing, the site at that link now identifies the same file as "Word for the Macintosh document (v4.0)". I think the MacWrite II diagnosis is more plausible. No idea what changed.
Also, for those who for some reason prefer curly brackets over Python-style indenting, it is also possible to write:
Good and sensible.
This could* pretty trivially be converted into a triple script.
* and should be
it's like all right someone built an app that's pretty cool now let me go set up my ide let me go download all these packages what's the stack they're using
A good(?) case study in why these "papers" should be... papers (and not six-pagers* with directories of source code that exist "over there").
cf https://www.colbyrussell.com/LP/debut/
* 19 in this case
Chris (incl. his intuition) isn't wrong—static sites really do exist and are special. Consider: - files "served" from the local filesystem, i.e. what you get if you access a collection of resources saved to disk and opened in your browser - how much can be captured by a crawler (e.g. Wayback Machine) - bounded limits of computation: serving an HTML artifact (or some other static resource) is guaranteed to terminate
This would probably be less of an issue making Hugo config changes was something I did more than a couple of times per year.
See also:
So, time to update the website, but the first wall I hit was that I:
- Forgot how my over-engineered SaaS was supposed to be used (no documentation because I built it myself and was lazy)
- Forgot how to follow the esoteric Hugo conventions (has documentation, but it's not easy to parse at a glance)
I was pretty annoyed with myself for having fallen for the trap of not documenting my own systems, but not sure how I could have remembered all of the Hugo-isms, especially since I don't update this site very often and don't do static site generator work outside of this.
https://web.archive.org/web/20210331182731/https://corytheboyd.com/posts/2020-03-09
(Previously: https://hypothes.is/a/U742AodQEeu5T2dEN4YdWQ)
Browser-based interfaces are slow, clumsy, and require you to be online just to use them
Nope (re: offline). You're confusing "browser-based" and "Web-based" (sort of the way people confuse statically typed" versus strongly typed*). They're different. You can have a fully offline browser-based interface. Most common browsers are every bit as amenable as being used as simple document viewers as Preview.app or Microsoft Word is. The browser's native file format is just a different sort—not DOCX, and not PDF (although lots of browsers can do PDF, too; you can't write apps in PDF, though—at least not in the subset supported by typical browsers). Instead of Office macros written in VBA, browsers support scripting offline documents in JS just like online documents. You can run your offline programs using the browser runtime, unless they're written to expect otherwise.
This is:
Wang, April Yi, Andrew Head, Ashley Ge Zhang, Steve Oney, and Christopher Brooks. “Colaroid: A Literate Programming Approach for Authoring Explorable Multi-Stage Tutorials.” In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems, 1–22. Hamburg Germany: ACM, 2023. https://doi.org/10.1145/3544548.3581525.
the order in which tutorial authors may want to explaintheir code often does not match the order of the code itself
This is an error/defect on the part of the author.
notebook-like interface
Colaroid’s unique ap-proach to literate programming is to bring together the rich textediting affordances of notebooks together with automated creationof contextualized code snippets showing code differences, and closeintegration of the literate document into an IDE where code can betinkered with.
This misses the point of LP—the true "fundamental theorem of LP" is basically that the compiler should be made to accept the preferred form.
their are a few configurations
Should be "there"
"<a href="http://vorlonjs.com/documentation/""
404 Web Site not found.
The server isn't redirecting requests at the apex domain to www..
"Fixing" the RSS-vs-Atom problem: brand Atom as "RSS3" (sexy)—and make sure there are accommodations (read: plenty of RFC 2119-style MUSTs, MUST NOTs, etc) for podcasts while you're at it.
Set up the Standard Ebooks toolset
The "Standard Ebooks toolset" should just be... an ebook. That your browser can execute. (Because it's a ubiquitous runtime target that requires no setup...)
JavaScript developers tell me that disk space and network bandwidth are cheap these days. While they're mostly saying that to try and justify extremely bad architectural decisions (what's a couple thousand NPM dependencies between friends?)
Question: what even is the "NPM hypothesis"? I.e. what is the value proposition, stated in the form of a falsifiable claim?
cranies
Should be "crannies"
What if console services (i.e. services offered by the system software for hardware game consoles) offered an asset cache?
NEWS 2023-06-21: The GMP servers has been under serious load due to a barrage of clone requests from Microsoft/Github. Github's setup encourages "forks" of their projects, and such forks then by default pull in parent project changes. Around 2023-06-15, a project known as FFmpeg decided that it would be a great idea to clone GMP in their CI scripts, meaning that every one of their commits requested a compressed clone from the GMP servers. But, by Github's design, hundreds of FFmpeg forks automatically followed suit, themselves cloning the GMP repo. In effect, Microsoft's computer cloud performed a DDoS attack on the GMP servers. After bringing up the issue here and on the GMP mailing lists, some Github brass replied, minimizing the issue and blaming our servers for the denial-of-service attack. They did not do anything to stop the attack! In fact, it is still ongoing a week later. Our servers are fully available again, but that's the result of us adding all participating Microsoft network ranges to our firewall. We understand that we are far from the first project to take such measures against Github.
Notice the total lack of addressability of this piece of content (in re the submission "The GMP library's repository is under attack by a single GitHub user" at <https://news.ycombinator.com/item?id=36380325>)
picolog.blue is missing
I started to learn PHP. I am very happy with the language so far. I enjoy a lot how easy it is to deploy and update a page. If I want to update the text on a page, I can just edit the file, save it, and that's it. If I want to push the latest version of a site, I just copy the files to the server.
... because the server is configured like that.
(This is not a property of the language.)
In dynamic languages you can write programs that take programs and output other programs
Dynamic languages are not a prerequisite to this.
Good example of how when people are talking about a thing, they're often not really talking about it—they're saying something about themselves, their environment, how they do things, etc.
See also xkcd 1172: Workflow
only
This looks to be imagined.
The problem is that the Copyright Office, under color of authority ostensibly assigned to it by statute, requires libraries to misinform patrons about their rights.
This is the basis of the article. It would be nice if, in all the words here, it were actually substantiated.
why is a library required tell you otherwise? Why must libraries actively misinform their patrons about their actual rights under the law?
Okay, now this is the problem statement(s). I don't see that the notice is doing these things (telling someone otherwise or "actively misinform[ing] their patrons"). It looks like it's totally in step with what is actually true.
is it really the case that when you make a copy of an in-copyright document at Kinko’s, you have the full spectrum of fair use rights – but if you copy (or receive a copy of) the same document in a library your fair use rights are significantly more restricted?
Who—outside of this article—is saying anything like that?
the notice that libraries are required by law to provide you
I missed the part where the writer established that this was the case. What law are they referring to?
And if you’re someone who is fairly familiar with U.S. copyright law, and especially with the fair use doctrine, that notice may have led you to ask yourself the following question: “Why are my rights more constrained with regard to a copy made in the library than they would be if the copy were made anywhere else?”
wat
I always wonder how infinite money would upend my system of values.
You upend your values before attaining the near-infinite money (in order to attain it).
A detailed description in html format is included in the Tutorial directory.
This is exemplary and deserves to be more fashionable than it is in 2023.
Disroot: Requires nonfree JS to sign up
Remember: forms are just forms.
If they don't provide a form that is sufficiently "inert", then anyone (including FSF) can create their own.
Which of these two messages do you think is more effective? ChatGPT will lie to you Or ChatGPT doesn’t lie, lying is too human and implies intent. It hallucinates. Actually no, hallucination still implies human-like thought. It confabulates. That’s a term used in psychiatry to describe when someone replaces a gap in one’s memory by a falsification that one believes to be true—though of course these things don’t have human minds so even confabulation is unnecessarily anthropomorphic. I hope you’ve enjoyed this linguistic detour!
"ChatGPT will say things that aren't true" seems perfectly adequate. I don't understand why this dumb debate—over the definition of the word lie—is even happening (to the extent, if any, that it actually is...)
Every time this is mentioned, the person is heavily downvoted.But if you were here in the 2000, that's exactly what happened.
Not even close.
JS succeeded because it was well-designed, period. There were many, many contenders in the early days—despite popular historical revisionism to the contrary. All of them failures.
This is:
Hilse, Hans-Werner, and Jochen Kothe. Implementing Persistent Identifiers: Overview of Concepts, Guidelines and Recommendations. London: Consortium of European Research Libraries, 2006.
It would be even worse if no such error message appeared: a URL may also be
It would be even worse if no such error message appeared: a URL may also be unstable in that it now points to a different resource that has replaced the earlier one.
Since this is yet another piece of journalism that covers a set of cases before the courts with citing the cases in question by name, here they are: - Students for Fair Admissions v. Harvard - Students for Fair Admissions v. University of North Carolina
Seth pointed out this is useful if you are on Windows and don't have the gzip utility installed.
Language runtimes that don't ship by default on Windows have historically been harder to install than utilities like gzip in my experience.
I question whether lawyers should be looking for new technology, as opposed to learning how to use more effectively the technology already available to them.
You can swap "lawyers" here for just about anyone—including (or "especially"?) software developers.
I don't want "new". I want established, reliable, with plenty of support, plenty of good documentation. (Okay, so I also want Free/open source, and self-hostable, but I appreciate that I'm probably a significant outlier here.) "New" is a con, not a pro.
See also: cars.
The scoping of the this keyword
My last comment here, the this hate, along with the fetishization of === over ==, is one of the most overblown aspects (and arguably: outright just incorrect stances) about language design when it comes to JS.
different versions in different browsers and will never be upgraded
This has nothing to do with JS. It's not a language-level concern; the same would be true with any other language. Python, Ruby, Scheme, C#... pick literally any other language. It's a totally orthogonal issue.
JeagerMonkey, TraceMonkey
Weird. TraceMonkey and JagerMonkey are just codenames for different approaches for fast execution/evaluation of JS in SpiderMonkey. They're not holistic JS language implementations unto themselves in the vein of, say, CPython vs IronPython.
Fragmented runtimes While pretty much every single one of these problems could be fixed by either extending the specific runtime you’re using or by ECMA releasing a new standard, it’s just not that simple. Assuming you extend the runtime you’re using to allow for things like native/fast arrays and you define a module/namespace solution like node.js has done, now any code you write will only run on that specific runtime with your extensions which punches a big hole in the “same language everywhere”-argument that you hear every day on twitter (and it really is server-side JavaScript’s only claim to fame).
In other words, the "problem" is the opposite of "fragmented runtimes"—it's that JS runtimes are so strictly committed to compatibility at the language level (to a degree not seen in any other widely deployed tech that I can think of). There are clear downsides (such as the sentiment expressed here), but there are also massive upsides. On net, the alignment is a huge win.
In case you didn’t know, these two functions are not identical: Advertisementhttp://wtfjs.com/ 12(function bar() { })function foo() { }
This is true, but also pretty huge non-issue. The only way it could possibly be an issue is for someone who just objects to the notion of function-valued expressions generally (fans of Pascal, maybe? I dunno) or someone who against all good sense believes that a pair of parens should result in the introduction of a new scope (weird).
why would you even have two different types of ‘nil’ to begin with?
You already know why: the semipredicate problem. (In other words, for a similar reason why you might want a number type to be nullable even though you already have 0.)
Being able to concatenate two comma-seperated strings without a comma in the middle is such a common use case. I'm glad the JS develpoers thought to optimise for the most common use case.
This criticism is not just ignorant. It's stupid.
A passive failure to make a special case ("optimise") for array operands in binary expressions with + is not the same thing as actively optimizing for "two comma-seperated[sic] strings without a comma in the middle".
the web is always stuck in thepresent
Mmm... no. It often is—to the world's peril—but it's not the architecture that makes this so. It is a choice of node operators to return some resource X when a given identifier is referenced on day d[0] and to return resource Y on day d[1].
linking to the site virtually impossible
On the contrary. It is the lack of stability that makes (reliably) linking virtually impossible. How do stable links make linking more difficult...?
daily newssites, will generate many new resources
They already are.
The former option will preserve all content,but will leadto an explosion of new resources, eachwith its own distinct identi®er.
It doesn't. It leads to no more (or fewer) resources than otherwise. It does lead to an "explosion" of identifiers.
Think about the silliness of casting aspersion on the notion of "[many] resources, each with its own distinct identifier". The fundamental premise of the Web is that this is a good thing; if you have a slew of resources, you should be able to (unambiguously) refer to them by identifier.
Referential integrity can en-sure that links always reference the same resource,but what happens if the content containedwithinthe resource changes?
Response: the question is malformed. The problem lies in the belief that it's possible for content to change. It can't. If it appears to, then it is only because the server is returning a different resource than whatever was previously available. Don't reuse identifiers for different resources. Mint a new identifier.
This is:
Evans, M.P., and S.M. Furnell. “The Resource Locator Service: Fixing a Flaw in the Web.” Computer Networks 37, no. 3–4 (November 2001): 307–30. https://doi.org/10.1016/S1389-1286(01)00204-3.
Lost history ± the web is designed for society,but crucially it neglects one key area: its history.Information on the web is today's information.Yesterday's information is deleted or overwrit-ten
It's my contention that this is a matter of people misusing the URL (and the Web, generally); Web pages should not be expected to "update" any more than you expect the pages of a book or magazine or a journal article to be self-updating.
We have taken the original vision of the Web -- an elaborately cross-referenced information space whose references can be mechanically dereferenced -- and rather than treating the material as imbued with a more convenient digital access method and keeping in place the well-understood practices surrounding printed copies, we compromised the entire project by treating it as a sui generis medium. This was a huge mistake.
This can be solved by re-centering our conception of what URLs really are: citations. The resources on the other sides of a list of citations should not change. To the extent that anything ever does appear to change, it happens in the form of new editions. When new editions come out, nobody goes around snapping up the old copies and replacing it for no charge with the most recent one while holding the older copies hostage for a price (or completely inaccessible no matter the price).
pointing at the correct IP address, but having the server not recognize the Host header
not an example of something gone wrong with DNS
They use canonical text. The metadata of the note is embedded in the content of the note, meaning things like tags and links have to be extracted out. But they’re structured data and should be modeled as distinct from the content. I’d want my notetaking app to use a relational database, not a bag of textfiles.
I don't understand this criticism at all.
There are a lot of papers cited in this presentation that aren't cited explicitly and in detail in the associated "transcript": https://web.archive.org/web/19980215203333/http://www.parc.xerox.com/spl/projects/oi/towards-talk/transcript.html
(E.g. Wirth "On the Design of Programming Languages" @25:00.)
It would be nice/useful to go through the video, grab the moments where these are referenced (incl. screenshots of the slides), and collect them into an orderly works cited rider doc.
Hey, traveler. Try this instead:
Not sure why this is detached from the thread it belongs to, but it appears to be this one:
nobody can even tell what skills will be needed in the job market a few decades into the future
By a reasonable guess, no matter what the actual (vs stated) requirements are, they'll be overstated.
and people can work only so many hours a day (and many prefer to work less if they can)
Do they? (This is almost certainly a coordination problem, right?)
Current American foundations for the most part are not really geared up to be supporting or encouraging 13- to 19-year-olds. That is where a lot of the low-hanging fruit is.
the best policy for science is just more immigration into the United States. High skilled maybe, but just flat out more immigration.
Isn't that just drawing from another exhaustible resource? Think end game. Don't we converge on an equilibrium where we are no longer able to exploit the outsized gains?
Of course, the personal computer and its cousin, the smartphone, have brought about some big changes. And many goods and services are now more plentiful and of better quality. But compared with what my grandmother witnessed, the basic accoutrements of life have remained broadly the same.
Related: see the "web of documents" tag on Hypothesis.
you can inspect as source and learn something or understand how it is constructed
Again: we're way past that—and it's not broadly accessible simulated word processors that got us there. (It's actually Web developers themselves.)
an increasing abandonment of creating web content as the kind of web content I know and love
I think that's a good thing, for the reasons described here: https://hypothes.is/a/TF6N6AxHEe6qM_dG0VlZzw. We should stop treating the Web as a sui generis medium and elevate it to the same status as material that appears as written word made for print.
I thought I had more.
I don't even think that these arguments are that compelling. In the first place, URLs are explicitly stated to be unreliable indicators of content—they are opaque. https://hey.look.a.verylegit.link/filehost392index-ip-stealer!.xlsx.docm.exe is as valid a URL as any PURL, or the URL to this very blog post.
Most of the other points come across like more application of the double standard.
Yet, the creation of doc hosted web pages rings of “being on the web but not of the web” (Have you ever done view source on a Google doc?, can you really grasp the content and meaning it’s un-HTML a melange of JavaScript?).
We're past this, though, even in the world of "proper" Web development. Look at anything you consider to be "of" the Web. Take this blog post as an example. There's a double standard at play, considering that if you peer at the page source, it's by and large worse than the sort of thing that you'd have gotten out of Frontpage, Dreamweaver, etc. 20 years ago. And this isn't even an SPA or other Google Docs-like creation of the sort that this post focuses on.
Anything radical published on Google Docs is published in spite of Google Docs.
I think the key here is "[...] published on Google Docs". Consider instead: "Something radical can be prepared with Google Docs". There's nothing stopping anyone from using Google Docs in the same way that traditional desktop word processors are used—by working on your stuff and then saving a copy to your own disk (using Google Docs's "File" menu). Pick your own format—DOCX, ODT, etc., but note that HTML mostly works quite well...
In fact, it being on your own disk is beside the point; you can put the thing anywhere—it doesn't have to stay "on" (read: in) Google Docs. Put it online if you want. (I refer again to https://crussell.ichi.city/food/inauguration/.))
Google Doc's main goal is to make money off of companies whose main goal is to make money.
I'm not entirely sure that's true. I'd wager that's incidental; the main goal seems to be to give people access to a word processor in the form of a Web app, and the fact that they've figured out a way to make money on it is... not coincidental, but certainly "serendipitous" or "fortunate" (in the way that it's fortunate to be able to make money off any kind of software created for some other reason than to make money).
Axiom 5: A doc is a distinct, shareable object
I dislike the use of "doc" as nomenclature here. "Document" works perfectly fine.
Axiom 4: If you build a tool with the ability to publish, so help them god, people will publish
See also: Zawinski's Law.
The writing here is super obscure. I don't like it.
The soft power of Google Doc publishing
See also:
Google Docs is one of the best ways to make content to put on the Web.
What disturbs me sometimes is that many people in software engineering approach debugging like empirical science. Run experiments, gather data, fit some curve, essentially. In the end, a program is a product of the mind. It's pure logic, and fundamentally it's understandable, unlike the real world which can at every turn have new surprises for you. We should think more and measure less.
I feel, in some circumstances, the opposite way.
The problem, as Feynman pointed out, is that it's very easy to fool yourself.
So much of software development practices are driven by people loosely (read: unrigorously) reasoning about things. Few people form hypotheses for which we can articulate some means of proving or disproving what is being claimed.
A resource can map to the empty set, which allowsreferences to be made to a concept before any realization ofthat concept exist
This is a very useful but underutilized property. It allows you to e.g. announce in advance that a resource will exist at some point in the future, and thereby effectively receive "updates" to the linking document without requiring changes to the document itself.
encapsulate the data with a rendering engine and send bothto the recipient
By and large, this is what 23 years of software trends in browser-based development have given us, unfortunately.
how dowe ensure that its introduction does not adversely impact, oreven destroy, the architectural properties that have enabledthe Web to succeed?
Another good jumping off point for why document mutability should be considered harmful. https://hypothes.is/a/N_gPAAmQEe6kvXNEm10s7w
This is:
Fielding, Roy T., and Richard N. Taylor. “Principled Design of the Modern Web Architecture.” In Proceedings of the 22nd International Conference on Software Engineering, 407–16. ICSE ’00. Limerick, Ireland: Association for Computing Machinery, 2000. https://doi.org/10.1145/337180.337228.
When a decentralized alternative for source-control took off (git), “society” still adopted a centralized repositoryof incredible scale (Github).
stylesthat could build software that works the way society works.
This is a good launching point for my contention about Modification Considered Harmful.
where theraw source could be directly modified and potentially read. Thiswas not widely implemented, and was subsequently removed. Thiseffectively limits WebDAV remote authoring to situations wherethere is a nearly direct correspondence
I'll go further and say that, wrt the original goals of the Web—and the principles we should continue to strive for today, despite widespread practice otherwise—Modification (should be) Considered Harmful.
Git has the right idea. Hypermedia collections should also be append-only (not different resources masquerading under the same name).
In REST,what is transmitted across the wire is a representation of the rawsource of a resource consistent with some standard data type, notthe raw resource itself. However, the author of a resource wishesto modify this raw resource directly. The raw source could be quitedifferent from its representation, such as when a web page is createdas the output of a program (e.g., a PHP script) running on the server,where the representation is in HTML, and the raw source is sourcecode.
This is highly dubious—you're talking about two completely different resources at that point.
If I send you a link to a page on a dynamic site written in PHP like standardebooks.org, and then I send you a link to the GitHub repo showing the source of the script responsible for intercepting the request and responding with the page that you actually see when you visit the first URL, are those really two different representations of the same resource? Or two different resources? It's the latter.
There is a desire to rectify/reconcile this with WebDAV, because you want to be able to "address", say, cart.php—which is in principle not a bad thing (it's very much a good thing, really)—but merging two resources into the same namespace is not the solution, and bad hygiene should not be excused.
Bi-directional links were initially supported within HTTP viaLINK and UNLINK methods; they were not widely adopted, andwere later removed
resource fusion
This appears to be among the only uses of this phrase wrt AJAX.
This is:
Fielding, Roy T., Richard N. Taylor, Justin R. Erenkrantz, Michael M. Gorlick, Jim Whitehead, Rohit Khare, and Peyman Oreizy. “Reflections on the REST Architectural Style and ‘Principled Design of the Modern Web Architecture’ (Impact Paper Award).” In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering, 4–14. ESEC/FSE 2017. Paderborn, Germany: Association for Computing Machinery, 2017. https://doi.org/10.1145/3106237.3121282.
Today “REST” and “RESTful architecture” are widely used terms,and sometimes even used appropriately.
For now, I was happy to chat with World Book's Tom Evans via tempered electrons, who says his employer's commitment to the print edition is ongoing. "We will continue to produce the print edition of The World Book Encyclopedia while there is still a demand. We believe in supporting teachers, librarians, and students and are committed to supplying content to them in whatever form is required," he said.
A thought: this kind of support should be in the purview of the Wikimedia Foundation. They have an ample endowment, and in 2021, their revenue was $162 million vs $111 in expenses. They could outright pay for every copy that the World Book sells, or cover the costs of a give-one-get-one program.
Some ways that this could work out to enrich the commons: a licensing deal where the photographs in World Book become available under CC-BY-NC-ND (i.e. gratis to share) two years after publication and then CC-BY-SA (sufficiently permissive so that it would allowed to be imported into Wikimedia Commons) after, say, five years following initial publication.
as I carefully pulled them out of the box one by one, I enjoyed feeling the weight of the information in my hands. It felt like stepping back onto dry land after a long boat ride.
See also: emerging from the theater when there's still daylight, or pulling off your skates and walking around in your own shes when leaving the rink.
I've revisited this post a lot. Here's a relevant link to discussion between the author of this post and Mark Adler:
https://github.com/madler/sunzip/issues/7
In light of Mark's insistence of certain things, Greggman's hedging seems more reasonable. I'm still of the opinion that Mark is wrong, though; Greggman had it right the first time.
This is "MSC:CV RESPONSE TO MOTION FOR NEW TRIAL Defendants' Opposition to Plaintiff's Motion for Trial Setting"
The only thing that might be unfamiliar is the local keyword, which is used to declare variables. Variables are global by default, so local is used to declare a variable as local to the current scope.
awful
EscapeHtml(str) → str Escapes HTML entities: The set of entities is &><"' which become &><"'.
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...
your private version of the Internet
The Web, you mean.
Madonna
NB: This refers to the the musical artist, not the (non-existent) Madonna, Texas.
Another Microsoft related problemwith WebDAV and Windows 2000involves an “unchecked buffer” thathandles the DAV protocol.
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...
1=23189,00.asp
should have been "[...]a=23189,00.asp"
www.pcmag.com/print_article/0,3048,1=23189,00.asp
should have been http://www.pcmag.com/print_article/0,3048,a=23189,00.asp
i.e., s/1=/a=/
IETC
should be "IETF"
IETP
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
authoring-suitable representation
what the FSF (GPL) calls "preferred from for modification"
WC3
should be "W3C"
accomplish things the originalauthors of HTTP never imagined at thetime of its invention” (www.swdi.com/WebDAV-Report.pdf)
except TBL did imagine them -- browsermakers (outside CERN) didn't
headds, “simplicity also leads to limita-tions.”
that's a feature (not a bug)
Floyd calls HTML “an extremelysimple protocol”
should be "HTTP"
1=23189,00.asp
should have been "[...]a=23189,00.asp"
IETP
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.
A good example for the motivation of this work is the website of the Hypertext Conference in 2008. The original URI http://ht2008.org is not accessible anymore and returns a 404 error today.
we show how we have used theseprotocols in the design of a new Resource Migration Protocol(RMP), which enables transparent resource migration acrossstandard web servers. The RMP works with a new resourcemigration mechanism we have developed called the ResourceLocator Service (RLS), and is fully backwards compatible withthe web’s architecture, enabling all web servers and all webcontent to be involved in the migration process
They assume that it's worth someone's time to keep up with updates every month or two. But situated software doesn't have those kinds of surpluses. It requires programs to just work once built, with little maintenance
I think there's a category error here.
Here is a study
Here is a talk
This is a headline
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).
incompetence
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?
What if there was zero accidental complexity to modifying a app, and all you had to focus on was understanding how it worked?
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.
Deciding when and how an organization should break compatibility is a thorny problem. But fortunately we're not concerned with organizations here. When we're just individuals
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.
I remember when I started out programming, I wanted my programs to look “professional,” like the programs other “real” programmers made.
(It is my contention that this accounts majorly for a bunch of the problems in e.g. the NPM ecosystem.)
When I show it to other programmers, often the first question I get is about what the file format for drawings is, and how to get other editors to support that file format. But does it make sense to so privilege interoperability? You have a tool to draw pictures as you write. There are situations where it can be useful, even if nobody else can read it. Trying to stay close to other people and tools makes things more complex and less supple. A tiny, open-source tool that is easy to run and works with a simple file format allows me (and you) to focus on the writing experience without precluding others from taking on additional concerns.
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.
These languages foster a culture of depending on lots of libraries
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".
it's easy to build
What does this mean, though? Concretely, I mean. (Could stand to qualify/quantify this.)
This is the LÖVE game engine. It's based on Lua
I was surprised to find about a ~month ago that LÖVE is written in C++. Its scripting support is Lua-based.
As a result, it doesn't tend to get used in products of conquest that try to be all things to all people.
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.)
that spawns lots of forks
Maybe not necessary for the intended audience but might benefit from distinguishing between bonafide forks vs what GitHub has done to the word.
I'm always looking for ways to make them useful to others.
Isn't that a contradiction?
If you doubt my claim that internet is broad but not deep, try this experiment. Pick any firm with a presence on the web. Measure the depth of the web at that point by simply counting the bytes in their web. Contrast this measurement with a back of the envelope estimate of the depth of information in the real firm. Include the information in their products, manuals, file cabinets, address books, notepads, databases, and in each employee's head.
to understand its construction and intentions and to change it comfortably
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.
people who are functioning in an underground manner in plain sight with knowing intention of being watched and findable, just doing so in a double-switchback
huh?
No representation is made about the persistence policies for any other information on the site.
lame
Should the W3C be disbanded, then any Web site will be granted the right to make a copy (at a different URI) of all public persistent resources so long as they are not modified and are preserved in their entirety and made available free of charge, and provided the same persistence policy is applied to these "historical mirrors." In such event, the original https://www.w3.org web site will be handed over for management to another organization only if that organization pledges to this policy or one considered more persistent.
Not Found
An atlas?
In a book? Yes.
A price guide?
You mean price guide books? If so, yes.
What about a phonebook?
Yes.
Is a dictionary a book?
Yes.
Is a yearbook a book?
Yes.
I think that TANGLE-style reordering is a lot less important with modern programming languages: they don't do one-pass compilation and so can deal with forward references. Note that most of the cross-references in Knuth's program could be replaced with function calls or constant names
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.
It also includes some advice that might be obvious to professional programmers, but that might not be obvious to researchers or others who are just starting out
in literate programming, the problem and its should be described in the manner best suited to the problem and the intended readership. That means non-linear, in a compiler's sense. Fragments of procedures presented out of order, procedures presented in any order, data structures introduced in any order. Perhaps objects give us a handle on the non-linearization, because they can be created in any order, and methods are very short. Webbed descriptions could also be fine, but of course people do read one sentence at a time, and when you convert to paper there is an order to the paper. But that order should be ordered to the reader, not the compiler (until it is time to compile)!
I felt he had just written the program where the default was comment without delimiters (i.e. most just changed the syntax for the compiler).
I second everything Kent said. Perhaps my misunderstanding about Knuth's writings, but the literate programs of his I read looked like the program was still sequenced for his compiler, with lots of English written around it. That meant the English read to me like it was sequenced for his compiler. I should like to see an example sequenced for me, with the pre-compiler so adapted as to straighten the code out for the compiler.
This pretty much the basis for Kartik's criticism in Literate Programming: Knuth is doing it wrong.
I can feed my Literate Programs (and I do virtually everything significant that way, since it helps me think better about the code) to hypertext-style index generators (a.k.a. "documentation generators", which I think is a dangerously misleading term).
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?
General solutions are more complex than specific ones.