Pinned toot

Don't get me wrong, computers can absolutely help us regain our environmental efficiency. They just *aren't*.

Not as long as we're:
* constantly syncing everything to the cloud,
* expecting same-hour delivery,
* funding our clickbait via surveillance advertising,
* buying a new phone every year,
* using AIs because they're cool rather than useful,
* running bloated software & webpages,
* buying into "big data"
* etc

Computing is environmentally cheap, but it rapidly adds up!

Show thread
Pinned toot

Maybe it's just because this is where my interest lies, but reading a few takes on how to Fix The Web yesterday I really think a major issue are the discovery hueristics we use. Their incomprehensibility and shallowness promotes the bad and buries the good.

There's PLENTY of good links! Otherwise I'd be wanting to tear The Web down rather than just JS...

I created Odysseus to explore some partial solutions, but I'm keen to see others address the problem from a different angle! Links? Advice?

Good moaning fedi. 🌎

If what's running on the server is a big mystery with endless speculation about whether it's open or closed then don't trust the software.

Convenience is one hell of a ride.

Be open. Let the sunshine in.

This has been a public service announcement.

Does anyone know of HTTP-based APIs that let you control exactly which parts of a complex JSON structure you want to fetch?

PostgREST has a pretty powerful 'select' query parameter* to do that, I'm curious if there are other examples.


happy #bandcamp friday verse. to kick things off, i'm rocking a massive broadcast with about 8 hours worth of original catalogue, mostly thumpers, weeded out most of the noise stuff. If you have the means be sure to support some bandcamp artists today for max impact as they will get 100% of the take.

say hay in the owncast chat if you like

#industrial #powernoise #ebm #synth #techno #mastoart #mastomusic #np #fediplay

The basics of good UI/UX seem to have been lost to time, in favor of shiny touchscreens with no fundamentals.

Old car radio had a very basic single line LCD. Push a button, volume knob becomes bass or treble knob, screen reflects state. Wait for the timeout and it reverts to being a volume knob again. Keep it simple.

New car touchscreen clusterkcuf first of all doesn't respond to presses (but it blinks the "button" so you know it knows you pressed it). But when it does, you get a popup bass/treble window that blocks everything else.

The EQ "faders" are as worthless as the buttons [WHOA! Eyes on the road swerve back into lane!] Give up on that for now... want to change the radio station? Good luck getting the little X to close the window, because the designers forgot what a damn timeout is.

You can either drive the rest of the way with the worthless EQ window up, taunting you, or take your life into your hands trying to close the window at speed...

Or as the dealer recommended, pull over every time you need to interact with controls that used weren't broken and didn't need to be fixed on your old radio...

Show thread

in addition to N-Triples, RDF/XML, and Turtle,

JSON-LD — that thing ActivityPub and Mastodon are using right this second — is actually a kind of rdf format.

Show thread

a (simplified) toot in json-ld:

"id": "",
"type": "Create",
"actor": "",
"published": "2021-03-05T04:24:47Z",
"to": [ "" ],
"object": {
"type": "Note",
"url": "",
"atomUri": "",
"conversation": ",2021-03-05:objectId=testconvo:objectType=Conversation",
"content": "wow a toot"

Show thread

Anyone feel like collaborating on a modernization of the public-domain classic "Calculus Made Easy"?

The 1914 edition is, well, from 1914, so it features a speckling of archaisms like pre-decimal British currency. Martin Gardner made an updated edition in the 1990s, but that update is copyrighted, and I think he adds a little too much material.

a toot in rdf/xml:

<content>wow a toot</content>

Show thread

(this is critically supposed to have namespace info around it that absolutely wouldn't fit in a toot body:)

<?xml version="1.0"?>
<rdf:RDF xmlns="" xmlns:rdf="" xmlns:o="">



Show thread

I jokingly/tentatively call this technique "OWL wings" because I like the imagery of term definitions as "wings" extending off the body of something,
or the notion of taking a data object and arbitrarily sticking several wings on it to turn it into some kind of terrifying many-winged angel thing

particularly when the data objects are in "Turtle" format it sounds like this has turned into mario or something.

Show thread

It seemed like the surprising answer was..... there wasn't.

rdfs/owl/etc existed, but all the documentation about absolutely anything anywhere was just like 'these are all really broad ideas, you can make whatever you want'.
(which of course wasn't very helpful to me because I wanted to make something /specific/ and was hoping there would be a standard for it.)

eventually I just started messing with the idea of defining the technique myself and hoping there wasn't already a better version.

Show thread

within rdf, there are RDFS (rdf schema), OWL (web ontology language), SHACL (shape constraint language) and others.
there are quite a few options

but one thing that confused me a lot is why prefixes — namespaces that distinguish similar property names put into "sentences" — don't immediately lead to machine-readable information about their terms,

and if there was a standard way to offload a handful of prefixes referenced at the top of an rdf file into a "prefix stylesheet" and import just one

Show thread

researching what kind of formats are already used to store citations,
I eventually started learning about rdf.

at its core, rdf is just a bunch of simple "sentences" (triples) drawing a particular kind of arrow from one thing to another thing:

:rdf a :format .

however there are many methods built on top of this to make the "sentences" actually mean something, usually through more "sentences" that connect particular "words" to their qualities.

Show thread

I first tried to imagine how I would store data for something like a bibliographic citation, to render out into some particular style a bit like bibtex.

one of the motivations for bopwiki is the idea of creating a 'miniature library' documenting different information sources, perhaps for the far future when it's hard to find some particular source on a web search.
like a card catalogue

so, being able to store a list of citation properties in a bop entry is a natural place to go

Show thread

this is one of those times where I have no idea if anything I'm saying has enough context to make sense to anyone outside my head

but, short version:

This is a bop entry

=> an external link
<= 1614911456 a "parent" entry
; these are functions that /return/ structured data, undefined in their text form but given life in code
; they are more than key-value fields like "parent: 1614911456".

Show thread

> bopwiki entries [... have] "meta lines" [... and ] "filters"
> they are more than key-value fields like "parent: 1614911456".

so, I asked myself, what can I even do if I want to put a key-value dictionary inside a file format which fundamentally abhors arbitrary + mutable things like property names?

and the answer led me to a very confusing and esoteric thing called "ontologies".

Show thread
@Valenoern For a file format, not breaking it is normal and should quite be expected.
For a language, okay yeah fine but maybe break a bit after like… 10 years? (C does break and it's fine)
For kernels and librairies, please do not avoid breaking ABI/API too much, there is a pile of broken things out there that are kept broken just because of this, just stabilize and keep it for few years. ("Linux maintains bugs")

my approach so far has been to kind of nudge users to code & name simple functions themselves to use features beyond absolute core ones

I figure if I essentially hide most of the logic inside the program and make the API surface "I'm" responsible for really small,
I can create a system where the user maintains their own API against future breakage

hopefully in such a way that whenever you want to add a custom feature to bop you end up reformatting data entries as little as possible

Show thread

bop is fundamentally built to quickly jot down a chunk of text, and then add "meta lines" that connect it to others or describe it.
usually just a couple, but maybe a bunch

there is a whole idea of "filters" for allowing the user to customise how raw entry files become their 'canonical' form, such the user can take the bop "file format" and redefine what it is and can do

but at this time it's not really designed for meta lines like
"key: value"

Show thread

this is partly intentional.

while thinking about what I wanted bopwiki to be, I decided I wanted to avoid "breakable APIs" as much as possible

nothing bugs me more than the concept programming functions can have the most arbitrary names and could change at any time or be merged or split with others...
/but/ users could also rely on them not changing.

why have we baked human language into programming like this when it's the most arbitrary and constantly-mutable thing

Show thread
Show older

For people who care about, support, or build Free, Libre, and Open Source Software (FLOSS).