Frank schrijft over de soms verwarrende ervaringen met zijn Post Kinds plugin in WordPress. Die plugin gebruik ik, en ik heb met regelmaat dezelfde problemen.

Post Kinds maakt het mogelijk dat ik makkelijk postings van anderen kan ‘liken’ ‘reposten’, er op kan antwoorden, én dat aan de oorspronkelijke poster kan laten weten.

Post Kinds probeert daarvoor gegevens van de posting waarop je reageert op te halen (link, titel, auteur, een quote etc.) en slaat die in je eigen site op.

Wat Frank en ik regelmatig als probleem hebben is dat Post Kinds niets ophaalt en een lege posting maakt, of wat ik ook vaak heb, wél alle gegevens ophaalt van de bron-posting, maar niet opslaat en een lege posting maakt. Zonder een idee te hebben waarom dat gebeurt.

Nu kan ik ook zonder Post Kinds een ‘like’ of antwoord posten, door zelf de inhoud de juiste eigenschappen mee te geven. Dat roept meteen de vraag op of er gevolgen zijn voor mijn bestaande postings als ik Post Kinds uitschakel.

Dat heb ik even geprobeerd op een WordPress site die ik gebruik om dingen te testen.
Daar maakte ik een ‘like’ aan op een posting van mezelf op dit blog.


Een like op mijn test-site, gemaakt in Post Kinds.

Vervolgens schakelde ik de Post Kinds plugin uit, met als resultaat dat dan de opgeslagen extra informatie niet meer wordt getoond:


Na uitschakelen van de plugin is de like ook verdwenen

Er staat nu geen enkele informatie of link meer naar de posting waar ik op reageer, en alleen mijn reactie staat er nog.
De Post Kinds plugin heeft dus niet alleen invloed op hoe informatie wordt getoond, maar ook of die informatie überhaupt uit de database wordt opgehaald. Niet geheel verrassend uiteraard.

Dit heeft als consequentie dat ik op deze site Post Kinds niet kan uitschakelen, ook als ik het voortaan niet meer zou gebruiken, zonder dat ik de functionaliteit van Post Kinds op de e.o.a. manier opnieuw maak in mijn site-opmaak. Omdat anders bestaande postings die met die plugin zijn gemaakt niet meer leesbaar zijn.

Die lock-in is een onaangename verrassing. Iets waarvan ik nog niet exact weet wat ik er van vind.

After I built a proof of concept of using OPML to share and federate book lists yesterday (UPDATE: description of the data structure for booklists), Tom Chritchlow asked me about subscribing to OPML lists in the comments. I also reread Matt Webb’s earlier posting about using OPML and RSS for book lists.
That results in a few remarks and questions I’d like to make and ask:

  • OPML serves 2 purposes
    1. In the words of Dave Winer, opml’s creator, OPML is meant as a “transparently simple, self-documenting, extensible and human readable format that’s capable of representing a wide variety of data that’s easily browsed and edited” to create and manipulate outlines, i.e. content structured hiearchically / tree-like.
    2. the format is a way to exchange such outlines between outliner tools.
  • In other words OPML is great for making (nested) lists, and for exchanging them. I use outlines to build my talks and presentations. It could be shopping lists like in Doug Engelbart’s 1968 ‘mother of all demos’. And indeed it can be lists of books.
  • A list I regard as an artefact in itself. A list of something is not just iterating the somethings mentioned, the list itself has a purpose and meaning for its creator. It’s a result of some creative act, e.g. curation, planning, writing, or desk research.
  • A book list I regard as a library, of any size. The list can be as short as the stack on my night reading table is high, as long as a book shelf in my home is wide, or as enormous as the full catalogue of the Royal Library. Judging by Tom Critchlow’s name for his booklist data ‘library.json‘ he sees that similarly.
  • A book list, as I wrote in my posting about the proof of concept, can have books in them, and other book lists by myself or others. That is where the potential for federation lies. I can from a book point to Tom’s list as the source of inspiration. I could include one of Tom’s booklists into my own booklists.
  • A list of books is different from a group of individual postings about books as also e.g. presented on my blog’s reading category page. I blog about books I read, but not always. In fact I haven’t written any postings at all this year, but have read 25 books or so since January 1st. It is easier to keep a list of books, than to write postings about each of the books listed. This distinction is expressed too in Tom Macwright’s set-up. There’s a list of books he’s read, which points to pages with a posting about an entry in that list, but the list is useful without those postings.
  • The difference between booklists as artefacts and groups of postings about books that may also be listed has impact on what it means to ‘subscribe’ to them.
    • A book list, though it can change over time, is a steady artefact. Books may get added or removed just like in a library, but those changes are an expression of the will of its maker, not a direct function of time.
    • My list of blogsposts about books, in contrast is fully determined by time: new entries get added on top, older ones drop off the list because the list has a fixed length.
    • OPML is very suited for my lists as artefacts
    • RSS is very suited for lists as expression of time, providing the x most recent posts
    • Subscribing to RSS feeds is widely available
    • Subscription is not something that has a definition for OPML (that you can use OPML to list RSS subscriptions may be confusing though)
    • Inclusion however is a concept in OPML: I can add a list as a new branch in another list. If you do that once you only clone a list, and go your own seperate way again. You could also do it dynamically, where you always re-import the other list into your own. Doing it dynamically is a de-facto subscription. For both however, changes in the imported list are non-obvious.
    • If you keep a previously seen copy and compare it to the current one, you could monitor for changes over time in an OPML list (Inoreader did that in 2014 so you could see and subscribe to new RSS feeds in other people’s OPML feed lists, also see Marjolein Hoekstra’s posting on the functionality she created.).
  • I am interested in both book lists, i.e. libraries / bookshelves, the way I am interested in browsing a book case when I visit somebody’s home, and in reading people’s reviews of books in the form of postings. With OPML there is also a middle ground: a book list can for each book include a brief comment, without being a full review or opinion. In the shape of ‘I bought this because….’ this is useful input for social filtering for me.
  • While interested in both those types, libraries, and reviews, I think we need to treat them as completely different things, and separate them out. It is fine to have an OPML list of RSS feeds of reviews, but it’s not the same as having an OPML book list, I think.
  • I started at the top with quoting Dave Winer about OPML being a “simple, self-documenting, extensible and human readable format that’s capable of representing a wide variety of data that’s easily browsed and edited“. That is true, but needs some qualification:
    • While I can indeed add all kinds of data attributes, e.g. using namespaces and standardised vocabularies like schema.org, there’s no guarantee nor expectation that any OPML parser/reader/viewer would do anything with them.
    • This is the primary reason I used an XSL template for my OPML book lists, as it allows me to provide a working parser right along with the data itself. Next to looking at the raw file content itself, you can easily view in a browser what data is contained in it.
    • In fact I haven’t seen any regular outliner tool that does anything with imported OPML files beyond looking at the must have ‘text’ attribute for any outline node. Tinderbox, when importing OPML, does look also at URL attributes and a few specific others.
    • I know of no opml viewer that shows you which attributes are available in an OPML list, let alone one that asks you whether to do something with them or not. Yet exploring the data in an OPML file is a key part of discovery of other people’s lists, of the aim to federate booklists, and for adopting better or more widely shared conventions over time.
    • Are there generic OPML attribute explorers, which let you then configure what to pay attention to? Could you create something like an airtable on the fly from an OPML list?
    • Monitoring changes in OPML list you’re interested in is possible as such, but if OPML book lists you follow have different structures it quickly becomes a lot of work. That’s different from the mentioned Inoreader example because OPML lists of RSS feeds have a predefined expected structure and set of attributes right in the OPML specification.
    • Should it be the default to provide XSL templates with OPML files, so that parsing a list as intended by the creator of the list is built right into the OPML list itself?
    • Should we ‘dumb down’ lists by moving data attributes of an outline node to a sub-node each? You will reduce machine readability in favor of having basic OPML outliners show all information, because there are no machines reading everything yet anayway.

I think for the coming weeks I’ll be on the lookout for sites that have book lists and book posting feeds, to see what commonalities and differences I find.

After I wrote about federated bookshelves again two weeks ago, I decided to build a proof of concept. A proof of concept for providing an OPML file that contains a list of books, in a way that can be parsed by others. I roughly follow Tom Critchlow’s “spec”.
Because I am making up my own data attributes (although I follow schema.org where possible), I decided to not just create an OPML list, but also to add an XSL template so that OPML is not just machine readable but also human readable in a browser.

The general idea is I have a list that contains lists of books. A list of books can contain books directly, or only be a link to that list of books. A list of books can be one of my own lists on my own domain, or it can be a list published by someone else on a different web address. This allows me to point to other people’s lists when it is somehow relevant to me.

A book in a list I provided with data attributes like title, author and urls for the book and author, and again fields pointing to other people, like the url for the list I may have found the book, or the url for the person / review which was my recommendation.

This allows discovery for both you and me. It makes it work like social software: in triangles, where you can navigate from a person, to a piece of content (a book or list), and to a piece of metadata which is itself the url of another list, or the url of another person, that then have their own metadata pointing to others etc.

Because my lists are structured opml, I should be able to automatically create list files from my own book notes.

Let’s have a look at the proof of concept:
I have an OPML file, called ‘books.opml


At the top of that screenshot you can see the opml file calls a XSL stylesheet, named test. I created it by adapting the similar set-up I have for my OPML blogroll. Because of that stylesheet the book list is human readable in a browser and looks like this:


What you see is first some info about me as the creator of the list. It has a link to this list, which is my main list, and a link to my site.
Below it is a list of book lists.

  • The first of those book lists, called ‘Fiction I read in 2021’ doesn’t have its own url, and the books are shown directly. Those books may have a link to the book, to the author, some notes, or a link to who recommended it to me, or in which list I found it. It also has a short list description at the top.
  • Underneath it is another list by me, called ‘Current non-fiction anti-library’, that is just linked.
  • Underneath that are two lists, created by Tom Critchlow and Tom Macwright, both of which are just links. The list item in the outline has an author attribute, and if it’s not my name it gets shown as a ‘followed’ book list. Theoretically if an external link is an OPML file itself, I could include it and show it right here.

Now if you click my other book list, the anti-library list (read here what an anti-library is), that is another opml file.

It calls the same XSL stylesheet as the other list, and renders in the browser as

What you can see in this second list is that it starts with the same link to the main list and info about me, and then shows how the list itself has both a URL and a description. It contains books, and see how one of those books has a link to the book itself. (I don’t link to Amazon or Goodreads, so won’t have links for most books, only if there’s a link to the publisher’s or author’s page on that book)
In the description of the last book you also see how it has a link to the list (Tom Macwright’s) in which I found it, as well as a link to a posting that served as recommendation for me.

For now what I like is that these lists bring their own viewer with it (your browser using my stylesheet), and can point to other people’s lists both directly as a list in my own collection, or as a reference for one of the books. Without having to make assumptions about other people’s lists or parse them somehow, it still allows connecting to them (federating), and discovery. My own lists use schema.org terms for book lists (collection) and books (book). Three attributes I cannot place within schema.org terms, at least not without adding additional subnodes in the outline: author url, reference list (url of the list I found a book in), and reference url (the person or posting that recommended the book to me).

UPDATE: I described the data structure for booklists I used.

I find I enjoy the process of self hosting my old presentations much more than I had expected. I expected the transition being a chore, but it turns out it is not.

Last September I quit using Slideshare and created a way to host my own slidedecks myself. I had 132 presentations in my personal slideshare account, and a similiar number in my company’s account. Migrating them into my own set-up seemed like a daunting chore. I resolved to take my time for it, to spread out the work load.

I first created a list of presentations that I embedded in this website at the time, containing 55 slide decks. In that list I marked those that I currently think are still relevant, or that I regard as important to me at the time, or that in hindsight turned out to contain something that gained more significance in my work afterwards. Then I started to manually add those prioritised slide decks to my self hosted collection (tonz.nl for Dutch slides, tonz.eu for non-Dutch slides), at most one per day.

Unexpectedly this is fun to do. Because I do not just upload slides, but add links to my blogposts about the talk at the time, a video etc, I sort-of revisit the conference in question. Sometimes rewatching my own talk, sometimes going through the slides of other presenters at the same event or watching their videos. It resurfaces old ideas I forgot about but still find useful, and it results in new associations and thoughts about the topics I discussed in those talks. Leading to new notes and ideas now. It also shows me there is a consistency in my work that isn’t always obvious to me, and it surfaces the evolutionary path of some of my ideas and activities. That makes it worthwile to bring these slides home. Like reassembling an old photo album whose pictures slipped out because the glue became too old.

Two years ago I wrote about the features I’d like to see in an ideal feed reader. Today I’ve tried to sketch out the various components, based on the various IndieWeb protocols, and then match the features I listed previously to the component that I think should provide it.

Separating feed reading into IndieWeb components

Feeds from blogs, to the left in the sketch below, end up in a microsub server, whose function is to fetch and store feeds. A microsub client is what presents those fetched feeds to me. A regular feed reader usually does both these things, but splitting them like the IndieWeb does allows multiple clients to use the same collection of feeds and feed items. It allows a wider diversity of readers, if the fetching is dealt with separately.
The microsub client also contains a micropub client. This allows having action buttons underneath each item presented in your microsub client. Hitting a button posts your reply or remarks, or shares something to your own website, and through your site to e.g. Twitter or Mastodon. Ideally it would be possible to have different websites to share to, next to storing locally in a specified format. The website that receives such an action has a micropub endpoint, and may need authentication through IndieAuth.

Such a reader set-up should be able to run locally on my laptop, as well as on a basic hosting package, so likely php / mysql based. Locally because I want to run my stuff local first, but the same thing online, even if a home server, because I’m not always working on my laptop and would like access from my tablet too, and point my Android Indigenous app to my subscriptions. Locally I would not need authentication from the microsub client to the microsub server, but in all other situations I would.

The sketch above is completely congruent with how I sketched my information gathering and filtering process in 2005:

filter1.jpg

Matching the ideal functionality to IndieWeb components

When I match the features of my ideal feed reader to those various IndieWeb components I think this is what results:

Microsub server needs to be able to :
* use various kinds of feeds (rss, atom, json, h-feed)
* allow folders (so I can arrange feeds on social distance)
* recognize and store tags if feed items have them
* allow me to tag _feeds_, really meaning tagging authors
* keep track of posting frequency, last post seen of feeds
* keep track of tags or predefined topics mentions/frequency
* pull in machine translations by default for certain feeds and store them with the orginal item

Microsub client needs to be able to:
* present the feed items in the server’s folder structure as a long list (the classic feed reader view)
* present views based on patterns in current feed items: what’s hot, what’s unique? Also set against social distance. (Topics discussed in my communities today)
* present views based on feed tags (show me all Germany based blog items of this morning, show me every feed of from EU based coders)
* present views based on feed tags and item tags: show me Germany based blog items talking about topic X.
* show full text search results of all items mentioning a certain topic.
* store full text search queries
* present visually which topics seem to be hot in which community, or where the frequency of mentioning a topic has changed
* provide a search of feeds (not feeds content): do I already have this feed in my list, where’s the feed of author Y?
* pull in a machine translation on request

Micropub client needs to be embedded in the microsub client and should support:
* saving an article as markdown or as html, to disk, to Zotero
* creating a todo from it by amending a textfile,
* bookmarking it, either to my blog or some other target
* sharing something about it to my blog, to Mastodon through my blog
* replying to it, through my blog to Mastodon, Twitter, other blogs
* allow configuring new actions.
* choosing from multiple micropub endpoints

What do you think, should some of these features be provided by other components than they’re currently listed? Are features missing that you’d like to see in your ideal feed reader?

Replied to Adding Microformats to WordPress’s Twenty Twenty Theme by Jan BoddezJan Boddez (jan.boddez.net)
I recently moved another blog of mine back to “plain” WordPress, and in the process added microformats2 support to its Twenty Twenty child theme. Some remarks: I’ve yet to add a u-photo class to featured images, I used a bit of a trick to get post metadata to show below short-form posts rather...

Thank you Jan, I will study this in some detail, as I’m trying my inexperienced hand at creating a theme from scratch in WP. So getting some clues how to add MF2 support this way is very useful!