Edits friction-to-publish

posts/friction-to-publish.md

@@ -9,7 +9,7 @@ tags:
 - RSS
 ---
 
-I was having a conversation over email with [Louie Mantia](https://lmnt.me) on the weekend about how to get more people writing on their own domain. He had [envisioned](https://lmnt.me/blog/sketchbook/punk.html) a combination RSS reader and publisher a while back which I thought looked so great (no surprise there).
+I was having a conversation over email with [Louie Mantia](https://lmnt.me) on the weekend about how to get more people writing on their own domain. He had [envisioned](https://lmnt.me/blog/sketchbook/punk.html) a combination RSS reader and publisher a while back which I thought looked so great (no surprise there). He thinks [hand-making your own website](https://lmnt.me/blog/why-by-hand.html) is the best way for people to publish themeselves on the web. He even wrote up an [awesome guide](https://lmnt.me/blog/how-to-make-a-damn-website.html) on how to do it for people with no prior experience. I think people should own their writing (as in files) and that wrigin should be on their own domain, but I don't think that should mean that people have to learn how to code and understand FTP. While I obviously think html is charming and a great, expressive, language, I know most people are intimidated by the thought of writing code, even it's just markup and CSS.
 
 Most self-hosted publishing products have a fritcion problem when compared to writing on blogging products like Medium or X. For example, when I want to write a new post on this blog, I have to pull out my code editor, create a new Markdown file, write the post, and then push it to the repository. This is a lot of "not writing" when the goal is to write, not to mention that I have to know about Github and use `git` for it all to work.
 
@@ -18,122 +18,21 @@ Most self-hosted publishing products have a fritcion problem when compared to wr
 I think there's an opportunity to build (or adopt..?) a standard protocol that any blog server could implement which would define how a client can list, edit and create posts. We have this for making web requests to APIs, why not for publishing? Perhaps it could define a common standard for commenting and re-sharing?
 
 ```yaml
-openapi: 3.0.0
-info:
-  title: Blog API
-  description: API for managing blog posts
-  version: "1.0"
-servers:
-  - url: https://example.com/api
-paths:
-  /posts/:
-    get:
-      summary: List posts with pagination
-      parameters:
-        - in: query
-          name: page
-          schema:
-            type: integer
-            default: 1
-          description: Page number
-        - in: query
-          name: size
-          schema:
-            type: integer
-            default: 10
-          description: Number of items per page
-      responses:
-        '200':
-          description: A paginated list of posts
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/PaginatedPosts'
-    post:
-      summary: Create a new post
-      security:
-        - basicAuth: []
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/Post'
-      responses:
-        '201':
-          description: Post created
-  /posts/{canonical_id}:
-    patch:
-      summary: Update a post
-      security:
-        - basicAuth: []
-      parameters:
-        - in: path
-          name: canonical_id
-          required: true
-          schema:
-            type: string
-          description: Canonical ID of the post to update
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/Post'
-      responses:
-        '200':
-          description: Post updated
-  /feed/:
-    get:
-      summary: Get RSS feed
-      responses:
-        '200':
-          description: RSS XML feed
-          content:
-            application/rss+xml:
-              schema:
-                type: string
-components:
-  securitySchemes:
-    basicAuth:
-      type: http
-      scheme: basic
-  schemas:
-    PaginatedPosts:
-      type: object
-      properties:
-        total:
-          type: integer
-        pages:
-          type: integer
-        page:
-          type: integer
-        size:
-          type: integer
-        items:
-          type: array
-          items:
-            $ref: '#/components/schemas/Post'
-    Post:
-      type: object
-      properties:
-        canonical_id:
-          type: string
-        title:
-          type: string
-        content:
-          type: string
-        date:
-          type: string
-          format: date-time
-        tags:
-          type: array
-          items:
-            type: string
+# Scaffold blog site protocol:
 
+# Public endpoints
+- GET /posts/
+- GET /posts/{canonical_id}
+- GET /feed/ # RSS feed
 
+# Private (Requires Basic HTTP Auth headers)
+- POST /posts/
+- PATCH /posts/{canonical_id} # edit a post
+- DELETE /posts/{canonical_id}
 ```
 
-I looked into [ActivityPub](https://activitypub.rocks/), but it seems to be more focused on social media and it defines more of how a federated network can be used to share content rather than individual blogs on single tenant domains. Another interesting protocol is [WebMention](https://indieweb.org/Webmention), but it seems like there is a high degree of variability in [people's implementations](https://indieweb.org/Webmention#IndieWeb_Examples) and it only solves the comment box problem, not publishing. Another solutions I saw was [what Hey is doing](https://www.hey.com/features/email-the-web/). On Hey you can email `[email protected]` from your own address and it publishes the email as a blog post on your Hey blog. That's a cool idea because it will work from nearly anywhere and it you get drafts for free. 
+A client could be written in Swift for MacOS, React, etc. and could simply implement the protocol and work with anyones choice of blogging service (home made, open source, or totally centralized).
 
-I will keep digging to find what to do for Rook to make it dead easy to post to it.
+I was curious about prior art and so I looked into [ActivityPub](https://activitypub.rocks/), but it seems to be more focused on social media and it defines more of how a federated network can be used to share content rather than individual blogs on single-tenant domains. Another interesting protocol is [WebMention](https://indieweb.org/Webmention), but it seems like there is a high degree of variability in [people's implementations](https://indieweb.org/Webmention#IndieWeb_Examples) and it only solves the comment box problem, not publishing. Another solutions I saw was [what Hey is doing](https://www.hey.com/features/email-the-web/). On Hey you can email `[email protected]` from your own address and it publishes the email as a blog post on your Hey blog. That's a cool idea because it will work from nearly anywhere and it you get drafts for free. 
+
+I will keep digging to find what to do for Rook to make it dead easy to at least post to it...