30: Walking before you runtime
This week I actually used Fancynote, in both ways it's meant to be used, for writing and programming. Both experiences were just successful enough to keep me satisfied and just frustrating enough to get me fired up to make it better. I'm starting to barely see the outlines of a useful tool here. But, it's not enough to make the experiences for both uses better. I want to converge them.
Right now I use fancynote the software library to program fancynote the application, which I use to write notes. I want to do both of those in the same place, using the same set of primitives.
To ground this a bit, let's talk about what I actually did, and then maybe use that to look at what I want to be able to do.
Writing
On the notetaking side I wrote my daily journal. The actual writing process is a
little painful. All editing just takes place in a single textarea, the
browsers basic input for editing blocks of text. This means I don't have any of
the ameneties I'm used to, like keyboard navigation and selection, or
autocomplete, or anything really.
From an interface perspective I was struggling with how little context I was able to work with. I was writing my journal each day in the context of a week but I could only view a small chunk of it at once.
Programming
I decided to start with backlinks, as that's been on the backlog for ages, and is a pretty useful building block for a lot of other things! There's a pretty large design space for a feature like this, so I needed to quickly iterate and try different things out. Unfortunately, the core structure of fancynote isn't quite amenable to that, so I had to take some time to improve it. Specifically I had to dig into how views are built and instantiated.
Of course, that wasn't too straightforward and I ended up creating some tricky bugs, that dissapeared all my notes! The stakes are high when you're debugging to recover the writing you've been doing.
Adding to the stress there is that the tools for debugging were far removed from the specific context of Fancynote. I didn't have a lot of insight into what changes were being made to the database, or when views were reacting to htem.
Some hypotheticals
Okay so there were a lot of problems and rough edges on both sides of fancynote, writing and programming. While I can think of solutions for the immediate problems, what I'm most interested in is building tooling to help me quickly iterate on all problems.
Focusing on the programming side: What if I could build an interface for writing, editing, and debugging programs the programs for views inside fancynote itself? That way I could build up that specific context, like tracking every write to the database, or showing how a view changes by stepping through different notes.
Interestingly, this is really quite analogous to the kinds of interfaces I want to build for notetaking as well!
The thought process is even similar. I'm executing, and want a very specific tool to help me do the work I want to do. In the context of notes, maybe it's a tool to view all the tasks related to the essay I'm writing. In the context of the program maybe its a tool to view all the changes I've made to this code side-by-side.
I think it's important to note that both those examplees would be equally useful for the other task as well, task management for code and version control for writing!
If everything is just notes, I could use the same tooling I use to make interfaces for notes, to make interfaces for programming (to make interfaces and tooling!).
In concrete terms, what this amounts to is moving the writing of code for fancynote into "runtime". I need to have a way to write javascript code inside fancynote notes that then get parsed and executed by the application, while it's running. There should be as small a core as possible, while allowing views and interfaces to all be definined at run time on top of it.
I think I have the start of an idea of how to implement this, but it's going to take a bit of experimentation.
Walking before run -time
Before I do this though I need to take some time and clean things up! The bugs I encountered this week are a result of the rushed implementation I did while just trying to get everything working. Now that I've used it for a little bit and have a top-level view of how everything comes together I should be able to refactor it all to be much cleaner.
On top of that, I'm begining to feel a bit tongue-tied actually talking about fancynote. I need to give things in it's architecture better names, and lay out in some nice document how everything connects together.
We'll see how much of this I actually get to!
Oh! If you made it this far, we're gearing up to launch some exciting things on hyperlink.academy soon and you should 100% check it out and signup for the newsletter if you're interested!
See you next week :D