A couple months ago, I wrote a short piece for the Sublime zine about my vision for collaboration,

What if We Could See Each Other’s Thoughts?

When you asked me to do something, I would know why you think it matters. If I told you my plan, you would know the thinking behind it.

Instead of debating what to do, we could discuss why we need to do it. Instead of hiding behind a powerpoint proclamation, we could share our truer selves, and our rougher thoughts, and figure it out together.

The curse of humanity is that we can’t read minds, but we do need to work together. Every company I’ve ever worked with has struggled to connect what we need to do, to why we need to do it.

This is where whiteboarding comes in. The combination of writing and drawing anywhere you want can help us build ideas and solve problems together. No two whiteboards are the same because no two problems are ever the same.

Collaborating like this, in the spirit of openness and vulnerability, we can share our goals, assumptions and ideas, we can ask questions, make plans, have fun, and learn to trust each other.

Unless you’re unlucky enough to be using an enterprise software whiteboard.

Designing for the Journey

Here’s the prettiest screenshot for Miro I could find, taken from its marketing site, illustrating its many features in use,

Let’s say I have a cool idea you want to share with the group. Hold on, I’ve got some decisions to make first:

• I want to type my idea so I’ll use the Text tool
• Oh wait, should I add a Sticky Note instead? What’s the difference? Which pastel color should I choose in the sub-options that appear?
• Oh nooo, I clicked on the + button and 30+ additional tools popped up (seriously click that link, the list is nuts). Umm, what’s a Card? How is it different from a Text or Sticky Note?
• I see multiple Diagram, Flow Chart, and Mindmapping tools. So if I want to add an idea that’s connected to another idea, do I need to use one of those?
• What was my idea again?

This “what if design app, but business?” kitchen-sink UI makes it possible to produce high-fidelity diagrams and flowcharts – but it also ruins the whole point of a whiteboard. (Also, at this point, why am I not just using a real design tool?)

Drawing and writing on a physical whiteboard is a mode-less experience that anyone can do. Being at least as easy, expressive, and fun as a $10 sheet of plastic and some markers is the bare minimum that a software whiteboard should be.

Unlike text documents and spreadsheets whose general shapes were settled pretty early on, collaborative digital whiteboards have only been around for ~15 years or so.

Despite this, every app in this space follows the same dreary UI playbook. Maybe that’s the nature of enterprise apps for the fortune 500, but why should the rest of us suffer? I think we can do better.

Wide Interfaces vs Deep Ones

As products gain features their interfaces can grow either wider or deeper to accommodate them. It’s kind of like a lake,

Wide interfaces show you every tool and control upfront to make them easy to discover and quick to access. But as the number of options increases, they become visually overwhelming, requiring designers to stuff some things into submenus.

In the right context, this is great. Wide interfaces are ideal for specialized professional tools designed to produce high-fidelity outputs like pixel-perfect mockups, millimetre-accurate architectural plans, and complex 3D models.

Pro tools take a lot of time to learn, but they’re usually critical to your profession, so that’s time well spent.

But the same qualities that make them powerful for professionals, also makes them prickly for cross-discipline collaboration. Complex tools elevate experts and intimidate novice users from making unique contributions, nurturing groupthink.

Deep interfaces, on the other hand, present fewer controls upfront. More advanced features reveal themselves contextually as you add content.

Because these interfaces are easier to start using, they’re better for collaboration with a wide range of people and a wide range of skill sets. Everyone feels more welcome to contribute when the barriers are low.

Like a physical whiteboard, the outputs produced this way tend to be lower-fidelity and conceptual – ideal for problem solving and consensus building.

The downside of deep design is that advanced features are inherently harder to discover. Good help docs and sharing examples of advanced use can go a long way though.

The other challenge is that you can’t just wedge new feature buttons into a toolbar. You have to think through how features could be invoked contextually – and be okay with some features taking longer for users to unearth.

In practice, almost every app has a mix of wide and deep interface design decisions. Now that you can recognize them, you’ll see these patterns everywhere. Sorry about that.

Eternally WIP

When Kinopio was born 5 years ago, whiteboarding wasn’t on my radar, so its design comes from a totally different place.

In 2019, I introduced Kinopio, why I made it, and how to use it in Hello Kinopio. I think I got a lot right from the start.

Early on, I noticed that those who use Kinopio the most, also use it at work. It’s really motivating to see people using the tool I created to help shape the kinds of teams and companies that I’d love to work for.

Kinopio isn’t for the Fortune 500 – there’s plenty of enterprise options for them. I’m personally drawn to the people and teams who care about using great tools because they take pride in their work.

Ultimately, my goal is to create something that’s so effortless and toy-like you’ll invent new reasons to sink into it with your friends and teammates.

Special thanks to Aneesha and Kevin for helping edit this.

Comments…

On the eve of it’s 5th anniversary, I’ve decided to make the code for the kinopio-client app public. That means you can run Kinopio on your own computer, make changes, and share improvements.

kinopio-client on github

kinopio-client is the app that’s downloaded and run in your browser when you go to https://kinopio.club. It can save data locally, and to the kinopio-server.

Because the app weighs only ~220kb, in an alternate dimension where we didn’t have the Internet but had html, I’d ship kinopio to you on a single floppy disk. It wouldn’t even need to be high-density.

To be honest, opening up 5 years of private code does feel a bit intimate, like inviting someone over. I’ve cleaned the dishes and swept up, but … don’t look in that closest.

That said, compared to other commercial codebases, you might find it refreshingly straightforward. It’s just a node.js app and here’s the entire install process:

git clone https://github.com/pketh/kinopio-client.git
cd kinopio-client
npm install
npm install -g @vue/cli
npm install -g hostile
hostile set localhost kinopio.local

Then create an .env.local file containing VITE_PROD_SERVER=true.

And to run it:

npm run serve
https://kinopio.local:8080

Why Make Commercial app code public?

I’ve long been thinking about how to share the amount of work that goes into Kinopio. The more you know how something is made, the more you appreciate it – even more so when it’s a quality product built to last a lifetime.

But at the same time, making software isn’t like carving fountain pens or acoustic guitars. As much as I would like to sometimes, I don’t toil in meditative isolation until I’m ready to deliver the perfect timeless objet d’art.

By contrast, delivering software is more like delivering a gooey crying baby. It’s alive. Squirming, growing, and changing because the technologies it relies on do too. Physical materials rarely change, but web browsers, operating systems, and servers sure do.

The big benefit of public code for me is that it’s another way to share the work that goes into Kinopio. One more piece of the puzzle, in between diagnosing bug reports, discussing feature requests, and sharing updates on social media.

Some kind souls might contribute changes. But because Kinopio is such a complex interface-based app, I have no idea yet how often that’ll happen.

Risks?

Sharing the code for paid software carries some potential risks worth considering,

1. A counterfeiter could theoretically use the code to make a clone product. Commercial derivatives are prohibited by the license, but even if they ignore that, the forger would still have to reverse engineer their own kinopio-server. It’d be way easier to use an off-the-shelf infinite canvas library or tldraw instead.

2. Code contributions are appreciated, but having too many PRs to review can be very stressful. On paper, Kinopio is a one person operation, but I’m not really alone because I’ve got a community of users I trust that moderate discussions and answer questions when I’m not able to. As always, I’ll be relying on their help and generosity.

What Happens Next?

If you are interested in contributing, please by sure to read the contributor docs first. And just like in the discord and forums, there’s only one rule:

We’re all friends here, so let’s be cool, constructive, and always treat each other with respect.

Compared to a library or CLI tool, where new features and more options don’t really complicate basic usage, what the ‘correct’ thing to do for a GUI application is far fuzzier and subjective.

I’m looking forward to seeing what kind of activity takes place in the repo. Will I spend more time reviewing and less time coding? Maybe I’ll stream some live coding sessions?

With loving scrutiny,

– Pirijan, Kinopio Creator

Comments…

The latest release of Kinopio lets you work offline while in a subway, plane, or uncharted rainforest. When you come back online, your changes will be synced back up. And because the app no longer needs to wait for a network before loading, it starts up almost instantly.

Full offline support was the byproduct of building for speed and immediacy. From a multi-storage loading process, to a queue system to save grouped changes, and a UI status system to inform and reassure users – many separate systems come together to enable an experience that responds fast and works everywhere.

If you're curious, the overall architecture of Kinopio is described in How Kinopio is Made

Multi-Storage Loading for Speed and Truth

While running Kinopio, if you peek inside the Storage tab in your web inspector, you’ll see that each of your spaces is locally cached under a space-ID key with a stringified JSON value containing cards and other attributes that gets updated as you work.

This local-first approach is what enables new users to immediately start using the app without an account – because the best way to learn how to use Kinopio is by using Kinopio.

The kinopio-server enables editing your spaces on other devices, sharing public spaces, and real-time collaboration. In scenarios like these, the remote data on the server acts as the source of truth. But reading/writing remote data from servers is much slower than cached local data.

When loading a space, we can use both local and remote data together to get the best of both worlds, local speed and remote truth. The process goes something like this:

A helpful side-effect of this loading system is that when you’re offline, you’ll still be able to open your cached local spaces.

Grouped Updates Through an Operations Queue

In most apps there’s a 1:1 relationship between user actions and server routes. In a social media app when I write something and hit the Post button, my post is then saved to a server so that others can read it.

But in the case of Kinopio, items like cards and boxes which need to show updates in real-time as you interact with them, this means a new update on each keystroke when you type in them, and on each rendering frame while being dragged. But of course you can also paint-select multiple cards and move them around together, so potentially that’s >100s of updates a second.

If I was sending server requests for each update, even regular use would bang against the rate limit that exists to prevent the server from crashing.

Instead, all updates flow through centralized update methods which update: the local cache, app state, real-time broadcast stream, undo/redo history, and adds the update to the API operations queue so that multiple updates can be grouped together and sent to the server in a single request.

Especially worth noting is that operations currently in the queue are saved in localStorage, so if they fail the queue can be resumed later when connectivity improves.

Bringing It All Together with a UI Status System

Once you have systems that are local-first and resilient to connectivity issues, the actual loading the app offline part almost writes itself.

For offline loading, the vita-PWA build plugin generates a PWA manifest and service worker that instructs the browser to cache the app and its asset files locally. And when new releases are shipped, the browser updates its cache to the new version.

The last thing needed is to do is inform the user that Kinopio works offline and reassure them that their changes will be sync-ed up once they’re back online.

While offline, it might surprise users to learn that certain features aren’t available offline because they depend on the server, like global search. Those features display a little clickable offline info badge. Other features are more obviously not usable offline, like social or discovery feeds, which can just be hidden.

Essentially, I went through every dialog and button and decided whether I could either make it work offline, show an offline badge, or whether to hide it entirely.

Offline Is the New Luxury?

While using Kinopio offline to test features and write this post, I realized that working this way is a really nice way to concentrate even on my desktop computer.

I’ve never heard a productivity influencer say “hey just go offline sometimes”, but the offline web is here, it’s speedy, it’s the original focus mode.

Comments…

My earliest blog was pretty emo – totally what you’d expect from a teen of the 2000s. But what made it fun for me was the comments. New internet friends from around the world would comment on my posts and I’d comment on theirs. Before we knew it, we were a little community.

But for all the good times, comments come with the responsibility of guarding against spam and toxicity. In other words, it’s a job. But building our own communities is a job worth having in a world that’s noisier and spammier than ever.

On one side of the web, we have social media sites with engagement (i.e. outrage) driven feeds that keep us coming back. On the other, smaller sites and apps that are oases of calm in the storm – but which rarely give us a reason to return.

The good news is that it’s a lot easier to make an oasis engaging than it is to chill out at a nightmare mall. So maybe we can have it all?

How to Build a Comments System

Whoa wait, this might not be something you want to build yourself. I originally thought it’d take 2 days, but it took 2 weeks. Not just because I’m bad at estimates, but because my view of commenting was way too simple.

There was a time when this is how all early comment systems worked during those short-lived early days of trust and harmony on the web. But these days we need to also consider spam and toxicity.

Designing secure systems is easy. But designing slightly less secure systems that people actually want to use is way harder because you’ll have to choose the right tradeoffs for your specific goals.

As for my goals:

• Easy to use: as close to a classic commenting flow as possible; no sign up required
• Robust and timeless: This blog predates and will probably outlive most companies and their current authentication systems, so there is no “sign in with Google/Facebook/Github/X”
• A reason to come back: commenters can opt-in subscribe to email notifications of future comments on that post
• Reward trustworthy commenters: repeat commenters and those with kinopio accounts will get little badges
• Enjoyable details: commenter info (name, website, etc.) is saved so you don’t have to retype it next time. In-progress comments are backed-up as you type so if your browser crashes you won’t lose any work.
• Spam resistant: first time comments need to be approved, and all new comments are reviewed. More details on how moderation works below.

So here’s what the commenting system looks like now,

⏰ And lastly, every 2 hours the server checks to see if there are any new comments. If so, an email is sent to the subscribed commenters on that post.

If you’re looking for an easy alternative, I hear commento is pretty good. The reason I didn’t use it is because its sign in model didn’t fit with my goals. But also because it’s been years since I’ve been able to code just for fun – so I guess this was like a holiday gift to myself.

I hope this inspires you to add comments to your own blog. I had to leave out a lot of details to keep this readable so if you have any questions… leave a comment! ＿φ( °-°)/

Comments…