Some random folk practices I've come across:

* Blocking, stacking and pulling creep camps in DOTA. Unintended behaviours that became core game mechanics.

* Comments in the tag section of Tumblr posts, to avoid the comments appearing in a reblog ("Why do people use tags on tumblr instead of comments?" [1])

* The appropriation of switching MOSFETs such as the IRF510, designed for low frequencies, in homebrew amateur radio QRP power amplifiers. "In talking to International Rectifier, they were floored to find out QRPers were using them at 7MHz or higher." [2]

[1] https://www.reddit.com/r/NoStupidQuestions/comments/nu4vpa/w...

[2] http://www.iw3sgt.it/IW3SGT_PRJ/IW3SGT_AMP_LF/ClassDEF1.pdf

> Large California-based companies produce monolithic apps and interfaces for a global audience. They're designing for the broadest, generic use cases to make things work for the greatest number of people.

Hah! If only! Actually they often (but not always) seem to design it for an SV audience with the latest-gen phone/computer, fast uninterrupted internet, familiarity with the latest "UX" fads, perfect eyesight, etc. Anybody that falls outside that narrow group can get shafted.

Another article in a similar vein, that I thoroughly enjoyed yesterday: https://www.robinsloan.com/notes/home-cooked-app/

I was surprised to see no mention of automation tools like IFTTT and Tasker. These sorts of overarching automation oriented tools let people solve a lot of problems by stitching together things that aren't designed to work together.

I would actually put Excel in this original category. Part of Excel's utility is that it is really good at enabling building of dashboards, applications, whatever. While Excel's builders didn't have D&D character sheets in mind, they definitely expect users to do unanticipated things with the software, just as much as IFTTT or Tasker would.

In some ways this is a "platform" type of perspective. "Here's a bunch of building blocks, go do whatever you think you need" is really powerful once the network effect of building blocks gets big enough. Any tool with a built-in DSL or workflow builder type of UI is probably in this category.

Orthogonal to the main point of the article, I was interested in the mention of Victor Papanek's tin can radio receiver, which apparently cost 9c to make (presumably the cost of the transistor, since everything else was recycled), and could be fueled by burning wax or dung.

I haven't been able to find a simple guide for how to make one myself.

I build fictional worlds as a hobby, and sometimes I need to make a map of a globe and find myself in need of a program that can draw vector shapes onto a globe and project it onto a 2D map afterwards. The simplest way I've found to do that which fits my workflow is a program called GPlates. A program that simulates plate tectonics. I've never touched the simulation part, although it might be useful in my worldbuilding at some point. All I use it for is drawing colored shapes.

Random folk practice that drove me nuts, Outlook "Deleted Items Folder" as storage, never actually deleted, ever.

20+ Gigabyte mailboxes, which were actually a threaded, searchable, rich content database. (Exchange's superpower (when it works) is a almost perfect online/offline sync able database -- You can send an email in your offline client, when you go online it'll get sent, your calendar updates will sync, etc)

Folk interfaces are a natural consequence of the focus on building applications for millions of users and the dearth of situated software [1]. They're also a clever way of claiming no-code or low-code platforms in unexpected places.

[1]: https://www.gwern.net/docs/technology/2004-03-30-shirky-situ...

This is like the interface version of Hyrum's law:

    With a sufficient number of users of an API,
    it does not matter what you promise in the contract:
    all observable behaviors of your system
    will be depended on by somebody.

This is referred to in the literature as 'appropriation' [0], though perhaps that term has gained too much cultural baggage recently to be useful.

[0] https://www.scienceopen.com/document_file/cbe110a4-c761-4afe...

> No matter how much well-intentioned user research these companies invest in, they'll never be able to produce software that fully meets the needs of individual users and culturally distant communities.

Domain experts being able to solve their own problems sounds is a worthwhile objective for software tools but innovation in this space has been surprisingly sparce.

I've been searching for other examples of end-user programmmable tools beyond spreadsheets for inspiration. Anyone have suggestions of some other places these kinds of "folk interfaces" show up?

One of my favorite creative uses of Excel comes from !!Con 2017, where Kevin Chen used spreadsheet to implement HDR imaging[1]. It’s also just an incredibly well-crafted presentation.

[1] https://kevinchen.co/projects/excel-hdr/

The biggest issue that I come across, is users of my software, developing mental models of the software that I would never, in a million years, have developed, myself.

They often work with the software, based on their "strange" mental model, and can have very weird workflows.

In some cases, this is excellent, and it is worth it for me to learn the new model, and maybe add affordances for it.

On the etymology of "folk", saying that it the word comes from Old English folc is true, although a vast over-simplification. A lot of languages share this word.

This is actually an ancient word, you can trace it back to proto-Germanic "fulka", and further to Proto-Indo-European "plh-gos" (presumably pronounced something like phulgos or pholgos, close enough to folk).

Using Virtual Machines as capability based security is something I've come to accept.

Windows and Linux are vulnerable to the confused deputy problem, so you separate your concerns into separate VMs and give each "machine" a set of resources (capabilities)

IBM and Digital machines have done this since the 1960s.

There's also the Indian cultural concept of `jugaad`, which refers to folksy hacking. https://en.wikipedia.org/wiki/Jugaad

I found the post interesting. It provoked me to think about the low-code, no-code movements, and of the concept of folk interfaces. It is a nice term and I will try keep it with me in my future thinking. I found the 9c radio particularly appealing. It also made me consider how I ended up where I am now, and one thing that struck me is that when I was learning to program, I tried learning from textbooks about programming and they intimidated me and felt impenetrable. I didn't know how to get into them at all. Then by stroke of fortune I came across the first programming book that really took me. It was called C for Dummies, by Dan Gookin. It was filled with humor and encouraged experimentation, and above all it was empowering. It made me feel good and it inspired me: I sent a couple of busted but well-intentioned input routines off to a friend who was further along in the process than I was and he introduced me to the off-by-one-error. I never became a good C programmer, but I learned how to make the computer do my bidding in small ways, and it wasn't long before I picked up another book, on Perl and CGI.pm, and I wrote my first "web applications". Eventually I went on to do a computer science degree. Today, by HN standards, I'm maybe nothing to write home about, but I make a very comfortable living and I enjoy writing code at work. I enjoy learning about tech in my spare time, even now.

I guess what I'm trying to get at is that I wish to see learning to code, per se, easily accessible for all. I'm not talking about cheap or even free boot camps that promise entry into a lucrative job market. I'm talking about a kid, or a parent, or an auntie or uncle or cousin or sister or brother, about whoever, who just sees something they want to make happen and they literally do because they can. I read through the comments and I re-read the wonderful article by Robin Sloan linked below ("An app can be a home-cooked meal" -- look through this comment thread, and you'll see it, alongside my first observation of the term "OA", one that took me some time to decipher -- another thing that will stick with me).

I believe that programming is and always will be for the masses. I believe in development best practices when they are called for. But for learning, for discovering the beauty of computing and the joy of software, of writing one's first programs, I wish the barriers were less!

I use Hugin[1] to manually align images and combine them into virtual focus.[2] I started doing this after learning of the Stanford Multi-Camera array[3], and wanting to replicate the ability to see through things[4].

I didn't have the budget, so I used one camera and a cluster of photos from slightly varying locations. I got there eventually.[5]

[1] https://hugin.sourceforge.io/

[2] https://www.flickr.com/photos/---mike---/albums/721577185851...

[3] http://graphics.stanford.edu/projects/array/

[4] http://graphics.stanford.edu/projects/array/videos/crowd0-sa...

[5] https://www.flickr.com/photos/---mike---/51018992733/in/albu...

I approve of this, but its hardly novel. Web browsers were originally intended to view flat html documents with hyperlinks between them. The concept of a web app is itself a 'folk' repurposing of technology.

Another might be the way blocks in minecraft are repurposed to make all sorts of elaborate redstone machines such as automatic farms.

This argument is very similar to what I usually, probably inappropriately, refer to “malleability” of a software, interface or system in general: it’s ability to be used way beyond the initial use cases, and hopefully be good at it.

Whenever I need to explain to laypeople what I do as a software designer, I tell them that most of my job is figuring out new ways to visualize and connect outlines and spreadsheets.

The theme/presentation of this site is top tier. Nice work.

and when you start from the premise that folk interfaces are not only good but should be actively encouraged, you get something like emacs.

If this is an interesting idea to you, check out: https://screenl.es

along the lines of the d&d spreadsheet, I've developed an entire app for running scrabble tournaments as an elaborate google sheets script. it's a couple of thousand lines of javascript for the logic, but the user interface is entirely a bunch of spreadsheet tabs.

I'm currently rewriting it as a standalone web app just to break the dependence on google, and have a more customisable user experience, but it's really hard to beat the spreadsheet UX, where settings are all done using editable tables and the output shows up in another table.

Hypercard was this and generated really rich "folk" artefacts. Filemaker (https://www.claris.com) is sort of this still. A modern example is Coda (https://coda.io) which is seeks to be spreadsheet like in terms of inviting folk (end users) to play and create while making database and scripting easy enough to discover and wrangle.

Corel's office suite has a scripting language if I recall. My grandfather in law learned enough of it to develop a few systems for managing family finances, gifting (it's a large family), etc.

Emacs is notable. It requires learning a bit of elisp programming but, like a browser, is basically a development environment that gives you access to a windowing system, input from the user, image rendering, text buffers, etc. Plenty of people write their own tools to manage particular workflows.

Update

Examples of emacs as folk interface:

- https://bofh.org.uk/2019/02/25/baking-with-emacs/

Microsoft Power Automate[0].

This tool scares the hell out of me, as a sysadmin, with end users who have no education re: software engineering (and potentially really wonky mental models about software) developing potentially business-critical tools/processes out of the IT equivalent of "glue and tape".

This is especially scary to me because building on "evergreen" platforms like Office 365 means that critical emergencies and downtime could occur at the whim of platform owners making changes to the underlying platform. Spacebar heating.. all that... >sigh< (And I'll be expected to fix it when it breaks and the user who made it has left...)

[0] https://powerautomate.microsoft.com/en-us/

Browsers used to be. They used to let the user apply their own CSS sheets to websites, and some extensions still allow tem to manipulate pages ("user scripts").

Web technologies were designed to let the user do what they want with the document they receive. But "the web" then evolved in a different direction.

Case in point: TFA, like many other sites, is unusable without Javascript. And it's not even "because CDN". Why do I have to execute code on a page that could be 1:1 replicated in pure HTML ?

It's very explicitly intended to be reprogrammed, but Tiddlywiki is a pretty good one. It is a great platform since it gives you data storage, advanced queries, and rendering.

People using notepad to subtitle screen-captured tutorials on Youtube.

Not quite what you're asking for since it's designed to be hackable, but the Vim alternative text editor Kakoune:

https://zork.net/~st/jottings/kakoune-a-punk-rock-text-edito...

Visual programming tools, such as Grasshopper 3d, have created a microworld of custom-made plugins and user interfaces, mostly to generate 2d and 3d geometry, but often used to achieve other programming feats.

There are even explicit plugins that let users create UI components to control and visualize program inputs and outputs.

One I haven’t seen mentioned: Max/MSP[1]. Technically it is a visual programming language but I don’t know how many users realize that.

1: https://en.m.wikipedia.org/wiki/Max_(software)

Minecraft comes to mind, if you want to think out of the box.

The entire Low Code / No Code and RPA / IPA markets exist for this. Airtable, App Smith, etc are a modern, web-based take on Access.

The more generic a tool is, the more creative people get with it. For example, emailing a file or note to yourself is a folk interface. Using a Facebook group to role play is a folk interface.

Nothing has come close to matching spreadsheets though.

MS Access databases.