2023.12.08.

Simon Willison

Simon Willison is the creator of Datasette, an open source tool for exploring and publishing data. He currently works full-time building open source tools for data journalism, built around Datasette and SQLite.

Prior to becoming an independent open source developer, Simon was an engineering director at Eventbrite. Simon joined Eventbrite through their acquisition of Lanyrd, a Y Combinator funded company he co-founded in 2010.

He is a co-creator of the Django Web Framework, and has been blogging about web development and programming since 2002 at simonwillison.net

#Person #Development #Web

Refactor Things journaling

  • Create a repository for the original shortcuts
    • automation-things-journal
  • Journal About Things To-Do
    • Save the Things URL of the selected item
    • Create a new Drafts document with the date, published, things_url, title attributes in the frontmatter
    • I could also create a new text file directly using iA Writer URL schemes, and the Shortcut
      • Get the Things URL
      • Format the frontmatter
        • title → name of the selected Things item
        • date → the current date
        • published → false
        • things_url → URL of the selected Things item
      • Create the Markdown file with a timestamp and a slugged version of the selected Things item
  • Open Things To-Do Journal

#Journaling #Things

Refactor checklist journaling

Automation repository creation

I created the new repository for my first automation script. https://github.com/zsbenke/automation-taskpaper-checklists

It would serve as a demo.

  1. Include all files that are needed for the automation.
  2. Create a README.md file which describes what it does.
    • I could include the keyboard shortcut which triggers it.
  3. Record a demo.mov file
  4. Upload the demo.mov file to Vimeo with the name of the automation
    • Automation – Automation Name
  5. Link the demo.mov from Vimeo in the README.md

#Automation #Reference

Plans for TaskPaper journal changes

Since I want to use TaskPaper as just another editor app, I should move my interstitial journal file out of it.

I cancelled some parts of this project. → 2023-12-09_10-04

#Thread #Shortcuts #TaskPaper #Journaling #TheArchive

Switching to my Zettelkasten as a journal

I think I’m going to give up my TaskPaper journal. I just think The Archive app makes so much sense as a journal and Zettelkasten.

I can develop notes and journal about stuff here. It’s even have images integration, and I can use the old style Notational Velocity app.

Increase your productivity on personal projects with comprehensive docs and automated tests

  • Author: 2023-12-08_20-16-simon-willison
  • Increase your productivity on personal projects with comprehensive docs and automated tests - DCUS → DEVONthink Archive
    • The Perfect Commit → DEVONthink Archive
    • Using PRs and squashing commits is similar
    • GitHub issues can be archived → https://github.com/dogsheep/github-to-sqlite
    • Using GitHub as Zettelkasten
    • 2:58
      • Perfect commit
    • 4:00
      • Commit changes of one thing
    • 5:30
      • Incrementally building tests
    • 7:32
      • Documentation should live in the same repo as the code 2023-12-09_13-27
      • Catch missing updates in PRs
    • 8:55
      • Documentation tests
    • 10:10
      • Issue threads
    • 12:10
      • It’s like Bike planning
    • 13:40
      • Timestamped documentation
      • A timeline of changes
      • Keeping an issue thread ensures we have a background information on a code change → 2023-12-09_13-35
    • 14:08
      • Issue driven development
    • 14:55
      • Have this for Shortcuts
      • I can commit and export a shortcut
      • Keep them in one repository
      • I can keep automation scripts in Git repositories 2023-12-09_16-05
    • 15:20
      • Get back to something when you have notes
      • Programmers complain about distractions
      • When we keep a journal we automatically keep bookmarks for ourselves 2023-12-09_16-10
    • 16:40
      • Issues for everything, even life stuff
      • At this state, this is a project management app, like Things
      • I keep stuff like this privately, not in GitHub issues
      • I link it using Hookmark
    • 16:56
    • 18:14
      • Publish Markdown files to GitHub issues
      • I can create a new comment to have a way to I document my stuff
      • It will make my work more transparent
    • 19:30
      • Have an output about what did you done
      • Journal about what you did
      • Twitter threads
        • Or small status blog posts
      • PR description
      • Get a blog

#Thread #Literature

2023.12.07.

I developed a coherent Zettelkasten content pipeline

The following diagram explains the flow of my #Zettelkasten content pipeline.

  • Incoming information: reading
  • Incoming information: fleeting notes and ideas.
    • Fleeting notes and ideas are things that I came up with from my mind.
    • Usually, these are triggered via external events like reading.
  • Processing
    • All of these annotations, ideas, and notes are collected in my Things inbox, where I process them using progressive summarization / sense-making.
    • I highlight the interesting parts and then add these to separate Bike outlines with a link to the source.
    • I’m organizing these ideas in Bike, and then I export them into Zettelkasten notes through Drafts.
    • They will end up in my Zettelkasten as new notes ready for drafting.
  • Drafting
    • I use the #Drafting hashtag to keep track of my notes in iA Writer using a smart folder.
    • While editing my notes, I expand new ideas into separate notes created on the fly and linked.
      • I usually add the #Drafting hashtag to these too.
    • When a note is finished, I mark it with the #Linking hashtag
  • Linking
    • I also have a Linking smart folder in iA Writer for notes that must be added to my main outline.
      • I do linking on my Mac because I need a bigger screen.
      • I keep my outline source in Bike and add new notes there.
    • I find the note most appropriate place in my outline and add its ID and title there.
      • I have a shortcut that finds the corresponding note for the selected Bike row, assigns an ID according to its place in the outline, and links it from the Bike outline.
    • The next step is finding and linking related notes, which can be done in Bike or my outline directly on my Zettelkasten site.
      • This is the hard part, where I have to find a connection between the new notes and existing ones.
    • When satisfied, I export the Bike outline into a raw Markdown file for Jekyll and sync it up with my Zettelkasten site.
  • Searching
    • I mostly use The Archive to search and browse my Zettelkasten.
    • I also have private notes there, which are hidden from my published Zettelkasten so that I can keep track of other information in my Zettelkasten, too.

Screenshots of iA Writer smart folders setup

2023.12.06.

Using my Zettelkasten in DEVONthink

I indexed my #Zettelkasten notes in DEVONthink and also turned on syncing without uploading indexed items. On other devices, I also want to have this database synced, but I should also set it up the same way as on the original laptop.

I want to use DEVONthink to browse my Zettelkasten locally. It can even get and parse hashtags. But I can’t use hypens in the name of the hashtag for the Hungarian suffixes.

2023.12.02.

Manage multiple libraries in The Archive

There is a way to open a different archive when starting The Archive app from the Terminal.

$ open -n /Applications/The\ Archive.app --args -archiveURL "file:///Users/YOURUSER/path/to/notes/"

For example, I can open my Running Lists folder with this command.

$ open -n /Applications/The\ Archive.app --args -archiveURL "file:///Users/zsbenke/Documents/Running%20Lists/"

This will open a new instance of The Archive app. I’m not sure if that’s intended behavior, but it works for quick checks.

2023.12.01.

2023.11.27.

Ulysses writing workflow

  • Create a new project for each post
    • Posts that are long
    • Projects has their own set of rules
    • Duplicate the Post Template project
  • Writing
    • 🏷️ Drafting
    • 🏷️ Revise
    • Use the Resources folder for assets
  • Publish to the blog
    • I merge all revised sheets
    • Run them through Grammarly
      • Or use the built-in grammar checker in Ulysses
    • Publish the post to my blog
    • Let it sit for a couple of days
    • Archive the project

2023.11.17.

2023.11.03.

Leave permanent note linking to the Mac

  • Writing notes requires a different environment than linking notes.
    • Linking is about finding the connections between notes, while writing is about getting out our ideas from our fleeting notes in a focused manner.
  • When I do linking, I need to have a bigger display with multiple notes open so I can easily review them. An iPad screen size it’s just too small for this activity, so I like to do linking on a Mac.
    • Can linking be done on an external display on iPad using Stage Manager? 2023-11-17_21-44
  • I added an outliner-like JS module which converts Markdown lists into a togglable outline.
    • So in this note, this item can be hidden by pressing the arrow before the parent element.
  • I can also link to list items.
    • The outline-toggle controller calculates a checksum from the text on each item, and links them using the toggle arrows.
      • The checksum algorithm I used is available here.
    • When I paste the copied link back to the browser, I get a highlight effect for the linked block.

The capture log is an append only system

This note connects “2.16 Appending information is way to keep a history of changes” to “2.14.12 The capture log is an automatic journal”.

So I can see the capture log in the descendants of “Appending information is way to keep a history of changes 2.16”.

2023.11.02.

Git can be used for keeping the history of non-code based source files

  • I can set a Git repository for almost any source material which I’m working on, and I’ll have a nice history for these files.
  • Keeping a Git repository only works for file-based apps. It doesn’t work for database based apps like Ulysses, or Bear.
  • On top of Git, it’s still worth to keep manual versions for writings around, especially after reaching a milestone like the first draft, the first edit, or the version before spell checking. Manual versions usually work in database based applications too.
    • 2.16.3 Keeping manual versions in Ulysses.

The capture log is an automatic journal

A capture log is a journal-based version of the inbox, where ideas are getting captured. This was an idea mentioned by Merlin Mann 2024-10-23_08-21-merlin-mann for the first time, where he wants to yell into the void and let Siri capture his ideas, with automatic metadata like creation date, a location, and optionally the weather.

A capture log is kind of a journal about our ideas. It’s like a tail for our life.

There is a difference between the Inbox and Storage

The Inbox is a medium which contains items that change frequently. It is a temporary place that holds new information in the short term. It’s like a tail for our life as Merlin Mann said it 2024-10-23_08-21-merlin-mann. → 2.14.12

The Storage is a place which holds processed information on the long term, optimally organized in some form of fashion (2.8.2.4.5 The file system is a backend for our projects). Organization categories should have clean edges, so we know what to store where.

By using these two information holders, we can separate the processing and organization part of #GTD.

2023.10.31.

2023.10.30.

There similarities between naming things in programming and naming things in a Zettelkasten

  • When we have to name something we’re forced to think about its meaning.
  • Naming a #Zettelkasten note is similar to naming a class in programming.
    • In programming a class describes a set of related behaviors.
    • A name have to describe these behaviors in a way that makes sense for us (and other developers).
  • Phrasing a title for a note will force us to came up a simple clarification on the content of it. This requires understanding.
    • 2.6.11.5 A jegyzetcímekre API-ként kell gondolnunk

Change the outline level display

Follow-up on 2023-10-30_07-54:

I think the best possible solution would be to keep just the 1st, 2nd, and 3rd levels in the outline.

  1. 1st level should be visible since that’s my entry to a main branch.
  2. 2nd level should be visible because these are idea threads which can be developed.
  3. 3rd level should be hidden though because these can be real rabbit holes which needs digging down into actual notes. I show them by expanding the 2nd level.

All other levels can be removed. This would keep the outline usable.

2023.10.29.

Using my thinking tools in different contexts

Follow-up on 2.6.5.9.1:

  • I create project related notes in Things. 2.8.2.4 and 2.8.2.4.2
  • If I want to have a private and flexible #Zettelkasten, I can use Bike.
  • When I’m developing an idea which expands my knowledge in general, I can use my public #Zettelkasten.

Thinking with a digital Zettelkasten

  • My idea of having a flexible thinking space means that I should be able to expand an idea everywhere in my #Zettelkasten.
  • Using iA Writer as the thinking space, I can automate new note creation using my “New Zettel” shortcut, which creates a new empty note and copies its wikilink to the clipboard.
  • After creating the new zettel, it displays the quick open bar in iA Writer, so I can choose to open the new note, or dismiss the search pane and paste the wikilink into the current one.
  • The workflow with this approach is that I can quickly create new notes, but keep them in the drafting phase, so I continue developing them later.
  • When a note is properly expanded, I can add it to the outline with the final zettel ID, and link to other notes.

Maybe I should give up this zettel ID idea for all my notes. I have backlinks and a follow-up button to quickly add a new note about something.

My biggest problem with this Zettelkasten is that there is no way to start an idea in place. With Craft I had the ability to expand an idea in-place which I used a lot 2.6.9.5.2. I use outlining so heavily because of that.

But I still want to keep some notes and stuff connected to zettels, so I can go down into a rabbit hole if I want to without the need to create a new zettel in place. 2.6.5.9.1

Things is my Finder

I don’t browse my stuff by category or by area. I browse it by project.

Since I use #Hookmark to link related support material to my projects, I use the Things quick-find panel, to quickly jump to a project, then click on a link or invoke Hookmark to open a related asset.

Things is a taxonomy for my ideas

Since Things provides taxonomy for our life 2.10.4, by keeping ideas there, this taxonomy will be true for ideas instead of tasks. Things is my Finder 2.8.2.4.3.

Ideas need to be developed: the idea manager workflow 2.8.2.4 will make sure that I have a complete overview of all of my ideas organized into projects and areas.

Things to-dos can be a source of Reminders and Calendar based next actions

Follow-up on 2.8.2.4:

Next to Reminders, I also have to create Calendar events for Things to-dos. Having the next action creation automated, makes using Things as an idea manager easier.

When I run the New Next Action shortcut on the selected to-do, Shortcuts ask me if I want to create a new reminder or a new event. Events are created for the next day, then revealed in the Calendar, so I can continue to edit them.

Things can be used as an idea-manager

When I’m working with projects in a #GTD system, I need to have a way to plan projects. Previously I used external apps for this, but having a different view on my task manager app – combining it with Reminders for next steps – I can create an interesting use case for Things, where the app is used as an idea manager and not a task manager.

#Things allows me to create todos and attach long-formatted Markdown notes to them. In addition to that, having the date and checklist-related functionality let me add details on how a task should be performed.

In essence, a to-do for me in Things doesn’t mean a next action. It is closer to the analogy of Trello and cards.

The basic system is built on this foundation:

  • Each idea is represented as a todo.
  • An idea contains detailed planning.
  • The phases of the execution of an idea are tracked with tags, which can be Scoping, Ready, and Blocked.
  • Each idea belongs to a project (or area) and can be scheduled in the time constraints of Things (upcoming, anytime, someday).

An idea is something that is getting worked on as I get more information on the project. These todos are represented by a todo tagged with Scoping. If I have everything collected about the idea, then it gets the Ready tag. These todos no longer contain unknown details or questions, they are well-researched and ready for implementation.

When a todo is completed and needs review or it’s blocked, then it turns into a Blocked idea. I add a new item to the checklist about why it’s blocked, and I use notes to log the history of events. This is a remixed version of the “@Waiting for” list in #GTD integrated into the #Kanban-like status tags.

I don’t work from Things though since I need to have concrete next actions stored somewhere. Since I don’t want to mix plans with next actions, I integrate Reminders with Things (2.8.2.4.1 Things to-dos can be a source of Reminders and Calendar based next actions). Using Shortcuts automation, I can create a linked reminder for any selected Things item, and move it to the appropriate context list in Reminders. Having this separation makes it possible to use Reminders to store bookmarks where I can quickly jump into plans stored in Things. Since Things no longer contains next actions, it can be treated as a #Zettelkasten like #PKM app which is about ideas working towards a clear goal (projects).

  • I created a shortcut which can export the current Bike selection to a new Markdown file in my Zettelkasten.
  • It doesn’t sync like my publish script does with WordPress, but it was easier to implement, since copy and paste between Drafts and Bike works pretty well.
    • The shortcut just cleans up the text and sets the title if it’s needed.
    • Otherwise it will create a headless zettel.
  • At the end it opens the note in The Archive app where I can edit it, or publish it using Git.
    • This shortcut actually uses the following apps.
      • Keyboard Maestro to copy and paste the text from Bike to Drafts.
      • Shortcuts to clean-up the Markdown output.
      • Then Drafts to create a new Markdown file in my Zettelkasten.
  • Here’s a demo video
    • In the video Archive complains about the “writing test”.
    • It’s not related to the shortcut.

Published post → Follow-up on “Publish daily notes to my Zettelkasten from Bike” – Decoding

  • I debuged Jekyll last night and was able to update to 3.8.
  • Version 4.0.0, 4.0.1, and 4.1.0 throws an error:
    • sass-embedded-1.63.6-x86_64-linux-musl requires rubygems version >= 3.3.22, which is incompatible with the current version, 3.1.3
  • Version 4.2.x fails with a CSS issue and can’t keep the Bundler cache between Docker restarts.
    • I don’t really have time to debug these issues, since if I want to upgrade I’ll probably just switch to Bridgetown anyway.
    • I just want to use my Zettelkasten for now, not spending time on maintenance. Since Jekyll is just generating a static site here, there is no security issue of having an older version in use.

Git is an append-only information storage system

  • The workflow of appending new information can be used in the software #Development context.
  • Adding or removing code in a project will change its state, so when we store a snapshot in Git, we essentially keeping an append-only history of the codebase.
  • We shouldn’t worry about how changes are looking at one state, since code can be always formed. Actual state stored in Git will show changes, mistakes, refactorings, removals, which is the natural part of everyday work.

2023.10.28.

Csak úgy tudunk javítani a helyzetünkön ha elfogadjuk azt

Csak úgy tudunk javítani a helyzetünkön ha elfogadjuk azt. Ez az első lépése annak, hogy az irányításunk alá vegyük a dolgokat. Amikor ellenállunk, és/vagy nem vagyunk képesek elfogadni a dolgokat, akkor nem fogjuk megtalálni a kormányt.