User:Jacky.wtf

From IndieWeb
(Redirected from jackyalcine)
Jump to: navigation, search

Jacky Alciné

(photo)

Pronouns: he/him

Jacky's a software engineer that likes to tinker.

https://jacky.wtf/about

Chat Nickname: jacky

Contact: https://jacky.wtf/contact

“Hey look,” [thumps table] “Microformats.” [laughs].

I really enjoy working on software and making it more simple to use for anyone interested. That said, I really like keeping my content on my own terms. You'll see that a lot of sections below might be out of date but will point to parts of my personal site that you can reference for more up to date bits.

At the time of writing, https://jacky.wtf, my personal site is Level 1. However, work is being done to skip to Level 3 by means of Koype.

Reasoning for IndieWeb

I (Jacky) can't remember how I stumbled upon the IndieWeb. It did happen around 2016-2017, however. My blog posts did show a transition but now it's become something I'm very passionate about. It's potentially the tooling we can use to help remove the heavy corporate influence in social media as well as making for more organic and natural places to be ourselves on this big world wide Web.

App Requests

Current Setup

I use Shock to present my site to visitors. It uses Koype, Sele, webmention.io and Telegraph currently to provide Micropub, IndieAuth and Webmention functionality respectively. Syndication to other silos is usually done using bridgy. Information about how I handle hosting is at https://jacky.wtf/colophon#hosting.

Projects

I work on a few projects to make my experience of the IndieWeb more pleasing and easier.

Itches

This is a place for me to drop some itches, ideas and thoughts around IndieWeb building blocks that I'd want to build and/or add to my personal site and projects.

  • Event management site dedicated for IndieWeb members
  • IndieWeb compatible (or -first!) app store
  • Native libraries to interact with IndieWeb sites
  • Simpler detection of what text formats a site can accept for Micropub
  • Elixir library for general purpose IndieWeb stuff
  • CLI tool for generating code snippets that are posted on my site
  • Question support [1]
  • List of other sites presented on my site
  • Protected content
  • Micropub media endpoint that allows me to use Nextcloud as my storage layer.
  • integrity of posts in the IndieWeb
  • Implement a tool to generate some common Wiki templates from user provided information to reduce barrier to contributing to the Wiki
  • Add logic to my site to translate it to other languages using https://projectfluent.org/
  • Providing an optimized video viewing experience on my site (TODO: expand)
  • Slug generation for posts on the fly
  • MF2-HTML to JSON side-by-side tools
  • backfeed of comments made on https://wordpress.com blogs and ones that support commenting using one's Wordpress account
  • backfeed of my purchases from ticketing sites to show up as an rsvp to a synthentic event. For movies, I'd like to associate it to their Wikipedia, TMBD, IMDB and Trakt pages with my rating and review (potential for syndication support to trakt)
  • backfeed of content I watch to show up as a "ticker" on my site as a sticky header with a duration factor
  • fitness information shown on a hourly graph on my site
  • p2p IndieAuth leveraging things like https://avahi.org/
  • normalizing the use of webactions on my site to make it easier to interact with it
  • implementing a Micropub bridge between the Wiki in an editor

Interactive Canonical Guides

As mentioned lightly in chat, having a site / set of pages that can serve as living examples of how the IndieWeb can work for one's site. Ideally, this would be concepts / ideas that have been implemented and works on a diverse array of sites and architectures. Things we can do for this would be:

The pages could be both descriptive and interactive, similar to https://www.twilio.com/docs/autopilot/guides/how-to-build-a-chatbot but in our case, we'd encourage people to use their own sites to do the "interactivity" and have these pages respond in real-time to their changes (like when they send Webmentions or handle rel-me verification).

The goal of the page is allow people (namely developers or code-friendly people) to "tinker" on their site in real-time and get immediate feedback.

Post Type "Linting"

Something that's happened to me a lot is the inability to make sure that my MF2 on my site is to my expectations without having to immediately inspect the HTML. The algorithm that I'd take on would be compiling a list of properties that are “known” on the Microformats wiki, grouping some by their expected post type to appear on, and checking the intersection of those properties to the properties present in a provided bit of HTML.

My requirements would be that this is something that I can run either as a binary in the terminal or hit at a URL from a remote service (probably https://ptd-lint.jalcine.dev in a few) and get information.

Output

The example output of someone messing up a like:

{
  "url": "checked-url",
  "issues": [
    {
       "html": "",
       "mf2": "",
       "types": ["note",
       "errors": [
          {"name": "property/misnamed", "found": "like-of"},
          {"name": "qol/missing-published"},
          {"name": "qol/missing-url"}
       ]
    }
  ]
}
  • Collect more examples of unintentional markup
  • Look into making rules something written in a declarative syntax (Lua?)

Syndication to my Newsletter

I currently keep a newsletter by using Buttondown. I'd like to leverage their ability to add a entry by using their privileged e-mail addressing service.

Flow:

  • Sign up on Buttondown
  • Get the private email private-HASH256@mg.buttondown.com
  • Provide a Webmention endpoint that knows what email address to use

I wrote the initial idea on my site.

2019-04-06: Piloting this idea under the project name "driftcask".

Gitea + IndieWeb Support via Webmention

I want to see if I hack the following features into Gitea (and maybe use it as a test bed for other kind of version control projects):

Opening Issues via Webmention

I'd want to be able to open an issue on a project by sending a Webmention to the repository's URI! This will require a new "issue-of" property / type so I can open them up there.

  • TODO: Figure out flow and response.

Replying Issues via Webmention

Submitting a response should be just as easy!

  • TODO: Figure out flow and response.
  • TODO: Figure out how to handle idempotent messages.

Submit Patches / Changes to a PR

Send changes to a PR that an author has permission to update with the provided patches in the sequential order specified.

  • TODO: Figure out flow and response.
  • TODO: Maybe leverage git-send-email.

GitLab supports sending patches and opening tickets via (privileged) e-mail

Send Webmentions in Linkable Text Regions

Final step would be to receive said mentions whenever a URI of the user or the nickname of the user is mentioned:

  • Text in a commit message
  • In a comment made in
    • Merge request
    • Issue text

Syndicator Detection

I'd want to have a way to detect and authenticate with a site that provides h-x-app information to expose what kind of syndication targets it can provide. The MF2 could look something like:

<section class="h-x-app h-syndicator">
  <h3 class="p-name"><a href="https://app.com" class="u-uid u-url">App</a></h3>
  <p class="e-content">This service can retrieve syndication requests to the following sources:</p>
  <ul>
    <li><a href="#" class="u-target p-name">Twitter</a></li>
    <li><a href="#" class="u-target p-name">GitHub</a></li>
    <li><a href="#" class="u-target p-name">Mastodon</a></li>
    <li><a href="#" class="u-target p-name">Newsletter</a></li>
  </ul>
</section>

The above would expose to a site in question that the app can syndicate to a particular set of destinations. One could then use these values (u-target) in their syndication endpoint. Ideally, the app would know which user it's coming from based on the host name provided or via a webmention to determine the user in question.

Format Detection

A request to one's Micropub endpoint can give information about the kind of formats in which one can set information to for creating new contet.

Determining

Another option to query from a Micropub client. The fields that come back under 'formats' would have the keys:

  • name: The name to show to the client
  • uid: The unique ID that the Micropub server would recognize.
  • help: Link to help information about formatting options.

If we use common UIDs all around then clients can switch to compatible editors with no problem.

GET /micropub?q=formats&for[]=entry

{
  "type": ["h-entry"],
  "formats": [
    {
      "name": "GitHub Flavored Markdown",
      "uid": "markdown+ghe",
      "help": "https://github.github.com/gfm/"
    },
    {
      "name": "Gruber's  Markdown",
      "uid": "markdown",
      "help": "https://daringfireball.net/projects/markdown/"
    },
    {
      "name": "Liquid",
      "uid": "liquid",
      "help": "https://shopify.github.io/liquid/"
    }
  ]
}

Posting With it

Similar to the create flow for Micropub.

POST /micropub?h=entry&content[type]=markdown-ghe&content[formatted]=<FORMATTED>

201 Created

Updating the Clients Page

One thing that's clear is that both Micropub/Clients and Microsub#Clients have a lot of information but it's not uniform. Here are some ideas:

Leveraging Tables

I'm proposing that we have a Clients page that does something like the table below:

Clients for the IndieWeb
Name Platform Supports
Indigenous (Android) Android Micropub, Microsub, IndieAuth
Indigenous (iOS) iOS Micropub, Microsub, IndieAuth

The cons to this flow is that it makes it hard to view and edit over time for those not too familiar with the Wiki syntax.

Leveraging Template

We use templates for highlighting people Jacky Alciné and chat boxes; we could implement one for clients and make it easy to have them present just enough information to get going. Some information we'd need:

  • a decent screenshot of what a high traffic / activity of the app looks like
  • (optional) a video of app launch, sign in and use
  • mentions of the things it supports spec-wise


XMPP Integration

Once I have my own XMPP account up and running, I'd like to work on the following things:

  • Using XEP-0108 to show my current status in my h-card
  • Using XEP-0118 to show what song I'm playing on my site
  • Leaning on XEP-0319 to indicate if I'm around for chat
  • Using XEP-0383 to allow on-site chat with visitors in a group room

Editor Presence Emission

I think Neovim plugin for Discord presence is really cool and would even be handy in a social reader capable of consuming this information. My site would be such a quasi-reader, showing it on my representative h-card whenever the page is refreshed (and eventually via a WebSocket). With a permitted set of folders, I'd want to show at least the file and location I'm currently editing. If I can detect it, I'd add more fields.

Fields:

  • File name (relative to project root)
  • VCS SHA
  • Link to file on VCS
  • project link and name
  • Language of the current file being edited (syntax)

Distributed Web

P2P/DWeb/HashWeb concepts interest me in the sense that the Web browser doesn't become the sole means of interacting with the IndieWeb. It can move it to be a thing that exists outside of the conventional Internet. My hope is to do the following (in some sort of order):

- Normalize how my site handles storage of posts to allow for editing across compatible clients - Create a wrapping library to normalize the operations to things like Micropub and Microsub operations - Present my site and content with the proper ACLs across different protocols (SSB and Hypercore) - Make working from the offline/p2p approach a first-class experience

Backup Service

Perhaps either as a command line tool or a Web service, the act of parsing known backup formats and converting them into a .bar file and allowing compatible services to either upload said .bar file or use the file to generate a series of Micropub requests to the remote service to backfeed from an archive. The same kind of logic can be used for generating backups from one's site (and converting a site crawl with Micropub requests for the store into a .bar file.

rel-subscribe proxy endpoint

First mused on in #dev, the idea of a service that allows you to use a traditional reader or provide an interface for picking a feed to follow and adding it to your Microsub service (for servers that are headless) came to mind. It'd be visible on one's own site by using rel-subscribe.

  • For sites that also support Micropub, it could be possible to prompt the user to create a follow post on their site to broadcast this behavior.
  • A sort of “follow back feed” can happen here for sites that are both Micropub- and Microsub-capable; by finding all the feeds of the people that they've marked as followed and that of the feeds listed in the Microsub channels and allow for easy following. It can be optimized for one-click if we detect MF2 on the site as a feed and use that.

Thoughts for Popups

MF2 Roundtable

  • In the case of a 'plain-text' fallback, should we leverage things like p-summary? For example, if I want to show a like in a RSS reader

Displaying Responses

  • Taking a cue from how micro.blog shows replies in the conversation view.

Automating Communication with Livestreaming

WIP

I enjoy live streaming, but have been stalling on doing so because I'd like to incorporate my site more into the process of it. I'd like to do the following things:

  • When I'm live for about 3 minutes, I'd like to post to my site that I am with some notes about what the stream would be about. I'd like to reference this post as the “live announcement” post.
  • As I continue to stream, I'd want to have a tool that allows me to post notes about what I'm doing (like a live-streaming journal; links I've come across and deemed as relevant and capturing notes about commits I've made during the stream). I'll call these “stream update” posts.
  • When the stream ends, I'd like to make an update saying how long it was for, how many updates I made and link to a recap post about the stream. This would be the “stream recap” post.

To keep my main feed uncluttered, I'm going to work on the following:

  • Set up a webhook with Owncast that talks to a private API that'll
    • (when going live)
      • send a Micropub request to my site for at least two minutes after I've begun streaming to create the live announcement post - creating it as a event with no end time with unlisted visibility
      • update my live page with a link to the going live post highlighting that I'm going live (this will toggle the preview of the livestream on that page) using Micropub
    • (when ending the stream)
      • send a Micropub request to my site whenever I end streaming to set the end time
      • mark the post as 'public' to allow other feeds to see it
  • (with a custom tool - GUI? TUI?)
    • provide an interface to add a type of update
      • bookmark: with the provided URL, optional tag and optional "referred by"
      • note: any kind of quick content can be captured, GUI would support markdown
    • allow for adding, removing, checking off, unchecking and "focusing" on a task item for the current event
      • these items would be stored under the livestream-checklist-item property of the current event
    • set the title of the current stream event
      • this should update the title in Owncast
      • and update it for the event as well
    • allow for selecting a game in my library as the active one
      • this will add a tag named "gaming"
      • a new gameplay post will be created and added a child to this event
      • (maybe) update category on twitch if one is found (otherwise use "Let's Play")

Backlinks

h/t to Chris Aldrich; these are pages I contribute

See Also