1,448 Matching Annotations
  1. Last 7 days
    1. First thing I noticed is that I spent a bunch of time writing tests that I later deleted. I would have been better off writing the whole thing up-front and just doing end-to-end tests.

      need for cheaper throwaway tests

    1. the expected lifespan of even very successful SaaS companies is typically much shorter than the lifespan of personal data

      A strength of boring tech that relies on the traditional folders-of-files approach, incl. e.g. the byproducts of using office suites.

    2. I suspect because most software is optimized for industrial use, not personal use. For industrial uses the operations overhead is not a big deal compared to the development and operational efficiency gained by breaking things up into communicating services. But for personal uses the overwhelming priority is reducing complexity so that nothing fails.
    3. preventing the build from bitrotting would probably require a full-time maintainer in the long run
    4. data can be exported from airtable, but the logic and UI can't
    5. when doing independent research I've typically fallen into the habit of creating unbounded projects with no internal structure. I don't think this has been good for my sanity.
  2. Jun 2022
    1. Yesterday evening (London, UK time) something amazing happened which can best be described in a single picture:

      That doesn't describe anything. It's a grid of GitHub avatars. What am I supposed to be seeing?

    1. you get so used to the way things are you don't think of the obvious next step and you know that can be so frustrating
    2. this can't possibly work because if it worked somebody in the last 40 years would have done it
    3. as long as the compiler doesn't use a bunch of global variables to store the compiler state, you can use it to run another instance of itself

      In other words, singletons are harmful.

    1. In saner bugtrackers like e.g. Bugzilla the community is empowered to step in and triage bugs. GitHub infamously chose to go for a "simpler" system with fewer frills, pomp, and circumstance. Perversely, this has the opposite of the intended effect. The net result is that for the community to have these powers, the project owner has to explicitly grant them to individual users, which is considered to be a lot more heavyhanded/ceremonial than how it works on bugzilla.mozilla.org.

      I'd have no problem, for example, stepping in and enforcing these things if it weren't the case that it were such a chore to go through the ceremony and getting approval to police this kind of stuff. GitHub's lackluster approach to user privacy, of course, doesn't help.

    1. Signal, which is damn good crypto work, announced MobileCoin support, and I stopped donating, bummed.

      Signal trades on some other stuff of dubious* merit, like the "guarantees" of SGX, and does other user-hostile stuff: requiring a PIN, doing user data backups without permission, locking out third-party clients... (What's worse is that the latter is excused as being the only way to reliably enable the undesirable "enhancements").

      * Even calling it merely "dubious" here is pretty generous.

    2. enablingly vague

      Nice turn of phrase.

    3. Many a

      This was tired the second time it occurred in this piece. Three times is def. too much.

    4. Not a fan of this piece, overall.

      Cryptocoin hype/scams are dumb. Who cares.

    1. Okay, so the original source seems to be Proteus (A Journal of Ideas). Specifically, vol. 3, iss. 1. (Thanks to Nikos Katsikis by way of Neil Brenner for helping track this down.)

    2. Also available here under the alternate title "Livingry" from BFI: https://www.bfi.org/about-fuller/big-ideas/livingry/

    1. I've come to much the same conclusion, I think: to wit, most people secretly enjoy their problems and suffering.

      See also, from Brooke Allen's "How to hire good people instead of nice people" https://brookeallen.com/2015/01/14/how-to-hire-good-people-instead-of-nice-people/:

      I won’t get between you and your dreams. If you have a dream, I need to know what it is so we can figure out if this job gets you closer. If you don’t have a dream then that’s fine, as long as you really want one and you’re not addicted to wishing and complaining.

  3. buckyworld.files.wordpress.com buckyworld.files.wordpress.com
    1. enormous an ounce of energy;

      I can't parse this. Ravasio says any typo is probably her fault. The best I can come up with is "an enormous amount of energy", which doesn't make sense as a typo, but does sort of sound the same.

    1. Rephrasing Brian Smith: Some thing is on the Web such that if the Web itself was destroyed, that thing would also be destroyed. If not, it's not fully on the Web. If someone destroyed the Web, this would not damage me if I were being denoted by a URI, but my homepage at that URI would be up in smoke if that what's people were using to refer to me by. I am not on the Web in a strong sense, but my homepage sure is.

      I don't think this is a good definition. The example, at least, is a bad one. That resource could still exist (the same way a .docx that lives in the Documents directory and has been uploaded but later had the file host go down would still exist)—it just wouldn't be resolvable by URL.

    2. In theory, through content negotiation a news website could communicate with your browser and determine where you live and then serve your local news. This rather simple example shows that the relationship between resource and representation can not be one-to-one.

      I don't think this is a good example. I'd call it bad, even. It's self-defeating.

    3. This page is excellent for an example of HTML being an adequate substitute for traditional office formats.

    1. > If I understand your critique, it's this: "How dare you critique their use of Ra? You have no standing! You have no right!" Which is basically an ad hominem attack that doesn't address any of the substance of my complaint.Sorry, no, making up your own caricature of what I said isn't an effective way of responding to it.

      Yeah, why has this become so normalized? It's gotten to the point where people will respond to something by posting nothing but an attempt at false attribution by rewording the other—typically in the most convenient, pithy, hackneyed, and strawmannish way—and then putting quotes around it while drowning in plaudits from those who already agree—often for reasons no better than shameless tribal affiliation.

      The basic precondition to summarizing the other's position in order to refute it is that the other side actually agrees that it's an accurate summary of their position. If you don't have that, then you don't have anything.

    1. How can you let people know that you’re “in the market”? How can you assemble a portfolio or set of case studies?

      Yes, those are the questions for people interested in pieces like this one. What are the answers?

    2. Old clients, bosses, colleagues?

      This presupposes something that I see frustrates many people who are the main audience for pieces like this.

      Is this step #1 or not? Where did those people come from? I see way too many people wave their hands on this part, which is silly, because this is the part that people are most interested in.

      The thing I really admired about Chris Lattner in an interview I listened to during lockdown was the fact that (one of?) the first things he mentioned about success was the role that luck played in his life. There's a tacit admission there that, although he's Chris Lattner and a really smart guy and clearly deserving of his success because of the foregone facts we now have access to, even if you reset everything but didn't manage to replicate the exact circumstances, then things might not actually work out like they did the first time. It's a tacit admission that replicability is not just not guaranteed but that results are almost akin to a crapshoot.

    1. maitenance
    2. ,"

      What's with the Americanized punctuation style here?

    3. intemediary
    4. Twitter API

      Change my view: Hypothesis is suitable for this.

    5. are using
    6. There are plenty of troublesome assumptions and unanswered pragmatic issues in that sketch.

      Here's one: suppose Alice reads a book and adds it to her library then learns through this system that Tom, Dick, and Mary have it in their libraries, too. Thing is, Tom finished reading it 6 weeks ago, Dick read it last summer, and Mary read it 12 years ago as an undergrad. Would this be a good reading group?

    7. committment
    8. seperate
    1. recieved
    2. the physical shape and color of each command limits makes clear where you can and can't put it

      As a sort of "gutter bumper" approach, guiding you on what is and isn't accepted in the language, they're nice, but I can imagine as a child that it would have annoyed me when I wanted to express something and found that the "only" reason why I couldn't follow through on something was because they made something the wrong shape, keeping me from doing the thing, and not understanding.

      Contrast this with the remark below about pattern languages being "a set of design rules that loosely define how a system should work, rather than a strict specification".

    3. a set of design rules that loosely define how a system should work, rather than a strict specification
    4. amphibians

      Turtles are reptiles.

    5. Paypert
    6. Seymour Paypert
    1. There's a data layer. There's a security layer. There's a visual design layer. There's a hypertext layer that links to other locations. There's an authentication layer. There's an algorithmic layer.

      Is "layer" the right choice here?

    2. login
    3. seperately
    4. We're looking forward to next week

      NB: this is culture-specfic

    5. Out of all of these metaphors, the second most dominant after paper is physical space.

      NB: these two metaphors are at odds. You can see this in the way that authors treat user agent overlays as intrusions into their space—a place for them to control, instead of e.g. a note clipped to the copy that belongs to the reader.

      The owned-space one is definitely worse, but I fear that for many people it's now the default—for both those seeking control and those who are the indirect objects of control.

    6. it's
    7. heirarchical
    8. pape
    9. We still imagine the web as a series of paper documents with text and images presented on them.

      I don't know if this is true for anyone. It certainly seems like most people who are digital natives (or immigrants) rarely make the connection and end up missing out on some lessons from print that would actually be helpful.

    1. Good documentation includes background and decision information that cannot be derived from the code.
    1. I was speaking to the CEO of a developer tools company earlier this year. He told me that the biggest obstacle to contribution is his local development environment.
    2. the cloud is reducing the dev machine to a poorly debugged set of environment mocks

      This pie in the sky has been promised for the last 10+ years. It's not happening.

    3. Your personal dev environment travels with you no matter which device you use

      A lot of these ideas are junk. This one, though, is achievable. triplescripts.org.

    1. JavaScript is the universal scripting language

      ALGOL 2020

    2. The fundamental mistake of Node.js was diverging from the browser
    3. In 2010, we didn’t have ES modules, but once it was standardized it should have been brought into Node.

      Fun fact: the amount of time between 2010—the year Dahl mentions here—and ES2015—aka ES6, where modules appeared—is less than the amount of time between ES2015 and today. And yet people act like modules are new (or worse, just over the horizon, but still not here). It's a people problem.

    4. If you have some computational heavy lifting, like image resizing, it probably makes sense to use Wasm rather than writing it in JS. Just like you wouldn’t write image resizing code in bash, you’d spawn imagemagick.

      This is misleading/hyperbolic. The performance characteristics of WASM vs JS are nothing like a native binary vs the Bash interpreter.

    1. This negatively impacted our team’s ability to work quickly and efficiently as they improved our documentation.

      Meanwhile, when I reported an error (broken link) in Cloudflare's documentation to a developer there, I was told "I'm sorry that our workflow doesn't work for you, but relaying typo reports through e-mail doesn't scale well on our end," just before snidely signing off with a lame attempt to upperhand: "I guess we'll have to get by without your reports."

    2. Built using Go, Hugo is incredibly fast at building large sites, has an active community, and is easily installable on a variety of operating systems. In our early discovery work, we found that Hugo would build our docs content in mere seconds.
    3. Developer documentation is incredibly important to the success of any product. At Cloudflare, we believe that technical docs are a product – one that we can continue to iterate on, improve, and make more useful for our customers.One of the most effective ways to improve documentation is to make it easier for our writers to contribute to them.
    4. we quickly found it to be the wrong match for our content-heavy documentation experience. Gatsby inherits many dependency chains to provide its featureset, but running the dependency-heavy toolchain locally on contributors’ machines proved to be an incredibly difficult and slow task for many of our documentation contributors

      This wouldn't be so annoying to read if it weren't the case that this was solved like 15+ years ago by the right tool for the job: wikis.

      I see the "neo-OSS era" or "New Social era" of today to stand in sharp contrast with what I've previously referred to as the Shirky era. In the world of software development, the regressions from the transition from the Shirky era to the present, monumental though those regressions are, have been quietly underreported (seemingly hardly even perceived). We've seen the rise and consolidation of open source project management around a centralized (and perversely, closed source) service provider that's more of a social network and valued for that reason than it is a decent bugtracker or wiki. It calls things wikis that aren't, not just diluting the word but instead transforming it into something that is by now effectively meaningless—along with encouraging awful mixing of support requests and freeform discussion with bugtracking (but that's beside the point).

      The big hallmark of this era: obtuse publishing pipelines that seek to replicate the compiler-input →compiler → compiler-output workflow, pushed heavily by new programmers who first encountered compilers during this era and encouraged by others who bafflingly insist on applying this poorly chosen hammer to the non-nail-shaped problem. Why? What I can make out:

      1. the omnipresent and inescapable influence of Ra

      2. a desperation for legitimacy at a time when low-level system programming has been in decline

      3. people just genuinely unable to perceive the effects of complexification, like the way some people cannot enjoy cilantro, or the way others cannot accurately track the passage of time without external help

      It'd be nice if we could get back to a place where we understood that the point of all this stuff is to make things easier—particularly in the here and now, and in some mythical, never-reached promised land where travelers are perpetually kept away by the YAGNI demons.

    1. I almost feel like I should get to draw the interface that I want for myself. like how Acme lets you grow your own palette of commands as you work.

      Some incarnation of the Fly Pentop/Livescribe focused on this.

    1. the web is not HyperCard; you can't really make a home-cooked meal
    2. It's the ethos of html-energy, combining the minimalism of htmldom.dev programming

      The fact that the author is describing it in these terms is really evidence that the main achievement here is overcoming the limitations of his or her own mental blocks.

    3. This is an excellent piece, even though the writing is (probably intentionally) in places too obscure.

    1. The interconnectivity features need a server though, and that involves either using a third-party service, or spinning up your own VPS, which means added cost, and you’ll probably have to do that at some point anyway if you choose the third-party option at first.
    1. it's gone into what's called the browser section

      Probably not the best descriptor, owing to domain collision. Almost anything else would be better, e.g. "Gallery".

  4. May 2022
    1. @5:50:

      In this portion of the machine, we keep these brass matrices.

      Throughout, "matrices" can be heard to be pronounced as "mattresses". Could this have something to do with the origin of the phrase "going to the mattresses"? It seems more likely than the conventional explanation that involves safehouses and literal mattresses, which strikes me as really dubious.

      Compare "capicola" → "gabagool".

    1. Until sometime last year I'd been coding socii in the open

      NB: I'm pretty sure this is referring to fact that the site was live, and it had open registration. The source code was not being worked on in the "open", even under lax definitions of that word.

    1. I think adding automated deployments would be a nice quality-of-life feature and would definitely encourage me to write more. Currently, I have to upload a new text file to my server and refresh the pm2 job.

      Is "automated deployments" really the solution?

    1. Our build bots do it by parsing your HTML files directly at deploy time, so there’s no need for you to make an API call or include extra JavaScript on your site. # HTML forms Code an HTML form into any page on your site, add data-netlify="true" or a netlify attribute to the <form> tag


    1. JS is plenty fast and can be used for "large, complicated programs"[1] just fine. The problem with most JS written today is in programmer practices—the way that the community associated with NodeJS pushes one other to write code (which is, ironically, not even a good fit for the JavaScript language). It turns out that how you write code actually matters
    1. I develop in Node and Sveltekit regularly and the chances that on any given day my flow might be crushed by random madness is unacceptably high.
    2. I have seen experienced developers pull their hair out for a day or more trying to get a basic build system working, or to import a simple module.
    1. I feel like the point of the article isn't so much "how do I solve this specific issue" as "this is the general state of JS packaging", and the solution you present doesn't work in the general case of larger, less trivial dependencies

      Much of the (apparent) progress (i.e. activity—whether it constitutes busywork is another matter) in the world of "JS Prime" (that is, pre-Reformation, NodeJS/NPM-style development) is really about packaging problems.

    1. Anyway: I think the underlying problem is that it has been hidden that Node is NOT JavaScript. It uses (some) of the JavaScript syntax, but it doesn't use its standard library, and its not guaranteed that a Node package will also run on the browser.

      NodeJS development is often standards-incompatible with JS-the-language and other (actually standardized) vendor-neutral APIs.

    1. This is a problem with all kinds of programming for new learners - actually writing some code is easy. But getting a development environment configured to actually allow you to start writing that code requires a ton of tacit knowledge.
    1. I can write JS and TypeScript easily enough but when I start a new project I'm always fighting the tooling for at least half an hour before I can get going.
    1. Not only this. Try to change the app two years later. Dependencies gone, wrong NPM version, Webpack config depricated and what not.That's why I like to use vanilla JS as much as possible. It will be maintainable years later.
    1. Javascript is severely restricted in file:// today.
    2. Oh, you’re in file://! Dude, what are you doing these days without a localhost?
    3. I’m gonna use Node!

      Reality: this has a lot to do with the problems here.

      Remedy: ignore the NodeJS toolchain bullshit[1], rip out the thing you're interested in, and stuff it into an ordinary page foo.hmtl.

      1. https://pg.ucsd.edu/command-line-bullshittery.htm[2]

      2. https://hypothes.is/a/22JaWMu5Eey2UvchosEz6Q

    4. Today I tried to help a friend who is a great computer scientist, but not a JS person use a JS module he found on Github. Since for the past 6 years my day job is doing usability research & teaching at MIT, I couldn’t help but cringe at the slog that this was. Lo and behold, a pile of unnecessary error conditions, cryptic errors, and lack of proper feedback.
    1. Yes, you could write Python utilities that are easy to install and run, but people don't. And the last bit of that sentence is the one that actually counts. "Could have" doesn't actually count in an engineering context.
    1. I just want to try this C++, download, unzip, oh it's windows so .project file. Fine, redo on windows , oh it's 3 versions of vstuido old and says it wants to upgrade , okay. Hmm errors. Try to fix. Now it's getting linking error.
    2. okay how about ruby? oh I have old ruby , hmmm , try to install new ruby, seems to run, but it can't find certain gems or something. oh and this other ruby thing I was using is now broken ? why do I have to install this stuff globally? You don't but there are several magic spells you must execute and runes you must set in the rigtt places.
    1. I've watched a bunch of very smart, highly-competent people bounce off JS; that's not a fault with them but with the ever-changing and overly-complicated ecosystem.

      It helps to be accurate (if we ever want to see these things fixed):

      They didn't "bounce off JS". They "bounced" after seeing NodeJS—and its community's common practices.

    1. It feels like every example I run into is an easy to follow "20-steps + 10 packages + 64GB cloud server instance" process when all I want to do is to download some historical temperature data to CSV.
    1. if you think it's hard for someone who is already a programmer - think about how needlessly complicated the entire ecosystem and everything surrounding it is for the average person
    2. You may think that this person is silly - but that is tainted by your past experience of already knowing it warping what you think the baseline average knowledge level is at.
    1. > Movim is easy to deploy> Movim is lightweight (only a few megabytes) and can be deployed on any server. We are providing a Docker image, a Debian package or a simple installation tutorial if you want to deploy it yourself.I imagine a typical Tumblr user landing on this page and not getting a single word of the "easy to deploy" section.

      Related: comments about deployability of PHP over in the comments about "The Demise of the Mildly Dynamic Website".

    1. I woke up realizing one of the computers I use isn't set up to build and I wished I could use it to build and release the new version
    1. The thrill of getting "hello world" on the screen in Symbian/S60 is not something I'll ever forget. Took ages of battling CodeWarrior and I think even a simple app was something like 6 files
    1. Knuth recommended getting familiar with the program by picking up one particular part and "navigating" the program to study just that part. (See https://youtu.be/D1jhVMx5lLo?t=4103 at 1:08:25, transcribed a bit at https://shreevatsa.net/tex/program/videos/s04/) He seems to find using the index (at the back of the book, and on each two-page spread in the book) to be a really convenient way of "navigate" the program (and indeed randomly jumping through code, as you said), and he thinks that one of the convenient things about the "web" format is that you can explore it the way you want. This is really strange (to us) as the affordances we're used to from IDEs / code browsers etc are really not there

      I can't help but think that currentgen programmers are misunderstanding Knuth and anachronizing him, with their being a product of the current programming regime where most never lived in a world without structured programming, for example, when we hear "literate programming", we attempt to understand it by building off our conception of current programming practices and try to work out what Knuth could mean given widespread modern affordances as a precondition, when really Knuth is just advocating for something that approximates (with ink and paper) currentgen tooling, and is therefore in fact more primitive than our reference point which we are trying to understand as being capable of being improved upon, but Knuth's LP is an improvement nonetheless of something even more primitive further still.

    1. I still stick by the fact that web software used to be like: point, click, boom. Now it is like: let's build a circuit board from scratch, make everyone learn a new language, require VPS type hosting, and get the RedBull ready because it's going to take a long time to figure out.
    1. Unlike conventional blogs which are read-only this blog contains active code, so you can click on any of the links in this tiddler and see the code and see how the system behaves.
    1. I have no doubt that the four children, now in their 70s and 80s, who spent their early years in the basement house would never tolerate such activity in their own neighborhoods today.
    1. I always joke that I'm fluent in jQuery, but no absolutely no javascript[...] There are still banks and airlines that run COBOL

      The joke being that both jQuery and COBOL were crummy right from the beginning, and now they're crummy and old, right?

    1. i noted first that the headline performance gain was 10% & 11% this for a team given far more time and resources to optimize for their goal than most

      What does this even mean?

      I also find it laughable/horrifying the comparison between jQuery and greybeardism (or, elsewhere, a bicycle[1]). jQuery is definitely not that. It is the original poster child for bloat.

      For all the people feigning offense at the "greybeard" comments at the thread start, it's much more common, unfortunately, to find comments like this one, with people relishing it when it comes to jQuery, because it confers an (undeserved) sense of quasi-moral superiority, wisdom, and parsimony, even though—once again—jQuery represents anything but those qualities.

      1. https://news.ycombinator.com/item?id=31440670
    1. I’d just like to point out that the problem with jQuery today is it was a library built to smooth over and fix differences between browser JavaScript engines

      jQuery is primarily a DOM manipulation library and incidentally smoothed over differences in browsers' DOM implementations. To the extent that there were any significant differences in browser's JS implementations, jQuery offered little if anything to fix that.

    1. jQuery-style syntax for manipulating the DOM

      This is 70+% of the reason why I end up ripping out jQuery from old/throwaway projects when I start trying to hack on them. The jQuery object model is really confusing (read: tries too cute/clever), and the documentation sucks, relatively speaking, and the code is an impenetrable blob, which means reading through it to figure out WTF it's supposed to do is a non-option.

    1. The problem is that a lot of old school website devs can write jQuery and very very little actual JavaScript.

      This happens to be true of many of the new/up-to-date Web developers I see, too.

      Anecdote: I never really did StackOverflow, either as a reader or a contributor. One day several years ago (well after StackOverflow had taken off), I figured that since I see people complain about JS being confusing all the time and since I know JS well, then I'd go answer a bunch of questions. The only problem was that when I went to the site and looked at the JS section, it was just a bunch of jQuery and framework shit—too much to simply ignore and try to find the ones that were actually questions about JS-the-language. "I know," I thought. "I'm in the JS section. I'll just manually rewrite the URL to jump to the ECMAScript section, which surely exists, right? So I did that, and I just got redirected to the JS section...



    1. I'm not going to write document.querySelector every time I have to select some nodes, which happens quite often.

      This remark manages to make this one of the dumbest comments I've ever read on HN.

    1. now something breaks elsewhere that was unsuspected and subtle. Maybe it’s an off-by-one problem, or the polarity of a sign seems reversed. Maybe it’s a slight race condition that’s hard to tease out. Nevermind, I can patch over this by changing a <= to a <, or fixing the sign, or adding a lock: I’m still fleshing out the system and getting an idea of the entire structure. Eventually, these little hacks tend to metastasize into a cancer that reaches into every dependent module because the whole reason things even worked was because of the “cheat”; when I go back to excise the hack, I eventually conclude it’s not worth the effort and so the next best option is to burn the whole thing down and rewrite it…but unfortunately, we’re already behind schedule and over budget so the re-write never happens, and the hack lives on.

      I'm having real difficulty understanding what is going on here and in what situations such cascading problems occur.

      Is it a case of under-abstraction?

    2. Furthermore, its release philosophy is supposed to avoid what I call “the problem with Python”: your code stops working if you don’t actively keep up with the latest version of the language.
    1. the skills to tweak an app or website into what they need

      Does "what they need" here implicitly mean "a design that no one really benefits from but you can bill a client for $40+/hr for"? Because that's how Glitch comes off to me—more vocational (and even less academic) than a bootcamp without the structure.

      What was that part about home-cooked meals?

    2. The biggest barriers to coding are technical complexity around processes like collaboration and deployment, and social obstacles like gatekeeping and exclusion — so that's what we've got to fix
    3. Building and sharing an app should be as easy as creating and sharing a video.

      This is where I think Glitch goes wrong. Why such a focus on apps (and esp. pushing the same practices and overcomplicated architecture as people on GitHub trying to emulate the trendiest devops shovelware)?

      "Web" is a red herring here. Make the Web more accessible for app creation, sure, but what about making it more accessible (and therefore simpler) for sharing simple stuff (like documents comprising the written word), too? Glitch doesn't do well at this at all. It feels less like a place for the uninitiated and more like a place for the cool kids who are already slinging/pushing Modern Best Practices hang out—not unlike societal elites who feign to tether themself to the mast of helping the downtrodden but really use the whole charade as machine for converting attention into prestige and personal wealth. Their prices, for example, reflect that. Where's the "give us, like 20 bucks a year and we'll give you better alternative to emailing Microsoft Office documents around (that isn't Google Sheets)" plan?

    4. as if the only option we had to eat was factory-farmed fast food, and we didn’t have any way to make home-cooked meals

      See also An app can be a home-cooked meal along with this comment containing RMS's remarks with his code-as-recipe metaphor in the HN thread about Sloan's post:

      some of you may not ever write computer programs, but perhaps you cook. And if you cook, unless you're really great, you probably use recipes. And, if you use recipes, you've probably had the experience of getting a copy of a recipe from a friend who's sharing it. And you've probably also had the experience — unless you're a total neophyte — of changing a recipe. You know, it says certain things, but you don't have to do exactly that. You can leave out some ingredients. Add some mushrooms, 'cause you like mushrooms. Put in less salt because your doctor said you should cut down on salt — whatever. You can even make bigger changes according to your skill. And if you've made changes in a recipe, and you cook it for your friends, and they like it, one of your friends might say, “Hey, could I have the recipe?” And then, what do you do? You could write down your modified version of the recipe and make a copy for your friend. These are the natural things to do with functionally useful recipes of any kind.

      Now a recipe is a lot like a computer program. A computer program's a lot like a recipe: a series of steps to be carried out to get some result that you want. So it's just as natural to do those same things with computer programs — hand a copy to your friend. Make changes in it because the job it was written to do isn't exactly what you want. It did a great job for somebody else, but your job is a different job. And after you've changed it, that's likely to be useful for other people. Maybe they have a job to do that's like the job you do. So they ask, “Hey, can I have a copy?” Of course, if you're a nice person, you're going to give a copy. That's the way to be a decent person.

    5. If you’re a coder, when’s the last time you just quickly built something to solve a problem for yourself or simply because it was a fun idea?

      And how future-proof was the result or how easy was it to make sure you could share it with others in a form that they could make use of (and not be dependent on you or some third-party or their internet connection)?

    1. I’ve been using heroku for years and while some might complain that it has stagnated and mostly stayed the same since the salesforce acquistion, I think that’s been an asset.
    1. Cold starts depend a lot on what people actually deploy. They're really fast for an optimized Go binary, really slow for most Node apps.
    1. Before deploying, we need to do one more thing. goStatic listens on port 8043 by default, but the default fly.toml assumes port 8080.

      When I created a blank app with flyctl launch, it gave me a fly.toml with 8080. The fly.toml cloned from the repo, however, already has it set to 8043.

      It's possible that the quoted section is still correct, but it's ambiguous.

    1. This column will continue only if I hear from people who use literate-programming systems that they have not designed themselves. and it did not continue.
    1. To keep tiny mistakes from crashing our software or trashing our data, we write more software to do error checking and correction.

      This is supposed to be the justification for increasing code size. So what's the excuse for projects today? Software of today is not exactly known for adding more "error checking and correction". It feels more like growth for growth's sake, or stimulating some developer's sense of "wouldn't it be cool if [...]?".

    1. The atomic unit of developer productivity ought then to be one iteration of the inner loop. The appropriate unit is not code quantity, but iteration frequency. We might call this unit of quantity developer hertz.
    1. Because we didn’t have real marketing people, we updated the product to became more and more interesting to us, the developers, and less interesting to potential buyers.
    1. suppose when you needed to make a permanent edit to the style sheet on your homepage, you opened up the CSS viewer, made the edit, and the result persists—not just in your browser, but by changing the very style sheet itself
    1. because of the "LP will never be mainstream" belief, I'm still thinking of targeting mainstream languages, with "code" and "comments"

      No need to constraint yourself to comments, though. Why comments? We can do full-fledged, out-of-line doclets.

    2. an acknowledgement of network effects: LP is unlikely to ever catch on enough to be the majority, so there needs to be a way for a random programmer using their preferred IDE/editor to edit a "literate" program

      This is part of the reason why I advocate for language skins for comparatively esoteric languages like Ada.

    3. in other words, there would be no "weave" step

      Well, there could still be a weave step—same as there is like with triple scripts (to go from compilation form back to the original modules) or with Markdown, which should be readable both as plain text and in rendered form.

    1. in an ideal LP system, the (or at least a) source format would just simply be valid files in the target language, with any LP-related markup or whatever in the comments. The reason is so that LP programs can get contributions from "mainstream" programmers. (It's ok if the LP users have an alternative format they can write in, as long as edits to the source file can be incorporated back.)

      (NB: the compilation "object" format here would, much like triple scripts, be another form of human readable source.)

  5. geraldmweinberg.com geraldmweinberg.com
    1. Welcome to the Gerald M. Weinberg Fan Site!

      Do we have to wait for people to die before these kinds of digital fanclubs can materialize for people who aren't in entertainment?

    1. Code can't explain why the program is being written, and the rationale for choosing this or that method. Code cannot discuss the reasons certain alternative approaches were taken.

      Having trouble sourcing this quote? That's because some shithead who happens to run a popular programming blog changed the words but still decided to present it as a quote.

      Raskin's actual words:

      the fundamental reason code cannot ever be self-documenting and automatic documentation generators can’t create what is needed is that they can’t explain why the program is being written, and the rationale for choosing this or that method. They cannot discuss the reasons certain alternative approaches were taken. For example:

      :Comment: A binary search turned out to be slower than the Boyer-Moore algorithm for the data sets of interest, thus we have used the more complex, but faster method even though this problem does not at first seem amenable to a string search technique. :End Comment:

      From "Comments Are More Important Than Code" https://dl.acm.org/ft_gateway.cfm?id=1053354&ftid=300937&dwn=1

    1. This is a good case study for what I talk about when I mean the fancub economy.

      Wouldn't it be better if gklitt were a willing participant to this aggregation and republishing of his thoughts, even if that only meant that there were a place set up in the same namespace as his homepage that would allow volunteers ("fans") to attach notes that you wouldn't otherwise be aware of if you made the mistake of thinking that his homepage were his digital home, instead of the place he's actually chosen to live—on Twitter?

    1. I loved the Moto G (the original—from during the brief time when Google owned Motorola). I used it for 6 years. It's not even an especially small phone. Checking the dimensions, it's actually slightly smaller (or, arguably, about the same size) when compared to either the iPhone 12 Mini and the iPhone 13 Mini—which I'd say makes those deceivingly named. They're nothing like that one that Palm made, which is called, uh... "Palm", I guess. (Described by Palm as about the size of a credit card.)

    1. memory usage and (lack of) parallelism are concerns

      Memory usage is a concern? wat

      It's a problem, sure, if you're programming the way NPMers do. So don't do that.

      This is a huge problem I've noticed when it comes to people programming in JS—even, bizarrely, people coming from other languages like Java or C# and where you'd expect them to at least try to continue to do things in JS just like they're comfortable doing in their own language. Just because it's there (i.e. possible in the language, e.g. dynamic language features) doesn't mean you have to use it...

      (Relevant: How (and why) developers use the dynamic features of programming languages https://users.dcc.uchile.cl/~rrobbes/p/EMSE-features.pdf)

      The really annoying thing is that the NPM style isn't even idiomatic for the language! So much of what the NodeJS camp does is so clearly done in frustration and the byproduct of a desire to work against the language. Case in point: the absolutely nonsensical attitude about always using triple equals (as if to ward off some evil spirits) and the undeniable contempt that so many have for this.

    2. on baggage: "package.json", for example, is not an ECMA standard

    3. My argument: JavaScript is a future-proof programming language

    1. Also (related moreso to Future-proof), Haxe? Dart?

    2. Absent from consideration: * Gecko/XULRunner (check out the way that Zotero is built) * GtkJS

      Both deserve a look

    1. C# is a great language and the .NET standard library is probably the most thoughtfully crafted standard library I've ever used

      My reaction to the author's take on future-proof programming languages even before I got to this post (and this part in it) was that he should look at porting (or getting ported) the C# standard libraries (to JS—as part of my argument that JS the future-proof programming language Krinke is looking for).

    1. You give up private channels (DMs)

      Consider ways to build on the static node architecture that wouldn't require you to give this up:

      • PGP blobs instead of plain text
      • messages relayed through WebRTC when both participants are online
      • you could choose to delegate to a message service for your DMs, to guarantee availability, just like in the olden days with telephones
    1. I’d start using a library written by somebody else to get started, then eventually replace it with my own version
  6. www.mindprod.com www.mindprod.com
    1. local a (e.g. aPoint) param p (e.g. pPoint) member instance m (e.g. mPoint) static s (e.g. sPoint)

      This is really only a problem in languages that make the unfortunate mistake of allowing references to unqualified names that get fixed up as if the programmer had written this.mPoint or Foo.point. Even if you're writing in a language where that's possible, just don't write code like that! Just because you can doesn't mean you have to.

      The only real exception is distinguishing locals from parameters. Keep your procedures short and it's less of a problem.

    2. Show me a switch statement as if it had been handled with a set of subclasses. There is underlying deep structure here. I should be able to view the code as if it had been done with switch or as if it had been done with polymorphism. Sometimes you are interested in all the facts about Dalmatians. Sometimes you are interested in comparing all the different ways different breeds of dogs bury their bones. Why should you have to pre-decide on a representation that lets you see only one point of view?

      similar to my strawman for language skins

    3. We would never dream of handing a customer such error prone tools for manipulating such complicated cross-linked data as source code. If a customer had such data, we would offer a GUI-based data entry system with all sorts of point and click featu