NINE

Example assignment: https://archive.jgregorymcverry.com/5570-2/

Notice the replies underneath which came from other sites including my response which is mirrored on my site at https://boffosocko.com/2018/08/04/highlighting-some-of-my-favorite-edtech-tools/

Example podcast post for a class: https://archive.jgregorymcverry.com/2toponder-episode-one/

Notice the listen webmention in the comments which links to my listen response at: https://boffosocko.com/2018/08/06/2toponder-episode-one-intertextrevolution/ where I own a copy of the context and my own response. As a student, even if the originals disappear, I’ve got the majority of the important content from the course.

This post was originally published on Chris Aldrich

I’ve just noticed that in addition to my relatively obvious user RSS feed on Goodreads, there’s a separate hidden feed of just my reading status updates. It’s of the form https://www.goodreads.com/user_status/list/#######-user-name?format=rss where #######-user-name is the typical user number and name combination at one’s profile page.

This post was originally published on Chris Aldrich

Lurking, Twitter, The Commons, and Private Posts

Lurking

Yesterday I was catching up on chat logs and ran across a stub for lurking on the IndieWeb wiki. I cleaned up the formatting a bit and added some additional material. Later Ton Zijlstra dropped a link to his excellent article from 2004 on the topic: Lurking and Social Networks (though honestly, I first came by the link courtesy of our good friend Jeremy Cherfas who added it to the wiki page).

Lurking is the quiet watching/listening that what many people of the web do in chat rooms in order to begin gauging culture, learning jargon or lingo, and other community norms or unspoken principles before diving in to interact on a more direct level with other participants.

While the word lurking can have a very negative connotation, online it often has a much more positive one, especially in regard to the health and civility of the commons. Rather than rehash what Ton has done an excellent job of doing, I won’t go into the heavy details and history of online lurking, but instead, let’s take a look at where it isn’t in today’s social media landscape.

Twitter

Since 2004, Twitter and a slew of other social media has popped up on the scene and changed many of our prior behaviors concerning lurking. In particular, Twitter’s interface has made it far easier to either like/favorite a post or retweet it.

In comparison the the preceding era of the blogosphere represented by Tons’ post, Twitter has allowed people to send simple notifications back and forth about each others’ posts indicating a lower bar of interaction than writing a thoughtful and measured comment. Now instead of not knowing about dozens, hundreds, or thousands of lurkers, a (micro)blogger would more quickly know who many more of their readers were because they were liking or resharing their content. Naturally there are still many more potential lurkers who don’t interact with one’s posts this way, but these interactions in some way are like adding fuel to the fire and prompt the writer to continue posting because they’re getting some feedback that indicates they’ve got an audience. Twitter has dramatically lowered the bar for lurkers and made it more socially acceptable for them to make themselves known.

A mid-century imagining of a Twitter company sign on the side of a commercial building, but aged to the point that the sign is rusted, broken, and decaying from neglect
Twitter image from the collection Social Decay by Andrei Lacatsu

Of course, not all is rosy and happy in Twitterland as a result of this lowering the social bar. Because it’s so easy to follow almost anyone and interact with them, naturally everyone does. This means that while before one may have lurked a blog for weeks or months before posting a response of any sort, people are now regularly replying to complete strangers without an resistance whatsoever. While this can be valuable and helpful in many instances, oftentimes it comes off as rudely as if one butted into the private conversation of strangers at a public gathering. At the farther end of the spectrum, it’s also much easier for trolls to tag and target unsuspecting victims. As a result, we have the dumpster fire that Twitter has become in the past several years for many of its users.

The problem for the continued health of the commons is how can we maintain a bar for online lurking, but still provide some feedback? How can we keep people from shouting and yelling at passer-by from their proverbial front porches or vice-versa? How might we encourage more positive lurking online before directly jumping into a conversation? 

Read Posts and Private Posts

For several years now, as a part of the IndieWeb movement, I’ve been more directly controlling my online identity and owning my content by using my own domain name and my own website (boffosocko.com). While I still use Twitter, I’m generally only reading content from it via a feed reader. When I post to or interact with it, I’m always publishing my content on my own website first and syndicating a copy to Twitter for those who don’t own their online identities or content and (sadly) rely on Twitter to do that for them. 

Within this setting, since roughly late 2016, I’ve been posting almost all of what I read online or in books, magazines, or newspapers on my own website. These read posts include some context and are often simply composed of the title of the article, the author, the outlet, a summary/synopsis/or first paragraph or two to remind me what the piece was about, and occasionally a comment or two or ten I had on the piece.

screencapture of a read post on my website
An example read post with context from my website at https://boffosocko.com/2019/06/02/lurking-and-social-networks-ton-zijlstra/

In tandem with these posts, I’m also sending webmentions to the websites of those pieces. These (experimental) read webmentions are simply notifications to the originating site that I’ve read their piece. In our prior framing of lurking or Twitter, I’m sending them the simplest notification I can think of to say, “I’m here lurking. I’m reading or looking at your work.”

I’m not saying that I liked it, favorited it, disliked it, bookmarked it, commented on it,  or anything else, but simply that I read it, I consumed it, I spent the time to interact with it. But in contrast with Ton’s older method of looking at server logs to see what kind of traffic his posts are getting, he can see exactly who I am and visit my website in return if he chooses. (Ton’s old method of sifting through those logs was certainly not a fun experience and the data was usually relatively anonymous and useless.) These newer read notifications could potentially give him a much richer idea of who his (lurking) audience actually is. Then when someone shows up with a comment or reply, it’s not completely from out of the dark: they’ve previously indicated that they’re at least somewhat aware of the context of a potentially broader conversation on his site.

These read notifications are semantically different from likes, favorites, or even bookmarks on other platforms. In fact many platforms like Twitter, which has moved from “stars” (with the semantic idea of a favorite) to “hearts” (with the semantic idea of a like), have so few indicators of reaction to a post that the actual meaning of them has been desperately blurred. Personally I’ll use Twitter’s like functionality variously to mean: “I’m bookmarking this (or the linked article within it) for reading later”, “I like this post”, “I’ve read this post”, or even “I’m acknowledging receipt of your reply to me”. That’s just too much meaning to pack into a silly little heart icon.

Because I’m using my own website over which I have complete control, I can make it do a better job of unpacking some of this semantic tom-foolery. I’ve written about it a bit in the past if you care to see some of the details: Thoughts on linkblogs, bookmarks, reads, likes, favorites, follows, and related links. See also: the read-posts tag on this site.

If they choose, some website owners display these read post notifications in one or more ways. Some sites like Aaron Parecki’s or Jeremy Keith’s will show my interactions as bookmarks. Others, primarily WordPress-based websites that support Webmention (via plugin), will actually show these interactions in their comment sections under the heading “Read” and display my photo/avatar as an indicator that I’ve interacted with that post. In the case of read posts on which I’ve written one or more comments, the receiving site also has the option of showing my interaction not as a read/bookmark intent, but could also show my comments as a reply to their post. I’ve written a bit about this and its potential for large news outlets before in Webmentions: Enabling Better Communication on the Internet for A List Apart. There are also some older legacy sites that might show my interactions as a trackback or pingback, but these seem few and far between these days, particularly as those systems are major targets for spam and the Webmention protocol has a richer interaction/display model.

screencaputure showing how Jeremy Keith displays my read post as a bookmark. The relevant section reads: "# Bookmarked by Chris Aldrich on Thursday, April 11th, 2019 at 1:31pm"
How Jeremy Keith displays shares, likes, and bookmarks (including my read post) in the comment section of his website.
Facepiled Likes, Reads, and Mentions in the comment section of the online newspaper with a heading "Reading" under which appears an avatar indicating one person has read the article.
The display of a read post on ColoradoBoulevard.net

A new itch

But as I think about these read posts, lurking, and being more civil on the internet, I have a new itch for some functionality I’d like to add to my website. I very frequently use my website as a digital commonplace book to collect links of things I’ve read, watched, and listened to. I’ll collect quotes, highlights, and even my own marginalia. As I mentioned above, my read posts sometimes have comments, and quite often those comments are really meant just for me and not for the author of the original post. In many cases, when my comments may be too egregious, sensitive, or perhaps even insulting to the original author, I’ll make these posts private so that only I can see them on my site.  Of course when they’re private, no notifications are sent to the site at the other end of the line.

Sometimes I would like to be able to send a read notification to the site, but also keep my commentary privately to myself. This allows me to have my notes on the piece and be highly critical without dragging down the original author or piece who I may not know well or the audience of that same piece which I haven’t properly lurked (in the positive community-based sense indicated above) to be as intelligently and sensitively commenting as I would otherwise like. Thus I’d like to build in some functionality so that I can publicly indicate I’ve read a piece (and send a notification), but also so that I can keep the commentary on my read private to either myself or a smaller audience.

I suspect that I can do this in a variety of meta-fields on my website which aren’t shown to the public, but which might be shown to either myself or logged in users. In some sense, this is a subset of functionality which many in the IndieWeb have been exploring recently around the ideas of private posts or by limiting the audience of a post. In my case, I’m actually looking at making a post public, but making smaller sub-portions of it private.

To begin with, I’ll most likely be looking at doing this at a small scale just for myself and my commonplace book, as I can definitely see second and third-order effects and a variety of context collapse issues when portions of posts are private, but others who may be privy to them are commenting on those pieces from the perspective of their public spheres which may not be as private or closed off as mine. i.e.: While I may have something marked as private, privy readers will always have the option of copy/pasting it and dragging it out into the public.

For those interested, I’ll briefly note that Sebastiaan Andeweg just wrote Private posts: the move of the checkins which has some useful and related background to private posts. (Of course I remember exactly when I read it.) I also highly suspect there will be a private posts related session(s) at the upcoming IndieWeb Summit in Portland in June (tickets are still available). I’m interested to see what others come up with on this front.

Lurking, Twitter, The Commons, and Private Posts was originally published on Chris Aldrich

Extending a User Interface Idea for Social Reading Online

This morning I was reading an article online and I bookmarked it as “read” using the Reading.am browser extension which I use as part of my workflow of capturing all the things I’ve been reading on the internet. (You can find a feed of these posts here if you’d like to cyber-stalk most of my reading–I don’t post 100% of it publicly.)

I mention it because I was specifically intrigued by a small piece of excellent user interface and social graph data that Reading.am unearths for me. I’m including a quick screen capture to better illustrate the point. While the UI allows me to click yes/no (i.e. did I like it or not) or even share it to other networks, the thing I found most interesting was that it lists the other people using the service who have read the article as well. In this case it told me that my friend Jeremy Cherfas had read the article.1

Reading.am user interface indicating who else on the service has read an article.

In addition to having the immediate feedback that he’d read it, which is useful and thrilling in itself, it gives me the chance to search to see if he’s written any thoughts about it himself, and it also gives me the chance to tag him in a post about my own thoughts to start a direct conversation around a topic which I now know we’re both interested in at least reading about.2

The tougher follow up is: how could we create a decentralized method of doing this sort of workflow in a more IndieWeb way? It would be nice if my read posts on my site (and those of others) could be overlain on websites via a bookmarklet or other means as a social layer to create engaged discussion. Better would have been the ability to quickly surface his commentary, if any, on the piece as well–functionality which I think Reading.am also does, though I rarely ever see it. In some sense I would have come across Jeremy’s read post in his feed later this weekend, but it doesn’t provide the immediacy that this method did. I’ll also admit that I prefer having found out about his reading it only after I’d read it myself, but having his and others’ recommendations on a piece (by their explicit read posts) is a useful and worthwhile piece of data, particularly for pieces I might have otherwise passed over.

In some sense, some of this functionality isn’t too different from that provided by Hypothes.is, though that is hidden away within another browser extension layer and requires not only direct examination, but scanning for those whose identities I might recognize because Hypothes.is doesn’t have a specific following/follower social model to make my friends and colleagues a part of my social graph in that instance. The nice part of Hypothes.is’ browser extension is that it does add a small visual indicator to show that others have in fact read/annotated a particular site using the service.

A UI example of Hypothes.is functionality within the Chrome browser. The yellow highlighted browser extension bug indicates that others have annotated a document. Clicking the image will take one to the annotations in situ.

I’ve also previously documented on the IndieWeb wiki how WordPress.com (and WordPress.org with JetPack functionality) facepiles likes on content (typically underneath the content itself). This method doesn’t take things as far as the Reading.am case because it only shows a small fraction of the data, is much less useful, and is far less likely to unearth those in your social graph to make it useful to you, the reader.

WordPress.com facepiles likes on content which could surface some of this social reading data.

I seem to recall that Facebook has some similar functionality that is dependent upon how (and if) the publisher embeds Facebook into their site. I don’t think I’ve seen this sort of interface built into another service this way and certainly not front and center the way that Reading.am does it.

The closest thing I can think of to this type of functionality in the analog world was in my childhood when library card slips in books had the names of prior patrons on them when you signed your own name when checking out a book, though this also had the large world problem that WordPress likes have in that one typically wouldn’t have know many of the names of prior patrons necessarily. I suspect that the Robert Bork privacy incident along with the evolution of library databases and bar codes have caused this older system to disappear.

This general idea might make an interesting topic to explore at an upcoming IndieWebCamp if not before. The question is: how to add in the social graph aspect of reading to uncover this data? I’m also curious how it might or might not be worked into a feed reader or into microsub related technologies as well. Microsub clients or related browser extensions might make a great place to add this functionality as they would have the data about whom you’re already following (aka your social graph data) as well as access to their read/like/favorite posts. I know that some users have reported consuming feeds of friends’ reads, likes, favorites, and bookmarks as potential recommendations of things they might be interested in reading as well, so perhaps this would be an additional extension of that as well?


[1] I’ve certainly seen this functionality before, but most often the other readers are people I don’t know or know that well because the service isn’t huge and I’m not using it to follow a large number of other people.
[2] I knew he was generally interested already as I happen to be following this particular site at his prior recommendation, but the idea still illustrates the broader point.

Extending a User Interface Idea for Social Reading Online was originally published on Chris Aldrich

Manually adding a new post kind to the Post Kinds Plugin for WordPress

The Post Kinds plugin, essentially an extended version of WordPress’s core Post Formats functionality, allows one to make a variety of types of posts on one’s website that mirrors the functionality provided in a huge variety of social media platforms. This is useful if you’re owning all of your own data and syndicating it out to social silos, but it’s also great for providing others better user interface for reading and consuming what you’re posting.

I’ve documented and written about it quite a bit in the past and am obviously a big fan. In addition to most of the default post types (notes, favorites, likes, bookmarks, reads, listens, etc.), my personal site also supports follows, eat, drink, wishes, acquisitions, exercise, and chickens! Wait a second… CHICKENS?!?

Yes, that’s chickens, not checkins, which I also support.

One of the nice benefits of the plugin is that it’s fantastically modular and extensible. As an exercise a few months back I thought I would take a shot at adding chicken post support to my website. Several years ago in the IndieWeb, partly as an educational exercise and partly for fun, several people thought it would be nice to add a post type of “chicken” to their sites. What would it look like? What would it entail? How might it evolve? Since then interest in chicken related posts has naturally waned, but it does bring up some interesting ideas about potential new pieces of functionality that one might want to have on their personal websites.

While I currently support many post types, I’ve discovered recently that I have a variety of notes and checkins that relate to items I’ve purchased or acquired. I thought it might be worthwhile to better keep track on my own website of things I acquired  in a more explicit way to make posting them and searching for them a lot easier. But how could I do this myself and potentially contribute it back to a broader base of other users? I started with a bit of research on how others have done this in the past and tried to document a lot of it on the Indieweb wiki. I eventually asked David Shanske to reserve the idea of acquisitions within the Post Kinds plugin, which he did, but I wondered how I might have done some of that work myself.

So below, as an example, I thought I’d write up how I’ve managed to add Chicken posts to my website. To a great extent, I’m using data fields and pieces already built into the main plugin, but in doing this and experimenting around a bit I thought I could continue to refine chicken posts until they did what I wanted, after which, I could do a pull request to the main plugin and add support for others who might want it. Hopefully the code below will give people a better idea about how the internals of the plugin work so that if they want to add their own pieces to their sites or contribute back to the plugin, things might be a tad easier.

Pieces for a new Post Kind in WordPress

Adding a new Post Kind primarily consists of three broad pieces  which I’ll address below. The modularity of the plugin makes adding most of the internals for a new kind far simpler than one might imagine.

Adding Taxonomy Support

New kinds in general will require a small handful of properties which include:

  • a name (as well as its singular, plural, and verb forms);
  • a microformats 2 property;
  • a format, so that the plugin can map the new post kind to a particular Post Format type within WordPress core so that themes which use these can be properly set when needed. Format options include: aside, image, video, quote, link, gallery, status, audio, and chat. Some post kinds may not have an obvious mapping, in which case the value can be left as empty;
  • a generic description for display within the admin user interface as well as for the archive pages for the type which are auto-generated;
  • a description-url, typically this is a link to the IndieWeb wiki that has examples and details for the particular post kind. If there isn’t one, you could easily create it and self-document your new use case. It could even be empty if necessary;
  • A show setting with a value of true or false to tell the plugin to default to showing the kind in the Post Kinds “Kinds” metabox so that the new kind will show up and be choose-able from within the interface when creating new posts.

Code to include these pieces of data will need to be added to the /includes/class-kind-taxonomy.php folder/file path within the plugin so that the plugin knows where it needs to be found.

As an example, here’s what the code looks like for the bookmark kind:

'bookmark'    => array(
	'singular_name'   => __( 'Bookmark', 'indieweb-post-kinds' ), // Name for one instance of the kind
	'name'            => __( 'Bookmarks', 'indieweb-post-kinds' ), // General name for the kind plural
	'verb'            => __( 'Bookmarked', 'indieweb-post-kinds' ), // The string for the verb or action (liked this)
	'property'        => 'bookmark-of', // microformats 2 property
	'format'          => 'link', // Post Format that maps to this
	'description'     => __( 'storing a link/bookmark for personal use or sharing with others', 'indieweb-post-kinds' ),
	'description-url' => 'http://indieweb.org/bookmark',
	'show'            => true, // Show in Settings
	),

For direct comparison, and as an explicit example for my chicken post kind, here’s the block of code I inserted within the class-kind-taxonomy.php file immediately below the section for the acquisition type:

'chicken'    => array(
	'singular_name'   => __( 'Chicken', 'indieweb-post-kinds' ), // Name for one instance of the kind
	'name'            => __( 'Chickens', 'indieweb-post-kinds' ), // General name for the kind plural
	'verb'            => __( 'Chickened', 'indieweb-post-kinds' ), // The string for the verb or action (liked this)
	'property'        => 'chicken-of', // microformats 2 property
	'format'          => 'image', // Post Format that maps to this
	'description'     => __( 'Owning all the chickens. Welcome to my chicken feed.', 'indieweb-post-kinds' ),
	'description-url' => 'https://indieweb.org/chicken',
	'show'            => true, // Show in Settings
	),

You’ll probably notice that beyond the simple cut and paste, I haven’t really changed much. Syntax aside, most of these pieces are relatively obvious and very straightforward, but I’ll add some commentary about a few parts and what they do which may not be as obvious to the beginner. When creating your own you can copy and paste this same block into the code at the bottom of the list of other types, but you’ll want to change only the data that appears within the single quotes on each of the nine lines for the various settings.

For those not familiar with microformats you may be asking yourself what snippet to add for the property setting. The best bet is to take a look at the microformats wiki or look for possible examples of people doing the same type of post you’re doing and copy their recommended microformat. For extremely new and likely experimental edge cases, chances are that you’ll need to choose your own experimental microformat name. In these instances you can use prior microformats as examples and potentially follow the format. In my case I knew about the bookmark-of, like-of, favorite-of, and the experimental read-of, listen-of, and watch-of microformats, so I followed the pattern and chose chicken-of for my experimental chicken posts. One could also potentially ask for recommendations within either the microformats IRC/chat channel or the IndieWeb chat. If you create a new and experimental one, take a few moments to document your use case in the IndieWeb and/or Microformats wikis for others who come after you. Keep in mind that if you change the property name at a later date you will need to go into your database and change the wp_postmeta database meta_key field from mf2_property1 to mft_property2 so that WordPress will know where the appropriate data is stored to be able to display it.

Our new chicken post kind is available in the post editor because show is set to true

The show setting is fairly straightforward, but may not be as obvious to some. It has either a value of true or false. If the value is false, the new post kind won’t be displayed in the radio button options within the admin UI for creating new posts. If the value is true, then it will be available. The Post Kinds plugin has a number of reserved post kinds which aren’t displayed by default on most sites–primarily because they do not have appropriate views or data fields defined–but they could be enabled by changing the show flag from false to true. Most often we recommend you only show those kinds that you’re actively using.

Additional examples of the dozen or more standard post kinds can be found within the code to provide some additional potential clarity on what types of data each of them are expecting.

I debated a while on making the verb ‘chickened out’ instead of ‘chickened,’ but I chickened out thinking that it would make my posts something wholly different. Obviously you can now make your own choice.

With this chunk of code saved into the plugin, it is now generally aware of the new post kind and can save the appropriate data for this new kind of post.

Template/View Support

Now you’ll want to add some code to the plugin to tell the plugin how it should display the data it’s saving for your posts. The easiest way to do this is to copy and paste the code from one of the many default views already in the plugin and just change a few small pieces of data to match your post kind. This code can be created as a new file with your new matching post kind name (the one at the top of your code snippet above that appears on line 1 before the word ‘array’) in one of two places. If you put it in the views folder in the plugin, you may need to re-add it later on if the plugin updates. Otherwise you can add the code into a file which can be placed into a folder named kind_views in either the folder for your theme (or your child theme, if you have one.) We recommend placing it in your child theme, so if the parent theme updates, your code won’t accidentally be lost.

There are a variety of views for many post kinds available to stand as examples, so you can look at any of these and tweak them as you wish to get the output you desire. For more complicated output displays it might certainly help to have some PHP coding skills. For my chicken post kind I simply copied and pasted the code for the bookmark kind view and pasted it into a file named kind-chicken.php following the naming convention of the other files.

Below is a copy of the code I added for the chicken post kind which is nearly identical to the bookmark view with exception of changing the name of the template, adding u-chicken-of and changing the get_before_kind to chicken instead of bookmark. Note that because the chicken-of microformat is wrapped on a URL, it has the u- prefix, otherwise if it were on plain text it would have been p-chicken-of using the standard microformat h-, u-, p-, and e- syntax.

I also put both the u-chicken-of and the u-bookmark-of microformats in the view so that sites using the post type discovery algorithm that don’t recognize the chicken-of microformat won’t choke on the proverbial chicken bone, but will default back to thinking this post is of the bookmark type. I suspect that I could also have left the u-bookmark-of off and many would have defaulted to thinking this post was a simple note as well. You can make your own choice as to which you prefer as a default.

<?php
/*
 * Chicken Template
 *
 */

$mf2_post = new MF2_Post( get_the_ID() );
$cite     = $mf2_post->fetch();
if ( ! $cite ) {
	return;
}
$author = Kind_View::get_hcard( ifset( $cite['author'] ) );
$url    = ifset( $cite['url'] );
$embed  = self::get_embed( $url );

?>

<section class="response u-chicken-of h-cite">
<header>
<?php
echo Kind_Taxonomy::get_before_kind( 'chicken' );
if ( ! $embed ) {
	if ( ! array_key_exists( 'name', $cite ) ) {
		$cite['name'] = self::get_post_type_string( $url );
	}
	if ( isset( $url ) ) {
		echo sprintf( '<a href="%1s" class="p-name u-url">%2s</a>', $url, $cite['name'] );
	} else {
		echo sprintf( '<span class="p-name">%1s</span>', $cite['name'] );
	}
	if ( $author ) {
		echo ' ' . __( 'by', 'indieweb-post-kinds' ) . ' ' . $author;
	}
	if ( array_key_exists( 'publication', $cite ) ) {
		echo sprintf( ' <em>(<span class="p-publication">%1s</span>)</em>', $cite['publication'] );
	}
}
?>
</header>
<?php
if ( $cite ) {
	if ( $embed ) {
		echo sprintf( '<blockquote class="e-summary">%1s</blockquote>', $embed );
	} elseif ( array_key_exists( 'summary', $cite ) ) {
		echo sprintf( '<blockquote class="e-summary">%1s</blockquote>', $cite['summary'] );
	}
}

// Close Response
?>
</section>

<?php

Icon Support

Finally, you’ll want to include the appropriate svg icon within the plugin so that it will display on the post (if the appropriate settings are chosen within the plugin’s settings interface: either “icon” or “icon and text”), and within the Kinds metabox in the post editor.

You’ll want to have one icon named kindname.svg in the svgs folder and another named kinds.svg in the plugin’s root folder. The kinds.svg is a special ‘master’ svg of all of the kinds icons bundled together. If it helps in matching the icon set, all of the current kind icons are made with Font Awesome icons which have the appropriate licensing for distribution.

In my chicken example, I opted for the feather icon since Font Awesome didn’t have an actual chicken available.

When you’re done

Thanks to the rest of the plugin’s functionality, you should now automatically be able able to make and display individual chicken posts, display a chicken feed (pun intended), and allow people to subscribe to the RSS feed of your chicken posts.

Creating a plugin for new kinds

Naturally some people may want to display particular exotic kinds which might not extend to the broader public. A chicken post type certainly falls under this umbrella as I wouldn’t expect that other than for novelty, obsessive IndieWeb post kinds completeness, or for a very small handful of specialized farming, juggling, or comedy websites that anyone else in their right mind would really want to be doing a lot of posting about chickens on their site.

David Shanske, the plugin’s creator, has made it possible to create a sub-plugin of sorts so that one can add one-off support to these types using  a variety of filters and functions. This could be useful so that updates to the plugin don’t overwrite one’s work and require adding the pieces outlined above back in again. Sadly, this is a tad beyond my present abilities, so I won’t address it further at the moment other than to say that it’s possible and perhaps someone might document it for others to use a similar template in the future.

Try it yourself

Now that you’ve got the basics, it should be relatively easy to add many of your own new post kinds.

Exercise One

If you want a simple exercise, you should be able to go into the code and manually change the show flags for the eat and drink kinds from their default false to true to enable posting food to create a food diary on your website. (These have a reasonable default view and icons already built in.)

Exercise Two

With slightly more work you can change the show flag on the follow kind and copy a view based on the bookmark view to make a follow view to make follow posts. (Here’s a link to my version.) Similarly other hidden kinds like wishes and acquisitions can be enabled easily as well. These also have default icons already built in, but just need a view defined to show their data.

Exercise Three

If you want a slightly larger challenge that uses all of the above, why not attempt adding the appropriate machinery to create a want post?

Exercise Four

Though David has often said before that he wouldn’t build in support for multi-kinds, some people may still want them or think they need them. If you’re exceptionally clever, you might be able to create your own explicit multi-kind by mixing up the details above and creating a kind that mixes a variety of the details and creates a view that would allow the specific multi-kind you desire. Caveat emptor on this approach if you should take it.

Share your ideas

Now that you’ve got the general method, what kinds are you going to deploy in the future? What have you already created? Feel free to reply with your ideas and thoughts below in the comment section or send us a webmention from your own site with what you’ve done. Maybe consider doing a pull request on the plugin itself to add the functionality for others?
​​​​​​​​​

Manually adding a new post kind to the Post Kinds Plugin for WordPress was originally published on Chris Aldrich