Ink & Switch

Every to often a project will come along which reminds me of the visions which Hermann Hesse's _The Glass Bead Game_ (originally published as _Magister Ludi_) inspired in me --- this looks to be the latest. Looking forward to reading the paper and hope that it is widely read/discussed, and that it influences projects/developers such as: https://www.inkandswitch.com/ I'd dearly love to see a 3D CAD program which used this methodology.

The histogram is great, nice work; I want to ask about adjacent projects - user interface libraries that provide input elements for providing ranges and approximate values. I'm starting my search around https://www.inkandswitch.com/ and https://malleable.systems/catalog/ but I think our collective memory has seen more examples.

Not an article, but still highly recommend Why Can't We Make Simple Software? [0] by Peter van Hardenberg (head of Ink & Switch [1]). Disclosure: it was given at my tech conference. [0] https://vimeo.com/780013486 [1] https://inkandswitch.com

The work Ink & Switch (unaffiliated) do has been an inspiration to me with regard to local-first and decentralized software: https://www.inkandswitch.com They have a quasi-manifesto on local-first (https://www.inkandswitch.com/local-first/) and have published the best rich text CRDT around, Peritext: https://www.inkandswitch.com/peritext/ Lots of interesting work happening in this space.

Last year I stumbled upon the research articles about Muse development at Ink & Switch. They exude care and craftsmanship. Really fun to read. Highly recommended. Muse's newsletter is great, too. https://www.inkandswitch.com/ I didn't know anyone on the Muse team but was so curious I reached out and asked for beta access and they kindly gave it. I've been using for about a year. I really love it. My use cases are light -- hobby sketches, sundry visual notes -- but I keep finding more things to use it for because it's just so... fun. It's fun feeling so extended and free using a digital tool. I'm pleased to see it on HN front page.

Thanks for sharing, this is a cool project. I've been working on something similar on and off for a while, and I've found the space to be fascinating and somewhat puzzling. Most of the first questions I try to ask about these in browser notebooks don't have clean answers. In no particular order: - Do you have any ideas about solving logic errors? As it stands right now a while(true) loop crashes the page and consecutive re-openings of the page for a short while (in chrome). What about things like document.body.innerHTML = "" (you actually seem to handle this pretty gracefully, I'll see if I can poke more holes in this another time). For what it's worth none of the online notebooks I've seen have a satisfactory solution to infinite loops, loop timeouts are too blunt an instrument and crashing the tab can take the browser minutes to recover. - Is there a particular reason you use eval rather than the new Function constructor? From what I've read using new Function is much more performant, and other than different scoping a better choice than eval. Can't find the link at the moment, but it was wrapped up in the mdn[1] design docs for their codebox examples. - I see you're using the first codemirror 6[2] beta release, how are you liking it? I really enjoy the interface so far. - Do you have any favorite resources or inspirations about why you went about building a hackable offline local first notebook environment? I particularly like the experiments at Ink and Switch[3].…

It's both. I recommend looking into it a bit deeper https://www.inkandswitch.com/essay/local-first/

Regarding the growing log in CRDTs, it doesn't have to be that way. Most of these popular CRDT libs use Merkle DAG only to build up the log of the changes. But there is a better way, you can combine a Merkle DAG for ordering + prolly trees for storing the actual state of the data. That gives you total ordering, an easy way to prune old data when you choose to, and an easy way to sync. Look into fireproof for how this is combined. Regarding distributed schemas, I agree, there's a lot of complexity there but it's worth looking into projects like https://www.inkandswitch.com/cambria/ and https://github.com/grafana/thema, which try to solve the problem. It's a young space though. If anyone else knows about similar projects or efforts, please let me know. Very interested in the space.

I think I might have phrased my criticism too sharply, sorry about that. I wouldn’t have commented if I didn’t think you were making a worthy point though! There was an article about malleable software recently that used avocado slicers vs. kitchen knives as an analogy; the more I think about your piece, the more it resembles that concept. https://www.inkandswitch.com/essay/malleable-software/

See also their blog post on Fuzzy Constraints (2023). https://www.inkandswitch.com/untangle/ Madly in love with how forward a frontier Ink & Switch cuts towards. Trying to make software less of a handcrafted artifact that each individual corporation builds on their own, as they see fit, and making computing a broader more universal project, with more regular hooks for humans to get themselves in the loop. A lot of "why are we still writing dead programs" vibes, in great ways. https://jackrusher.com/strange-loop-2022/ https://news.ycombinator.com/item?id=33270235 (181 points, Oct 2022, 61 comments)

Mechanical merge algorithms can perform better or worse on different kinds of conflicts (the specific example of editing deleted text is just one of many edge cases) but in the end no CRDT can decide if your merged text is what you mean to say. We go into a bunch more detail in the Upwelling paper about the differences between (what we call) semantic and syntactic conflicts in writing: https://inkandswitch.com/upwelling/ Ultimately, my feeling is that serious collaboration is a document review problem as much as anything else. That said, this is particularly true in journalism and scientific publishing and can be mostly ignored for your meeting notes... Anyway, if you see this comment, thanks for a nice piece of writing, Alex. Love to see folks wrestling with these problems.

Wonderful work, but this doesn’t look like local first software to me. It looks like server first software with live updates and caching. Don’t get me wrong, that’s super cool - but if you’re going to claim it’s local first software, I want to see the principles of local first software at play. And I don’t think Zero delivers that - at least as I understand it from its website. Like, “the network is optional” and “the long now” and “you (the user) retains ultimate control”. It just looks like an excellent server sync system with client side caching. What if the data I need isn’t in the cache? What happens when I edit things offline then come online later? What happens if the company shuts down and the server gets turned off permanently? Will the app still work? Local first software can handle these cases too. [1] https://www.inkandswitch.com/local-first/

There is another excellent write-up exploring the theory / use-cases for such libraries https://www.inkandswitch.com/cambria/ (and a corresponding library at https://github.com/inkandswitch/cambria-project)

Good question! Compared to Protocol Buffers and Apache Avro, that each have their own specialised schema languages created by them, for them, JSON BinPack taps into the popular and industry-standard JSON Schema language. That means that you can use any tooling/approach from the wide JSON Schema ecosystem to manage schema evolution. A popular one from the decentralised systems world is Cambria (https://www.inkandswitch.com/cambria/). That said, I do recognise that schema evolution tech in the JSON Schema world is not as great as it should be. I'm a TSC member of JSON Schema and a few of us are definitely thinking hard on this problem too and trying to make it even better that the competition.

I just recently found out about automerge from this youtube channel. https://www.youtube.com/@localfirstfm I love the idea of "local first software" https://www.inkandswitch.com/local-first/

This is a great question! The short answer is by maintaining backwards compatibility in your schema--it's basically the easiest way to guarantee compatibility. We have warnings in place to let you know when you've made a change that isn't backwards compatible, you can read about it in our docs: https://www.triplit.dev/docs/schemas/updating#pushing-the-schema However, overtime this can naturally lead to a mess of a schema definition that has a lot of confusing names. We haven't released a solution to fix this yet but we're working on a few things that should make this less painful. For background on the various approaches, the Cambria doc is an amazing resource: https://www.inkandswitch.com/cambria/

Ink and switch has several projects and articles: https://www.inkandswitch.com/ Some folks from Ink and switch made a podcast that I've really liked: https://museapp.com/podcast/ Bret Victor (from Dynamicland) has lots of projects, articles, and talks: https://worrydream.com/Home2011/ The future of coding has a newsletter and a podcast, but I haven't dug into them: https://newsletter.futureofcoding.org/

The kind of scenario screams a local-first applications and solutions, and it's the reason why the Internet was created in the first place [1][2]. People have been duped by the misleading no software of Salesforce's advert slogan that goes against the very foundation and the spirit of the Internet. For most of its life and duration starting back in 1969, the Mbps is the anomaly not the norm and the its first killer application of email messaging (arguably the still best Internet application) is a local-first [3]. Ironically the culprit application that the author was lamenting in the article is a messaging app. [1] Local-first software: You own your data, in spite of the cloud: https://www.inkandswitch.com/local-first/ [2] Local-first Software: https://localfirstweb.dev/ [3] Leonard Kleinrock: Mr. Internet: https://www.latimes.com/opinion/la-oe-morrison-use24-2009oct24-story.h…

The idea of ”local first” is sort of related: https://www.inkandswitch.com/local-first/ I think tldraw is an application that does this well in the browser. When you open it up you can start working right away, your work is automatically saved in localstorage or similar, but you can always save to a file. And you can also click share and get live collaboration on the document. Saving to a file still works the same. It’s best of both worlds I think. I get the convenience of a web application with sync/collaboration, and I have control of the files if I want to. The format is plain JSON and if the original application goes away I could put together a renderer so that I can view the file.

I think they publish their research here: https://www.inkandswitch.com

More information: https://www.inkandswitch.com/potluck/demo/?openDocument=welcome and https://www.inkandswitch.com/

> Also, a product which the world needs badly.. would be a software which would abstract git and present text to lawyers as regular word processor, but in the backend it's git for the win. Ink & Switch Upwelling [0] goes into that direction. A must-watch is the StrangeLoop 2023 talk by Martin Kleppmann "New Algorithms for Collaborative Editing" [1] that excellently explains things. [0] https://www.inkandswitch.com/upwelling/ [1] https://yewtu.be/watch?v=Mr0a5KyD6BU

Worth noting that the author, James Long, is the same one who made a great talk on using CRDTs called CRDTs for Mortals [0], and he uses them in Actual as well. He was a great source of inspiration when I was looking into using them for my offline-first, local-first apps [1]. [0] https://www.youtube.com/watch?v=DEcwa68f-jY [1] https://www.inkandswitch.com/local-first/

This doesn’t appear to support rich text formatting ranges like bold, italic, etc - unless I’m missing something in the API. AFAIK Peritext is still the state of the art in rich text CRDT algorithms https://www.inkandswitch.com/peritext/ I’d love to see this build the rich text stuff from the Peritext algorithm.

Read this first: https://www.inkandswitch.com/local-first/ > Anyone who's worked inside a large organization knows the cloud is the solution to be able to get things done and deliver value to the business. Local first is focused on end consumer experiences and is orthogonal to the on-prem vs cloud argument; ideally there wouldn't even be a server. @pvh and i&s team have done a great job threading the needle in articulating the ideology. At a high level it is advocating for products that can provide the benefits of the cloud without being locked on or turning your phone into a paper weight if it doesn't have internet access.

I believe most do use a DOM like structure for block level elements. For inline styling however they tend to not have separate nested nodes for each style (bold, italic, underline), and are closer to the old HTML4 <font> tag with multiple properties for each style and don't nest them. It makes for much simpler code. The docs for ProseMirror are a brilliant insight into how many of these editors are designed. ProseMirror maintains its own document model in parallel to the html DOM and rectifies one to the other as either changes. For realtime collaborative rich text editors take a look at PeriText, they have a brilliant article explaining the CRDT structures used. https://prosemirror.net https://www.inkandswitch.com/peritext/

If you havent read it already it may be worth reading why the AWS libs are built that way. Definitely a problem at a certain scale. And if you havent seen it already you would probably appreciate Project Cambria from Ink and Switch. https://www.inkandswitch.com/cambria/

Alright, I just added a link to the section of the original Peritext document related to preserving the author's intent: https://www.inkandswitch.com/peritext/#preserving-the-authors-intent The specific definition of user intent in the context of concurrent rich text editing can't be clearly explained in a few words. it's best understood through specific examples. I've provided some examples in my brief introduction to Peritext.

This is great, I love local-first [1] software. Are you using OT or CRDTs for real-time editing? Are you using any specific cross-desktop platform? (Electron?) [1] https://www.inkandswitch.com/local-first/

Yeah, I see your point. I've been assuming that local-first doesn't mean local-only. Even if it's just you, you could easily be polling something else to get data updates, as you suggest. (One original use case was a personal GitHub dashboard app that polled for new activity but provided local analytics). A couple of great essays I've enjoyed in this space are https://www.inkandswitch.com/local-first & https://riffle.systems/essays/prelude/ I feel it should be possible to build certain types of apps that can view, query, and manipulate denormalized data without even being online. (Perhaps I shouldn't over-glamorize those days when one used to jam Access databases into Windows apps, but hopefully you get the point.) Reactivity just serves as a nice binding paradigm.