localfirst.fm

A podcast about local-first software development

Listen

Conference

#16 – Anselm Eickhoff: Jazz

The guest of this episode is Anselm Eickhoff, creator of Jazz and founder of Garden Computing. This conversation will dive deep into Jazz to learn how it works and which use cases it’s a good fit for by exploring various apps already built on top of Jazz. 

Mentioned in podcast

Links:

Thank you to PowerSync and Rocicorp for supporting the podcast.

Transcript

Intro
00:00Imagine if you could mock up an app just based on React use state
00:05or like equivalent things, and you build your UI around that.
00:08but then magically your app actually works and like all of the status persistent
00:14and you can share it with other users and, you have permissions on there and
00:18you still only wrote front end code.
00:21That's kind of the Jazz story
00:24Welcome to the localfirst.fm podcast.
00:26I'm your host, Johannes Schickling, and I'm a web developer, a
00:29startup founder, and love the craft of software engineering.
00:32For the past few years, I've been on a journey to build a modern, high quality
00:36music app using web technologies.
00:38And in doing so, I've been falling down the rabbit hole of local-first software.
00:43This podcast is your invitation to join me on that journey.
00:47In this episode, I'm speaking to Anselm Eickhoff.
00:49Creator of Jazz and founder of Garden Computing.
00:53In this conversation, we dive deep into Jazz to learn how it works and which use
00:58cases it's a good fit for by exploring various apps already built on top of Jazz.
01:03Before getting started, also a big thank you to Rosicorp and PowerSync
01:07for supporting this podcast.
01:09And now my interview with Anselm.
01:13Hey Anselm, so nice to have you on the show.
01:15How are you doing?
01:16Hey Johannes, doing good.
01:17How are you?
01:18I'm doing great.
01:19I was looking forward to today talking to you about Jazz.
01:23I know a little bit about Jazz and as I'm generally trying to scan the
01:28local-first ecosystem, but super excited to have you on the show and dive deeper,
01:33learn a lot more about Jazz, but before we dig in, do you mind giving a quick
01:37background and introduce yourself?
01:40Oh yeah, of course.
01:41I guess I've always been like interested in the web.
01:43I think it technically, I started with like Flash for people who remember
01:48that, but I very quickly got into making websites, just static ones
01:51first, kind of doing web design for local shops in my hometown and
01:56that became more and more serious.
01:57I learned about Rails and like building whole web apps and what that even meant.
02:01And I guess most of my career kind of spent being like a full
02:06stack consultant, building apps for lots of different industries.
02:11And typically I would be just like one man army doing like product design and
02:16building the backend and the front end and just building kind of the first version
02:21of that app that was ready for production.
02:24And then doing the next one and the next one and so on.
02:27And that was lots of fun.
02:28And I learned a lot, but over time, especially when you build lots of apps
02:32that are very different in nature, like who they serve, how they work.
02:37You still notice that there's so many things that you have to do again and
02:41again and again, and they don't even really have to do with each app.
02:44And you're, you're.
02:45You're using these tools that are supposed to be like high level
02:48frameworks for building web apps, but you still need to do so much
02:51yourself, redundantly each time.
02:52Like people who build web apps will know stuff like, why do you have
02:57to do user auth and permissions every time or like file uploads,
03:00this is like super simple stuff.
03:03and that always like nagged me.
03:05and particularly like, it seemed like.
03:07What you're really trying to do is just share state between
03:11different users of the app.
03:12And why, why do I have to build a whole stack and why is it so weird to do it?
03:17But I never really had a good, good solution for it.
03:20Right.
03:20And that's kind of what, what brought me where I am today with Jazz.
03:24And yeah, happy to tell you more about that.
03:27Yeah, that journey definitely resonates and, sort of in a similar
03:31counter reaction, in, in 2016, just led me back then to starting GraphQL,
03:36which later turned into Prisma.
03:38So I feel like that's a common, somewhat common story to like, from like the
03:43previous trauma of like doing something over and over again in a way that
03:48doesn't quite satisfy you, where you feel like, Oh man, we can do so much better.
03:53so that story definitely resonates.
03:55I'd be actually intrigued to hear a little bit more about some of the
03:58specific aspects, but I'm sure you'll, you'll cover that in comparison to Jazz.
04:04So, and Jazz is actually not quite the only thing you're doing
04:08since you're doing this under the umbrella of Garden Computing.
04:12So before diving into Jazz, do you mind giving a quick idea of like,
04:17what is that umbrella and what.
Garden Computing
04:20Yeah, sure.
04:21So it actually started with an app called Garden, which was kind of like
04:26my take on what should a Notion clone look like, what kind of other ideas do I
04:32have, I was really fascinated by Notion when it came out and by Figma just like
04:37setting this new standard of like, it not just being like a higher fidelity app.
04:43But one where like multiplayer and like rich multi user interaction is like baked
04:49kind of into the very fabric of the app and then the app itself is just like kind
04:54of like features on top of that, right?
04:56And I was like, this is cool, but I think It still doesn't feel fundamental enough.
05:01Like the multiplayer ness of it and like also the aspects that we
05:05now call local-first that I didn't really have a name for back then.
05:09and I was like, okay, I want to do something like that, but I want to do
05:11that part even better and then build like even cooler features on top.
05:15And that, that was Garden.
05:17And yeah, I did a bunch of experiments there and that's.
05:20That's pretty much what, what led me to what, what Jazz became as for
05:25like Garden Computing as an idea for a company or bigger umbrella.
05:31I can get more into that later, but basically the idea is that.
05:34I'm really fascinated by abstractions, by like powerful abstractions, by
05:38abstractions that are tall and like span many levels of, of understanding.
05:43And very often they come from like academia and research, right?
05:47That's where people find like really new, better ways of
05:50describing and building things.
05:52But they're obviously very abstract, very hard to approach for most people.
05:57and from my experience as a.
06:00Full stack web dev, I'm, I'm like very in touch with what people are using day
06:06to day and what, what the mainstream developer is like and cares about.
06:10and I just love the idea of taking these new ideas and kind of like
06:15finding ways to package them in a way that makes sense for the mainstream.
06:20And that actually makes.
06:21What we use in the mainstream, a little more enlightened.
06:24So I think in the broadest sense, that's, that's what Garden Computing
06:28for me is about and like Jazz and local-first is kind of like
06:33the first step in that journey.
06:35And I love the vibe overall of like Garden Computing.
06:39A garden is something that I think that's just, I'd say if you'd ask anyone,
06:45they'd probably associate it with like a nice, comfortable, homey feeling.
06:50If you think about a garden, does this maybe even, you have a very personal
06:54relationship of like, maybe you put together the garden, maybe you care
06:58after it, or maybe not, maybe it looks a little bit wilder, but there's something
07:02very unique and something very personal to our garden compared to like a very
07:08Industrial, like hyperscale, like that doesn't sound like a garden to me.
07:14and also like the use case that you've mentioned sort of like a
07:18Notion esque thing, I think Notion is also like there, there's this
07:22term of like a digital garden.
07:24so all of that is like a vibe that very much resonates.
07:27And it also resonates that you're saying you didn't actually start right away.
07:32with designing Jazz as a local-first tool, but that you're rather stumbling
07:38into it through working on an actual app.
07:41Since there's also the analogy for me, the parallel that while working
07:45on Overtone, I also realized, okay, this is a data foundation that I'm
07:49working on that doesn't just work well for Overtone, but also for other apps.
07:53So I think this is one of the most authentic ways to Really
07:57think of a new data abstraction.
08:00So now with that background, can you give me an introduction to Jazz?
Jazz
08:05Yeah.
08:05So like, to audiences like this, I introduced Jazz just as
08:09like, a framework for building web apps in a local-first way.
08:14That's probably the simplest way to put it.
08:16That of course requires you to already know what local-first means.
08:21So I think maybe a nice way to explain it is to go a bit more in depth on like how
08:27through trying to build Garden, I kind of discovered what I thought it needed to be.
08:32Because in many ways I didn't like sit down and be like,
08:35Oh, I want to build this app.
08:36I want to build it in local-first ways.
08:39and then I'll make a local-first framework to build the app because.
08:42When I started building the app, I didn't even know about local-first.
08:45I didn't know about that as a term.
08:47I saw apps like, like Notion and Figma.
08:51and I guess systems like Git, where it feels different from a traditional
08:58SaaS app with a centralized server and it has these really nice
09:02properties and it actually feels like it's suddenly very easy to do
09:05multiplayer, to have offline support.
09:08And to like be really serious and honest about the fact that what you're building
09:13with your app is a distributed system and not like some thin client around
09:17like the app basically just running on another computer, on one other computer.
09:22so I was like, okay, I want my app to be like that.
09:25And I started building the app and I had all of these crazy ideas in
09:28terms of like features for Garden.
09:30Part of it was even like, it should be like a visual programming
09:33language in there and like.
09:35I actually didn't get too far on that because very soon I was like, okay,
09:38what's, what's the infrastructure I need.
09:41That's like fabric that, that just has in the data layer, multiplayer
09:46and users and permissions and sharing and working on your device, but still
09:50being able to sync to the cloud.
09:52So I started building that just as part of Garden, right.
09:55and very soon just through like.
09:58abstracting and encapsulating the code.
10:00I had this like separate layer that did all of that.
10:03and a big part of what made that layer possible was learning about,
10:08Ink and Switch and their blog posts and publications, seeing auto merge
10:12as the first CRDT that I encountered and being like, Oh, even just the idea
10:17of having like, synced state between two text editors is super interesting.
10:22Like, let's.
10:24Build the layer around that.
10:26And then once I had that layer, I looked at it and I was like, damn, this is like
10:30really interesting, not just for Garden.
10:33but I kind of want to build every app ever like this now.
10:37thinking of all the apps I had built in the past, all the other apps I
10:40still wanted to build or the apps I didn't even know I could build yet.
10:44And I'm like, if I feel like that, probably other people will too.
10:47They just don't know yet that it's even possible to have this abstraction.
10:51So therefore I should probably try.
10:53And make this a framework.
10:54And that's, that's the origin story of Jazz, right?
10:58That makes a lot of sense.
10:59And, it also, there's, this interesting dance of, being irritated
11:06and confused by some problems, this desire of like, could we do better?
11:10You kind of hope we could do better.
11:12You don't quite know yet how to do better.
11:15You see some proof for other apps.
11:19Being able to build something in an experience that you wouldn't quite
11:22know how you would replicate that.
11:25You go on like looking around for ideas and luckily they're, very smart
11:31people, like the folks associated with Ink and Switch who are also like
11:35write about that and inspire others.
11:38And that leads you to maybe also like be very.
11:42compelled by those ideas, but maybe you have some slightly different takes.
11:46And so this is where, where it evolves.
11:49that makes a lot of sense.
11:50And I see a lot of like parallels there for like past endeavors and
11:55current endeavors that I'm on.
11:57So this is what led to Jazz.
12:00And I think there's like a lot of similarities for how other data
12:05technologies, like in the local-first space came to be and, throughout the
12:09further conversation, I'm sure we'll learn about what makes the specific flavor
12:15of Jazz, how that compares to others, but maybe we can best approach that
12:21by talking a little bit more about the applications that, Jazz wants to empower.
12:27So can you, give me an idea of like, what is like a typical app that, Is
12:33just naturally now built with Jazz.
12:35And what are some apps that you've like intended Jazz for?
Jazz early adopters
12:39Right.
12:40I guess one thing I will add in terms of like, what's special about Jazz
12:44and we'll go more in depth about that later, but like while building it
12:48as part of Garden, I realized that the responsibility of this layer.
12:52It's actually not just a data layer, it also needs to, or like, I wanted it to
12:58also handle user identity and permissions because that's other, other, because
13:04like, that's what allows you to go from having a local-first app that kind of
13:08syncs between your devices as a single player user to just extending that
13:13model very naturally to multiplayer.
13:16and it just always felt like these two things, user identity and permissions
13:20also need to be part of that abstraction.
13:21And that's kind of, that's the most special thing about Jazz, I would say.
13:26and that has enabled it to support quite a, like, wide range of different
13:31apps that, that even surprised me.
13:33and you kind of, you have apps that are like obviously local-first and are like
13:37a very good fit, and they are some of the ones that, that already felt the
13:42strongest benefit from adopting Jazz.
13:44for example, like I, I think Garden is a good example.
13:47We're actually almost at a point now where we can start building Garden
13:50again, based on top of what Jazz is now.
13:53That's, it's like Notion.
13:55It's very clearly a local-first app.
13:57One of my favorite early adopters, they're an app called Invoice Radar,
14:02which is basically, it lets freelancers collect invoices automatically from
14:08like cloud providers and other things they use that send them invoices,
14:13manage them, and then submit them to tax authorities, for example.
14:17And that's an area where like, yeah, having it local-first is really important.
14:23And the people who were building the app already, I think also without
14:27knowing the term at the beginning, knew that they wanted to build it that way.
14:31And then they found Jazz and they're like, Oh, there's like a framework that
14:34Just lets you build apps like that.
14:36And once they started building it with that, they were just able to get to
14:40like an MVP of their apps so quickly.
14:43So that's kind of like, almost like an obvious success story.
14:46Right.
14:46But then there's other ones that are really surprising that start to push
14:50the boundaries of what a local-first app is, or does the framework even
14:55only need to be for local-first app?
14:57one I'm building myself with, my girlfriend that I presented in Berlin
15:02at our local-first conference is an app called Succulent, which is
15:06basically a Hootsuite alternative, like a social media scheduling tool.
15:12And it's like 90 percent a local-first app where you can like plan drafts
15:17for Instagram posts, for example, on your device and you prepare
15:20them with the pictures and the descriptions and the hashtags.
15:24But then it has this component that's like not local-first at all, because like in
15:27order to meaningfully schedule posts to be posted, you need to have a server worker.
15:33and, typically this would mean that, well, you just need to build it as
15:36a centralized, like, SaaS app where all this logic runs on a server.
15:40But, What I realized with Jazz is like, you can actually take this
15:43local-first concept further and the server worker can just become yet another
15:47local-first client to the shared state.
15:50And then you get this really funky arrangement of like, you have
15:54this local-first app for authoring all this stuff and then just this
15:57little worker that whenever you're online and your stuff gets synced.
16:00It will know about what you're trying to do and then you can go
16:04offline again and it will post your posts for you by like interacting
16:07with the meta API, for example.
16:09So that was already a bit of a stretch of what Jazz can do.
16:13But honestly, the most ambitious and most out there things in terms of
16:17what you can build with Jazz have been from like other early adopters.
16:21So one of the crazier ones is This guy Nikita is building an app called
16:27LearnAnything, and you can check it out.
16:29It's already public.
16:30You can go to, I think, Learn Anything.
16:33xyz.
16:34It's, it's like a cross between Quora and Reddit.
16:37It's like a learning community where you can be like, I want to learn how to play
16:42the guitar, or I want to learn TypeScript.
16:44and for each topic that you might want to learn, you find this like
16:48community curated list of like really good links to other resources,
16:52like videos, blog posts, whatever.
16:55and that's just the social network, right?
16:57And the crazy thing is, he's already getting a bunch of impressions just from
17:02SEO, so you have like lots of, First time visitors and all of the state that
17:07needs to be loaded for each of these potentially huge topics, which have like
17:11thousands of links or something like that.
17:13And he decided to completely pivot his stack to just use Jazz for everything.
17:19And I think one of his motivations is that, For each individual user, he
17:24actually wants the experience to be local-first in the sense that you can
17:27also have your own kind of like notion, like notes about the topic and your
17:31learning progress in there and manage your own collection of links and so on.
17:37But then through sharing it with others, again, it needs to have the
17:40scaling properties of a social network.
17:42And that really, really stretched Jazz, but he was able to kind of like, Self
17:47publicly launched already and a version of his app completely built on Jazz.
17:51And so far it seems to be working.
17:53So, so that's kind of an interesting one.
17:56another one, which is very early and we'll have to see if it works, but
17:59it's basically like a local-first spreadsheet app, which is just like
18:03really intense in terms of like how much data there's in it and how like
18:07finally granular the interaction will be.
18:10And then the last use case I'll mention also really surprised me
18:14because it actually uses Jazz to do much less than a whole app where,
18:19it's at this huge enterprise and they have like CI pipelines for like
18:24their build processes or whatever.
18:26but it's really hard to look at them and see what's going on, which builds
18:29are passing, which ones are failing.
18:31And it's all in this like super old system with a really clunky API.
18:35And this person just wanted to build like a dashboard for that.
18:37Right.
18:38And that's really annoying.
18:39They decided to use Jazz basically just as a layer that makes that
18:43clunky old API real time and really easy to build UIs around.
18:50So they again have like a server worker that makes requests to that API and
18:55then maintains like a version of the state of all of the stuff in Jazz.
19:01And then they built a really thin client with Jazz and the two, like
19:07the status shared between the two.
19:08And then they were able to super quickly build a really nice dashboard,
19:12where you see a real time updates of what's actually going on.
19:15and I, I think you can start to see like how these are actually all.
19:18Really weirdly different.
19:20And yet everyone was able to use Jazz as this like small tool that
19:26does a lot very successfully.
19:28and I have to say as a caveat as well, these are very brave people.
19:31Like Jazz is early in many ways.
19:33Some of its APIs are clunky as well.
19:35The documentation really isn't there yet, but all the important like magic
19:40is already there and I think that's what allowed all these people to move quite
19:44quickly and confidently and the parts that still have friction are problematic.
19:49They were kind of able to work around it.
19:50I think that's kind of a good representation of where we're at as well.
19:54That sounds incredible.
19:55That's such a wide range of different apps and different use cases.
19:59you mentioning InvoiceRadar, for example, I'm actually one of the
20:03early users of InvoiceRadar, I've been using it for multiple months
20:07now, and I can confidently say that, I would have probably not started to
20:12adopt it if it wasn't local-first.
20:14Not because of like, that I say like, okay, now I have this bar Everything has
20:19to be local-first, like I still adopt other tools, but in this particular thing
20:23is, one of the, main ways, how this tool works is by getting access, like actually
20:31log in access to the various places that you where I pay for an invoice.
20:36So this tool needs access to my Notion, to my Slack, to my Hetzner columns,
20:42to all those like very critical places I wouldn't give anyone access who I
20:46wouldn't really, really, really trust.
20:49And that level of trust, I can't just give that to like an arbitrary
20:53SaaS startup, that wasn't around like a couple of years ago.
20:57Even if it was around, I would still have trust issues.
21:01And that trust issues thing.
21:03They very elegantly address by, saying like, Hey, the entire
21:08thing runs all on your computer.
21:10Like.
21:11All of like the login credentials, et ceterall of that, like not running in the
21:15cloud, like all remains on your computer.
21:18and so this is how that afforded me the trust and I've been using it.
21:24And, it works amazing.
21:26And I think it's built by folks, who are like very confident in
21:32sort of like front end development.
21:34And I think Jazz empowers them to like leverage their strength.
21:38And a lot of like the data moving around, that is taken care of.
21:42So that is like a use case that I can already as a user speak to.
21:46And then I want to also hear more about the Learn Anything use case,
21:50since that's, to me, seems like it's actually stretching, quite on
21:55the boundaries of where local-first is even considered a good fit.
21:59I think, if you hear about local-first, like where App use case works well,
22:04that's more around like data that's all like centered around a small entity,
22:09whether it's one user, whether it's one document, one workspace, one small team,
22:14but the more I think it's actually used sort of like as the counterexample,
22:18the more something is seen as a social network, the more local-first also
22:24actually becomes increasingly tricky to model around, to scale, et cetera.
22:28So I'd love to hear a little bit more how, Learn Anything and how Jazz helps with
Edge use cases
22:37Yeah, I'll, I'll go into that.
22:39There's two more things I want to say about Invoice Radar, because, I think
22:43that ties in quite nicely with what makes Jazz special, particularly for
22:47like your particular sensibilities as a user where like, yeah, you need to
22:51put your login credentials in there.
22:53Why can you trust it?
22:54And part of the answer is, well, it, because it only runs on your device,
22:58but then even then you might want to, and I think they're working on like a
23:03mobile companion app to Invoice Radar.
23:05So you can also just like scan and paper invoices with your phone.
23:10So obviously it's like 2024, you want sync between your devices, right?
23:16Maybe you're no longer just like a solo freelancer, but you have like a small
23:20company and you want other people in your team to submit invoices as well.
23:23And how do you do that while maintaining the trust that you have with the
23:28credentials and your invoices?
23:30And Jazz's answer there is exactly what I mentioned earlier that.
23:33User identity and permission is also part of the abstraction that
23:37it offers you, and it solves those in a local-first way as well.
23:42And we, again, we'll go into that later, but basically it uses public key
23:46cryptography to do permissions and auth.
23:49And what that means is that, Their app can actually use my infrastructure
23:54to sync data between your devices or between members of your team.
23:58But my infrastructure only ever sees encrypted data and that way you can
24:03still trust that app despite having these modern properties of like
24:07sync, cloud persistence, and so on.
24:10for them, what it meant was that they envisioned their app initially as
24:15only like a single player experience.
24:16And it already makes a lot of sense there.
24:18And they were like, okay.
24:19Later on, maybe in a year or a bit more, we'll add like team and
24:23organization features, and that'll probably be like a huge topic, right?
24:27But because they build it with Jazz, the idea of users and permissions is just
24:32like baked in and literally all they had to do to make it multiplayer was to
24:38build the UI for a little invite button.
24:40and their, their app was like multiplayer team ready from day one
24:45while preserving all of these like privacy and data protection guarantees.
24:50Anyways, just like a short addition to that.
24:53I'm also really excited about Learn Anything for exactly the reasons that
24:57you mentioned, because I didn't think that quote unquote local-first could
25:01stretch that far and that's maybe where I'll go into a bit of a spicy take
25:05and ask the question of like, Just how useful as a term is local-first
25:11really, because it's really good at describing local-first apps, right?
25:16But the abstractions that we build to make local-first possible, or at least in my
25:21case, what I'm trying to build with Jazz, it actually feels like something slightly
25:25more general than that, where like one thing I like to call it is like it's
25:30distributed state, and you already see that a little bit with apps like Succulent
25:34that has a server component, I don't know.
25:36We have a couple examples with server components that already stretches it,
25:39but it's still just Jazz and it's, it's distributed state, not just across end
25:44user clients, but across server workers.
25:46But again, the trust relationships are now explicit.
25:49It's not just frontend and backend, but all these individual things.
25:52The way it works in Jazz, by the way, is that the server workers
25:55also have an account like a user and you need to invite them.
25:58Two specific pieces of data for them to be able to see it and do stuff with it.
26:03so I really liked this idea of distributed state.
26:06And then, I also had this like coming to Jesus moment with Jazz where
26:11I'm like, what I'm building here is actually a distributed database.
26:17And I have to be honest with myself that it's a database.
26:19And, I don't know how many people that are listening or watching
26:23this are familiar with Redis.
26:25But one way I always like looking at Redis is that it's like, it's, it's
26:29kind of like an exploded database.
26:31It doesn't give you the nice high level relational API that, that usual
26:35databases have, but it gives you all the little tools that you need
26:38to kind of build your own database.
26:40So you can have like your raw key value store and then different ways
26:44to build indices or like spatial lookup structures and stuff like that.
26:48And that's really powerful.
26:49And Jazz is kind of similar in a way.
26:51It's like, I would say it's like an exploded distributed database
26:55with permissions built in.
26:56And once you start thinking about it like that.
27:00There's suddenly way more use cases where it can be a useful tool, including
27:04stuff like the, being this like real time layer in a purely backend setting,
27:09or you could imagine using Jazz as like a, distributing configuration for apps.
27:15So like anything that's a distributed system where you might have network
27:19failures, nodes going offline, but you want to have meaningfully shared state
27:25with like History and auditability.
27:27You can actually use Jazz for that.
27:28And I think even though I'm trying really hard to envision all these different use
27:33cases and build for it, there's probably a ton more that people will come up
27:37with, just by having something that's so flexible without like a narrow minded
27:41use case of like, this is for local-first apps or like, this is a database.
27:45Does that make sense?
27:47Totally.
27:47yeah.
27:48And I would love to dig in a little bit more into the social network aspect.
27:53I think the exploded database analogy is, is very useful and maybe that also
27:59addresses a little bit how, Jazz is able to stretch beyond that, but can you
28:04make the, a little bit more specific?
28:06when you.
28:07Remember other people, me included, saying that, for local-first, anything
28:11that's looks and smells like a social network or like a global, like basically
28:17if you have a lot of strongly connected, a vast set of strongly connected data
28:21points, this is where local-first has a harder time to sync all of that.
28:27And it seems like that would mean you need to sync literally everything.
28:31So you need to.
28:33Chop off certain points in the everything is connected graph to not
28:38let the user wait forever until all the graph data is there, but to only
28:43show the user what they actually need.
28:46So how do you work around
28:47that?
28:48Or do you need to sync everything?
28:50That's kind of like, other than the like user identity and
28:53permissions making Jazz special.
28:55That's I think the only other big point that makes Jazz special
28:58is that from the beginning I kind of knew that it had to be.
29:02Super granular when it comes to which chunks of data are you loading?
29:07And it's, it's much more, it's basically on demand by default.
29:11And the underlying data model is like an infinitely big graph of
29:16data that can reference each other.
29:17And you like.
29:18Load sub graphs of that as needed.
29:21And for like a very local-first or classical app, that means, well, you
29:27kind of end up everything that one user needs or like a small team of people
29:31needs and there it's very obvious how that works well, I think the surprising
29:36insight is maybe that even in something crazy like a social network, even where
29:40you have single nodes, like people who might have a lot of followers, it's
29:44actually still quite like manageable graphs that are quite independent.
29:50And what doesn't work is in my design sense, you can't ask the app developer
29:57to have to come up with the boundary of like, what is a chunk of data that
30:00makes sense to be loaded at once.
30:02I think maybe you could get away with it for an app like Notion where like
30:06the document is an obvious boundary to do that for, but even there it's
30:10kind of annoying and gets in the way, particularly with sharing and so on.
30:14So I think you just have to adapt that like a hundred percent granular mindset.
30:18And then it turns out, Even the very highly connected graphs, they're actually
30:22manageable in size, and it is feasible to load them to display, for example, one
30:27learning topic and Learn Anything, even if it has thousands of links and thousands
30:32of people interacting with that topic.
30:34That's actually, in the grand scheme of things, not that much data to sync.
30:39And on my infrastructure, which is kind of inherently distributed.
30:42It's like, obviously geographically distributed because that's like a nice
30:47metric to kind of chunk data up against.
30:50you can also start doing something very similar to sharding where you basically
30:55co locate data that is often accessed together, again, on a very granular level.
31:00And then suddenly even this like really hot data with lots of
31:04people interacting easily fits.
31:06into a single node, even a single core, and it's feasible to
31:09sync it to clients who all want roughly the same stuff anyways.
31:13and if you're being honest, like databases face exactly that problem and that the
31:18way it's solved usually is just by scaling it,, like making your database node huge
31:24so it can fit all of the data for all of the users and then distributing and
31:28scaling databases is a hugely complicated topic and I think in many ways local-first
31:33is actually an answer to that in the sense that in the most extreme case
31:37you're like well we only need to worry about the data of one user and we'll
31:41have a system that manages the data for one user, which is their machine.
31:47but then the abstractions you build to make that possible, if you include
31:52the granularity, actually also let you do everything in between where,
31:57yeah, you, you can have a couple of nodes collaborating to sync and
32:04persist and serve like, Subgraphs of that, like infinitely big data.
32:09Does that make sense?
32:10That makes total sense.
32:11And before we're going even deeper here, and I think we're stretching a
32:14little bit into some like implementation details here, et cetera, which are super
32:18interesting, but maybe we take a little step back as a application developer
32:23who wants to build something with Jazz.
32:25Maybe you can walk us through, what does that look like?
32:28So just to give a little bit of like a spectrum of options, we had Matt
32:33Wonlaw on the show where we, for example, talked about CR SQLite,
32:37where the idea was that, you replicate a SQLite database across devices.
32:43So this is where you have already Something that developers are
32:46very familiar with, which is a relational database that you can
32:50just embed in the app and then query.
32:52So that's one approach.
32:53we heard from the folks working on AutoMerge, which is a CRDT based
32:59system, so where you rather think less about a database that's replicated.
33:04But more about individual documents, that are being replicated and state
33:10based as you change the CRDT document, those state changes are being propagated.
33:16and there could be also other options, for LiveStore, for example, I'm following more
33:20of like a, what I consider a combination of both approaches where you distribute
33:26a event log and you recompute a, in this case, a SQLite database from it.
33:32So there's various flavors, various trade offs, which path have you've been
33:37going down with Jazz and maybe also why.
How Jazz works
33:41Yeah.
33:42So the meta comment there is that like, after you think about it for a really
33:46long time, a lot of these approaches end up actually being the same, but it
33:50really matters, I think, in terms of contrasting different frameworks and
33:54solutions and introducing people to the idea in the first place, from which
33:59angle you approach it and like the.
34:01It's like a replicated local database that's relational is a very obvious one.
34:06And there's a lot of people doing that really well now.
34:08the document one is an obvious one.
34:11I think you'll be able to predict what, what my issue with
34:14it is that it like makes you.
34:16Put the boundaries, but I'm basically doing that.
34:18I'm doing what AutoMerge is doing.
34:20It looks like state, and I'll say that a bit more precisely in a second,
34:24but again, it's a bit more granular.
34:26And the way I describe it typically, like the audience that I have in mind
34:31is actually not full stack developers or backend developers who are very
34:35familiar with relational databases, but in my case, frontend developers who
34:41are familiar with Local UI state on the one hand and kind of making requests
34:45to APIs as like the only external system they ever need to worry about.
34:49So the story I tell this Imagine Frontend developer is that imagine
34:55if you could kind of mock up an app just based on local, like React use
35:01state or like equivalent things, and you build your UI around that.
35:06but then magically your app actually works and like all of the status persistent
35:12and you can share it with other users and, you have permissions on there and
35:18you still only wrote front end code.
35:21That's kind of the Jazz story and that's what the API looks and feels like.
35:25So if, if you build an app with Jazz, typically the first thing you do is.
35:30You actually do something kind of database y, which is that you define a schema
35:33just to describe kind of what is the shape of data, which kinds of objects
35:38are the main abstractions in my app.
35:40interestingly, you don't have to model users at all because that's just baked in.
35:44So it's very nicely like, what are just the concepts that are
35:48specific to your domain that you're, addressing with your app.
35:52And once you have the schema, you can just start having state of objects in
35:58that schema and build UI around it.
36:00And you can create objects of different types out of your schema locally, and you
36:04can create like, groups, which is kind of like the permission structure in Jazz
36:08and put objects in groups and then like give users access rights to groups, all
36:15like you can do these things literally in an on click handler of a button.
36:19And it feels kind of illegal because of how simple it is, but that's it.
36:23That's how you build apps with Jazz and you can get very far with just that.
36:28As apps get more complicated, you can kind of.
36:31abstract things all kind of similarly to how there are solutions for not
36:35letting UI state get too complex.
36:38and the other thing you might need to start, if you want to talk to external
36:41systems like third party APIs, you can build the server workers that I
36:46talked about a couple of times now.
36:48But the nice thing is you can build.
36:49If you also write them in TypeScript, for example, you just
36:51share the same data schema that you're using for the front end.
36:55And it really just feels like one, one small addition to your
36:59otherwise purely front end code.
37:01That's, that's kind of the Jazz experience, right?
37:04That makes a lot of sense.
37:05And I've just in parallel.
37:07going through the Jazz landing page here, where you have, this
37:11really cool chat app and 174 lines of code embedded here as well.
37:16We can just see exactly that, like a little schema definition
37:20of this case for this chat app.
37:21There's just like a message.
37:23Class, a message concept and a chat concept.
37:27and that's it.
37:27You can use it right away in your React code, in your other code, and fire away.
37:33and you've also have here the user concept where you see like, okay,
37:38something is owned by me and then the chat, for example, is owned by a group.
37:44what if I want to go a little bit more specific here and enforce
37:48certain Permission rules, that are more specific to my app.
37:54what is the story in progression there?
37:57So the way that that works is that it doesn't get more complicated than groups
38:03and objects belonging to the group.
38:04So like whenever you create an object in Jazz and like, I should say
38:08the name for them, we call them co values, like collaborative values.
38:12You have like co maps that are kind of like.
38:14JavaScript objects, co lists that are like collaborative arrays, basically.
38:19and just like you can represent a lot of different kinds of data with JSON, you
38:24can represent a lot of different kinds of collaborative data with co values, right?
38:29And each co value has to belong to a group.
38:32The group is like the scope for permissions, and it simply has user
38:36accounts in it with a certain role.
38:39The three roles that exist are Reader, Writer, or Admin.
38:43They do exactly what it says on the tin.
38:45and they then influence what people can do on co values.
38:49We can talk in detail later how that works under the hood, because
38:52I think that's interesting as well.
38:53But for now, that's all you need to know.
38:55And that maps quite naturally on onto a lot of stuff that you want to do in apps.
39:00But then the question is what about more complicated situations?
39:03And the answer there again is the granularity.
39:06Because if you wanted to every, each co value, like imagine like a kind
39:12of tree of co values representing the state of a more complicated document
39:17or even like a folder of documents.
39:19The way that looks like in Jazz is that they're actually each
39:22individual CRDTs that just have plain data as values in their fields.
39:28Or they can have references to other co values.
39:30And that's how you build this, like, potentially infinitely big graph,
39:33and you, like, load whatever you need to, like, display right now,
39:36or what you want to have offline.
39:37But the nice thing is that the groups that these co values belong
39:41to, and the permission structures, therefore, are kind of orthogonal
39:44to the, like, data references.
39:46So you can reference a co value, That belongs to a different group that
39:50has different members or where the same members have different roles.
39:53And that way you can build permission structures that are just as granular.
39:57And you can even have like something like a notion document where like a small block
40:03might only be editable by some people.
40:05does that make sense?
40:07totally.
40:07you, you've been mentioning the reference concept that is giving you the kind of
40:13like a relation for a key kind of concept between different kinds of documents,
40:19and I think this is also describing the.
40:22the boundary between one thing that needs to be synced and then another
40:27thing that needs to be synced.
40:29And if you model a thing like a network with that, how does,
40:34Jazz, how does it know where to, uh, how much it needs to sync?
40:39Where does it need to stop?
40:41Is there, so one analogy, for example, in GraphQL . maybe not everyone is familiar
40:46with that, but it's like a query language that is language agnostic and can be
40:51implemented with any sort of backend.
40:53And this is where you can also define a schema kind of similar to this here.
40:58and aside from the schema, describes the potential graph of queries, or
41:04set of queries in a specific query.
41:08you need to very explicitly say, those are the things that I want to query.
41:12So let's say we model a file system from this, where we have folders and files
41:18and folders can have folders and folders can have folders in a GraphQL query.
41:23You need to say, actually, I want to, you need to explicitly lay out.
41:27I want to go like all the way to like level three.
41:30So you need to say, I want to grab the folders and in that folders, I'm
41:34going to grab again, the folders.
41:36And I want to, there again, grab the folders, but you can't self
41:39recursively, infinitely, traverse.
41:43Is there a similar kind of explicit depth to how jazz should sync something.
41:50Is that determined at runtime by a React component, for example, is
41:56there some sort of middle ground?
41:58How does that work?
41:59So there are kind of, and it's a really good question because like, that's kind
42:03of, you need a system that solves that.
42:06If you don't have the explicit boundary of like, this is, we can
42:10either sync all of that or nothing.
42:11Right.
42:12And the file system is a good example because it's.
42:14It's kind of potentially infinitely deep, but you're probably only ever looking
42:17at a subset, so how do you do that?
42:19And the way, the quick and dirty way you do it in Jazz, which is actually
42:24really fun to just, again, super quickly build your eyes that work, is that,
42:29Jazz tries really hard to make covalues look like just plain JSON objects.
42:35And if you have co values with references to each other, they look like JSON trees.
42:40So what do you do then if like at some point you might
42:43not have a co value loaded?
42:44Well, then it just says that it's in a TypeScript sense that field is
42:48either the reference thing or null.
42:51And,, if you try and render a specific tree in a React component,
42:55you can basically just use optional chaining to like render like this far.
43:00And if it's not loaded, show like a little spinner or something.
43:03But the funny thing then is that Jazz notices what you are trying to access.
43:09And it's like, Oh, you're trying to render like three levels deep.
43:12And you try to access this thing that we don't have yet in the background
43:16triggers a sync of the needed co value.
43:19And once that's available locally, it re renders your component.
43:22And now that's not null anymore, but you actually have the JSON state
43:26for that co value and you render it.
43:28So very naturally by like building your UI and just deciding to render.
43:34What do you want to render it will lazily load exactly what's needed.
43:38And you can even manually do pagination like that by just having
43:41a little stateful, like, oh, I want to render 10 items and then you only
43:45drill down into the first 10 items.
43:47And then like you hit a button or you reach the end of a scroll list or like.
43:51Elements become visible on the screen and you just ask Jazz to
43:54access more of them, even if they're right now, not, not available.
43:58And in the background, it will load more.
44:00That's the quick and dirty way.
44:01Super nice for prototyping stuff.
44:03It's a bit weird in terms of user experience, because you end up with a lot
44:08of spinners and they like, they resolve really quickly because Jazz is fast,
44:12but it still looks unfamiliar to people.
44:15So if you want to give people a more polished experience of maybe one Loading
44:21thing until a bunch of status available.
44:24That makes sense as a unit.
44:26There is a way of specifically specifying a loading depth and that's.
44:32That kind of looks like GraphQL lite, but because you only need to specify
44:38fields that are references, you don't need to say which plain data fields
44:41you need because they're always loaded.
44:43yeah, you, you, it's, it's actually very similar to Prisma.
44:46You just say which references you want resolved and then the Jazz hooks.
44:51Won't give you anything until all of that is loaded and then
44:54they give it to you as a chunk.
44:56That makes a lot of sense.
44:57So you're basically just specifying sort of the graph of the references,
45:02not the individual fields of a document, since you typically want a document
45:06as a whole, that makes a lot of sense.
45:08And that's also, as I'm thinking through how I would model something for Overtone.
45:13when I have a music app and I want to listen to music, if I'm currently
45:17ermbarking on a train journey or on a like traveling somewhere where
45:22I don't have perfect connectivity.
45:25I want to like that lazy loading just in time as I like click on a playlist.
45:32if I don't have connectivity, then at that point, it kind of breaks a
45:36bit of like that local-first promise.
45:38but I also understand like, let's say, Spotify is thinking
45:42about building it in that way.
45:44Spotify can't just sync the entire catalog of like all of Spotify on a single device.
45:50So there needs to be like some cutoff point.
45:53And I think while prototyping doing the just in time lazy loading, that's great.
45:58But then as an app developer, in this case, for example, me building
46:02Overtone, as I better know, okay.
46:04I want you to find some rules of like, that stuff should always
46:08be there, like prepared for me going on a, on a train journey.
46:12And that would probably in this case be.
46:14For all of my playlists, make sure like all of like the tracks for the
46:18individual playlists are at least the metadata is there and possibly
46:22then have like also some rules for pre downloading some tracks.
46:25If I have the rights to do so.
46:28that makes a lot of sense.
46:29And that seems like Jazz provides a really nice trade off of making, providing a
46:35easy way right away to prototype and then, dial it in to match the user
46:41experience that you want to provide.
46:43And I guess I met the comment here with like, because you actually just
46:46now asked a very precise, interesting question, which is like, well, what
46:50if you ask it to load a chunk of data and not give it to you until all of
46:54it is there, but then your connection drops, what should actually happen?
46:59And like nothing being loaded, then it's actually a.
47:02Like you said, an outcome that violates local-first a bit.
47:04So there, then we need to be more refined and be like, well, maybe show
47:09a spinner for everything for like two seconds and then give up and just show
47:13me everything that was actually loaded.
47:15and what we're getting to there is that I think like, look, I think
47:19it's starting to become clear how local-first in general is this cool
47:25new way of building app and how Jazz in particular things really deeply, how to
47:29make that easy for you as a developer.
47:31But most of the challenges with local-first and with multiplayer, by the
47:35way, I think are UX challenges where we're like, well, what, what should happen?
47:40And that's something that we figure out as we try to build
47:43and dog food, our own apps.
47:45As we see what, our first adopters build with it and what makes sense
47:51to their particular developers and how you want to expose all of these
47:54different, like, is it loading?
47:55Is it locally available?
47:57Is it locally available?
47:58But it's like, not quite up to date with what we know the syncing server has, but
48:03we didn't have a chance to get that yet.
48:05And there's like so much complexity in there.
48:07And in different situations, you need to expose like more or less of that.
48:11So I think beyond just like.
48:14Making the sync and making the data persistence and making the permissions
48:18work, which like we're pretty good with now, there'll be a lot of like
48:22API design and also like educating developers and just figuring out UX
48:27together, like as a field, I think.
48:30I definitely agree.
48:31And like just the scenarios that we've now went through over the
48:34last couple of minutes, I think already go surprisingly deep.
48:38For example, like the partial, like if you want to load everything and then you say,
48:42okay, I don't have everything, in some cases, it's fine to show a partial set.
48:47In some other cases, it might be like really nerve wracking for a user where if
48:53you don't signal like, Hey, we've just, we, we can't say this is everything.
48:57We've just fetched so much since otherwise a user might assume, Oh my gosh.
49:00Like this app has like lost some of my data.
49:03and so this might, in some cases might be better to not show anything
49:07and like explicitly let the user know, like, Hey, we're sorry.
49:12when you come online again, we'll do our best to get everything in here.
49:15sometimes you also like from the data you fetch, maybe you want to like,
49:19let's say you, you shouldn't build a bank account this way, but let's say
49:22you build a bank account and you've just fetched a bit of like your,
49:26your like transactional history.
49:28And it misses your latest, like, big check that you cashed in.
49:35Basically you added money to your bank account and it's not in there.
49:38And you think, Oh my gosh, like my bank account is like lost all of that money.
49:42Obviously you won't build an app like that, but I think the analogy kind of
49:47like translates where you derive data from other data and where it could be
49:52like really bad, you missed something.
49:53So this is really interesting to dig into the user experience aspects.
49:58And that might also make for a really interesting future conversation,
50:02but I want to, Dig a little bit more into, into another related topic,
50:07which is the localfirst.fm podcast.
50:10And what brings all of us together is that we think we can do better
50:14how we build apps, at least in many app use cases, and Jazz shows for
50:18how many app use cases that applies.
50:21And so that means We, as a whole, as an ecosystem, we need to convince
50:26the people who are not yet in that small but growing ecosystem.
50:30We need to convince them that we have a very interesting way how to
50:34build apps better, that are simpler to build, better for end users, etc.
50:39And I think each technology has their own specific, benefits, how that's, is
50:45a, is a good fit for, for certain app use cases and particular developer types.
50:50Like you want to target more like the front end developers.
50:53what is your approach to talking to developers?
50:57How do you want to market Jazz to reach the right people and sort of the,
Marketing approach
51:06Yeah, yeah, totally.
51:08Because I think like, look, we're all facing the same challenge.
51:11Like you said of like, we understand how this is better and how it can benefit
51:16a lot of different kinds of apps.
51:19but counterintuitively it's, I don't think it's really about selling the benefits.
51:23I think the one big benefit that really does make sense.
51:26And it's valuable to people as just saying, look, like you've got like
51:30a 10 X better developer experience.
51:33It's way faster to build apps.
51:34It's way easier to reason about.
51:36There's way fewer moving parts.
51:38I think that's kind of universal across all the different solutions.
51:42different solutions differ in terms of like what traditional
51:45parts of the stack they replace.
51:47I've put myself in the shoe of like replacing a lot of the pieces because I
51:53do auth and permissions, and by the way, you can also store binary data in Jazz.
51:58So suddenly you don't need blob storage anymore and binary data just becomes
52:02part of the data you have locally and can be referenced just like JSON like data.
52:07and it's so easy to just think about what are the obvious advantages of that
52:11if you are totally bought into this and ready to build your app like that.
52:15That's kind of the easy part, right, to make.
52:17to explain that.
52:19But the biggest question is like, why should you even bother?
52:23And why should you give up this really proven, familiar way of building apps?
52:28that means the biggest challenge is that it's so new and alien and different.
52:34So I think the trick has to be How can we make it look familiar
52:39and how can we make it look like something that already exists?
52:43And that's, I think where exactly the different audiences or, ways of telling
52:47that story for different products come in because, saying that you're replicating
52:53a relational database into the client.
52:56That's taking something very familiar to like backend developers and then
53:00doing one little step away from that.
53:02And then like, Oh, and then it has all these benefits.
53:04Right.
53:05I feel like, yeah, I've made it hard for myself because I'm basically
53:08trying to replace the whole stack.
53:11And that's a story that actually, again, it works really well for
53:15frontend developers because the whole stack was never part of like
53:19where they had agency to begin with.
53:22So they're happy.
53:23Full stack developers and especially backend developers aren't so
53:26happy because you're like.
53:28You don't have to do all of that stuff anymore.
53:30It's replaced by this giant pile of magic.
53:33I think like, I mean, what we identify as developers is being
53:38clever and building stuff ourselves.
53:40Right.
53:41And I think a big part of what keeps really complicated stacks and ways
53:46of doing things in life is honestly just the IKEA effect of like.
53:50Well, but I built this myself and I like, I picked things that are individually
53:54good at what they're doing, but I put them together in this really clever
53:58way and local-first is like, it's just, it's so powerful that it takes away
54:04so much of that doing stuff yourself.
54:07That it's a real danger in terms of adoption and like not
54:09bruising people's egos secretly.
54:12so one attempt I had was like, well, can I kind of not make Jazz one giant
54:18package, but more smaller ones so people can glue stuff together again.
54:22And I think that's kind of counter to like what makes Jazz powerful, which is exactly
54:27that it is a vertically integrated thing where even the different parts of like.
54:32CRDT, stage sharing, and user identity and permissions.
54:36They are actually very tightly knit together.
54:38And that's why, yeah, that's what makes Jazz special, I think.
54:41But, the other way out of that, I think, and this is something I just have to
54:45do way more, is to have really good, like, under the hood documentation.
54:50And the cool thing is, like, I think CRDTs kind of get thrown around
54:54as this like mysterious new thing that magically solves everything,
54:58but like, it's really complicated.
55:00Don't worry about it.
55:00Like, you can read about it in some research papers if you really wanted
55:04to, but I think the way I've implemented CRDTs in Jazz is actually very.
55:09Very straightforward, in the sense that it really follows a particular viewpoint of
55:14CRDTs, which I think is best represented by a blog post called, like, Data Laced
55:20with History, I think it's called.
55:22And it's basically just this, the simple idea of like, look, you just keep all
55:26of the edit history on an object around and that's what the object actually is.
55:30And then the current state is just a view over that history.
55:33And if everyone has all of the edit operations and the full histories
55:36of different people collaborating on a document, then you eventually
55:40get the same state and that's it.
55:41and like, just as simply in like five or 10 more minutes, I could
55:45describe to you how then Jazz adds cryptography to do the like.
55:49Read and write access control, but it's actually not that hard.
55:52And I think having really neat diagrams and kind of like a medium level
55:57explanation that people can read through in like 15 minutes and feel like, okay,
56:01these are the parts that are inside Jazz.
56:04And now I know like, if I wanted to glue stuff myself together, what I could glue
56:09together or which systems I would need.
56:11But I won't bother.
56:13It's enough for me to know.
56:14What's going on and that in itself already makes me feel kind of clever.
56:18And then just going like extra deep on all the details for the people
56:22who want to be really, really clever.
56:23I think that's going to be important.
56:25and probably each framework has their own equivalent of doing that.
56:29And like, it's not necessary to use it at all, right?
56:32That the APIs that you use, if you build Jazz are much higher level
56:35and are much more in terms of like abstractions that an app needs, but.
56:39Yeah, I, I think DevTools, the biggest challenge is that you are
56:44selling to developers, so you need to speak to developers egos, right?
56:48Right.
56:48And I love the way how you framed that in the Ikea effect and how you, yeah,
56:54it's, it's like this delicate balance you want to, like, I think we can all get on
56:58the same page that we want to collapse as much complexity as much as possible,
57:05But developers still like love the abstractions, love putting things together
57:10and, like figuring out the delicate balance of having something that's already
57:15somewhat put together and does what they need, but then you can decompose it and
57:19like compose it again in a different way.
57:22I think that's sort of like where the, where you need to apply like
57:26a little bit of like special sauce.
57:28and I think this is what you've already, laid out very, very nicely with Jazz, with
57:32like the APIs look amazing and the apps that are being built on top of it already.
57:38I think a really, really good proof for that.
57:41So slightly switching gears.
57:43Jazz is no longer just a technology, but behind Garden Computing, you've
57:48also, I think you've thought about that for a longer time and recently took the
57:53step to actually, Turn Garden Computing into an actual company and build out a
57:59commercial offering around Jazz as well.
58:02and I think you've recently, took on a initial round of pre seed
58:07funding, so congrats on that.
58:09but I'd love to hear a little bit more about what that means for Jazz as a
58:13technology, what your thoughts are on possibly offering a commercial product,
58:18sustaining the company otherwise around that, and how you're thinking of like
58:23Going beyond just working on this yourself, but possibly, scaling out the
58:28company or like hiring other people.
Building the company
58:33Yeah.
58:33So I think again, going into it from like, how did it come to be?
58:37I think it's important to say that, like, I'm not someone who's like trying to do a
58:42startup for the sake of doing a startup.
58:45I was very much like thinking of it as like an open source framework and
58:48was building that as like a good tool.
58:51And in a similar way where like the fact that it is a framework kind of became
58:54apparent to me while I was building it.
58:57it became apparent to me that like, okay, even if you have all of these
59:00abstractions for distributed state and local-first, and that's all
59:05like, it feels very peer to peer.
59:06And I think in our legacy, we have a lot of peer to peer thinking.
59:10and that obviously influenced me, but I had this moment where I'm
59:13like, okay, if I really think about what I as a user want from the app,
59:16for example, very pragmatically.
59:19I want sync between devices that works even if the devices
59:23aren't online at the same time.
59:25So I need some kind of centralized syncing infrastructure that
59:28also does persistence for me.
59:31Right.
59:31so that very obviously became a part of Jazz and then I'm like, it's actually
59:36kind of hard to run that at scale and to run it well and have it have low
59:39latency and so on, and that's something that a company could do as a service.
59:46Right?, and it being open source, of course, you can also self host your
59:50own version of that either on a single node for like a small app, or you can
59:53be brave and try and scale it yourself.
59:56That's totally doable, but there's just obvious value in
59:59someone doing that for you.
1:00:01And the interesting extra component there is that.
1:00:04Because of the encryption, you actually don't have to trust that
1:00:07infrastructure with your data.
1:00:09You can just use it for syncing and persistence, but know that it will
1:00:12never see your data, your user's data, whatever you care about.
1:00:16so there's this kind of like really useful service or product.
1:00:21presented itself to me and I'm like, okay, this doesn't just feel like it wants to
1:00:26be a framework for people to really have that local-first development experience
1:00:31where you only want to have to worry about the parts that actually make your
1:00:34app, your app, and now you don't have to solve state syncing and permissions
1:00:40yourself anymore, but you would still have to build syncing infrastructure.
1:00:44That seems kind of weird.
1:00:45Like.
1:00:45I think what you want as an application developer is to use a
1:00:48service for that, because then you're actually only left with your app.
1:00:51That's what I would want anyways.
1:00:53So like, okay, this is starting to feel like a company and I think I'm in a
1:00:57good position to build that company.
1:01:00and then it became a question of like, okay, I, for a long time,
1:01:04my plan was to bootstrap it.
1:01:06and I did try to go into YC and raise VC funding, but I think we, as if Field are
1:01:13so early that it's, it's really hard for outsiders to see the potential in that.
1:01:19and what it took for me to have any success with that was to get
1:01:23Jazz to a state where it became obviously useful to developers.
1:01:27And they could start telling these like first success stories of like,
1:01:31wow, we actually built the SAP way quicker than we would have otherwise.
1:01:36And then to do that in like a public setting, like the local-first conference
1:01:40in Berlin, where then investors can see that and be like, Oh, this
1:01:44actually really speaks to developers.
1:01:46And that's like, That's like an early signal they understand, right?
1:01:49So that's, that's what allowed me to raise that round.
1:01:53And now I'm in the, in the very fortunate position to have investors
1:01:57who understand how early we are and how much work it's going to take to
1:02:01really bring this into the mainstream.
1:02:03And starting to have the person power through like hiring my first couple
1:02:07of employees who I'm really happy with and who, who really get it as well.
1:02:11And they're building their own apps with it as well.
1:02:13where I'm like, okay, we can actually speed run, the features that we
1:02:18need to reach parity with what traditional stacks can offer you,
1:02:22in the way that I think we need.
1:02:23That's, that's kind of the switch that happened there for me.
1:02:27And before I had all of these ideas in my head of what I kind of knew
1:02:31Jazz needed to do, and believe me, I thought about everything.
1:02:35It's all somewhere on the roadmap, but I didn't really know what
1:02:38was most important, right?
1:02:39But the nice thing about having early adopters is that just becomes super
1:02:43obvious because they'll be like, They'll be blocked because Jazz doesn't have
1:02:47like this and we just built that next.
1:02:49And that's kind of the journey that, that I've been on actually, since before
1:02:52the investment for about a year now.
1:02:54and now I have the luxury of being able to like tackle a couple of these at a time.
1:03:00that's kind of where I'm at with it.
1:03:02And the goal is to really.
1:03:04To build a service that makes sense both for individual developers, for
1:03:08whom it will be the first point of contact with local-first or distributed
1:03:12state, for small companies to build, successful apps super quickly and
1:03:17kind of like being able to reach a much wider economy of small companies
1:03:22and individual developers who can now meaningfully build real things that
1:03:26are useful to people and maybe because.
1:03:29It's so much easier to build things.
1:03:30You can now build products that target smaller niches.
1:03:34And that's really interesting.
1:03:35And also to just give a tool for like bigger companies or even enterprises to
1:03:40be like, Oh, it's actually really hard for us to build high fidelity apps.
1:03:46Figma like notion.
1:03:47We want these because we have lots of people and lots of teams that interact,
1:03:50but we don't have the know how to build something like a sync engine.
1:03:54That's just way too complex for a company to do itself.
1:03:57But if that's now an off the shelf abstraction and there's kind of like an
1:04:01obvious either third party service or something that you can deploy on premises.
1:04:06That's really powerful and interesting and I think enables a lot more
1:04:09bigger companies to build their own software as well and have it
1:04:12immediately be as good as the best, like, SaaS apps we have right now.
1:04:17That's, that's kind of the potential I see in it and what I'm trying to
1:04:20address in the, in the medium term.
1:04:22I like that a lot.
1:04:23And that also makes me think about, like the, this concept called small giants.
1:04:29I think it was also, I think I first learned about it on the Metamuse podcast
1:04:33by, that Adam Wiggins did in the past.
1:04:36Hopefully it comes back at some point.
1:04:38but this is where they did one episode about the idea of small giants.
1:04:42And this is basically that a very small team, possibly could be like just,
1:04:48an individual small team, et cetera and they can build products, reach a
1:04:53really wide audience without having to build up all of that load and to.
1:04:59Like, for example, WhatsApp was when I think it was acquired before
1:05:04billions of dollars by, by Facebook, was still a very, very small company.
1:05:09I think, they've been, I don't get the numbers exactly right, right
1:05:13now, but like, I think within 10 to 50 people where they've already.
1:05:18Reach like billions of users.
1:05:21I think similar for Telegram, well, Telegram is a little bit in the
1:05:24news right now, but, I have a lot of admiration at least for like how they
1:05:28built the product in terms of the craft, et cetera and it's also similar there.
1:05:33There's a very small team that can still reach a very wide audience.
1:05:38And I think this is what local-first can really empower, where you can empower
1:05:44a lot more small giants to serve a much more richer, diverse set of use
1:05:50cases, where a bunch of current existing products could be replaced by local-first
1:05:56products, but not just by one local-first product, but a hundred different kinds
1:06:02of people who have specific use cases.
1:06:04There are a hundred different small giant.
1:06:07Build products specifically for their use case, for their niches.
1:06:10so instead of like having, 10 very, very large monopolies, like, dominating
1:06:16a particular segment, let's rather have like a thousand individual
1:06:20builders reach smaller slivers and have products that fit particular use cases.
1:06:28And I think this is where you can empower them.
1:06:30They can focus.
1:06:31Similar to Invoice Radar, focus on specific use case and
1:06:36then, use a syncing service.
1:06:38So that makes a lot of sense.
1:06:39And I'm looking forward to that future.
1:06:42before we close out, I'm interested in hearing your perspective on the more,
1:06:48the bigger web ecosystem as a whole, as you've been building apps within the
1:06:52web space for a long time, now you're contributing a, better development suite
1:06:57to that, but I'm curious whether you have any sort of strong opinions on the
The web is fine
1:07:04I think my strong opinion on it is that I kind of don't have one, or like there's
1:07:09a lot of critical voices that complain about all kinds of things about the web
1:07:15and its state that are completely fair.
1:07:17Right.
1:07:18But I think what kind of gets lost within that is that the web is actually fine.
1:07:23And it's not only fine.
1:07:24It's, it's like, it's amazing.
1:07:26It's like, I think first and foremost, it's this like
1:07:29crazy distribution mechanism.
1:07:32and, I think, you talked about this in a previous episode, that like, you can just
1:07:37send your grandma a link and she'll know.
1:07:40What to do with it.
1:07:40Right.
1:07:41and it will, she'll see what, what you see.
1:07:44and that's crazy.
1:07:45That's something that is just so at the core of the web.
1:07:48And, sure.
1:07:48It's kind of weird that like JavaScript got tacked onto like a
1:07:52document representation and so on, but it is a really powerful VM.
1:07:59That is super dynamic, would make anyone who likes Lisp or Smalltalk
1:08:05proud if you really think about it.
1:08:07But it's like, everyone has it.
1:08:09The best minds of our generation optimized it to the death.
1:08:15And you just get all like, CSS is crazy, but you can do a lot with it.
1:08:21and you just get all of that.
1:08:22And.
1:08:23It's kind of not doing what it was originally meant to do.
1:08:26It's kind of like an app distribution system now, but because it's so
1:08:32flexible and so malleable, I think my big point is actually that we can
1:08:36just make it do whatever we want.
1:08:38for example, when I think about Jazz and what Jazz does, the way Jazz works is, is
1:08:43it's actually like a high level framework and then like a protocol underneath it.
1:08:48And it's a very minimal, simple core that does like, the implementation of
1:08:53the CRDTs and like how to sync them, how to persist them and the cryptography,
1:08:57like how do the permissions work?
1:08:59That's all like defined.
1:09:00And then like you get higher level features on top.
1:09:03And if you look at that, it's kind of like a new networking protocol.
1:09:06And in many ways, it's like what I think the web should have been like just taking
1:09:11seriously that we're building like this.
1:09:13Network of distributed nodes that have partial state and being able to represent
1:09:18user identity and permissions across that.
1:09:20so like one kind of pessimistic take would be that like, Oh yeah, that's
1:09:24obviously better, but we'll never get there because we're stuck with the web and
1:09:28this like centralized client server model.
1:09:31And that's like at odds, but like, it's not at odds at all.
1:09:34We've got web sockets and we can just build.
1:09:37The protocol on top of client side JavaScript and server side JavaScript
1:09:42and hopefully soon other server side programming languages and
1:09:45native apps and, communicate over the web socket or maybe soon web
1:09:49transport or like HTTP 3 or whatever.
1:09:52It's like you can actually do a lot of crazy stuff with the web and, we
1:09:57can just like, yeah, just embrace the fact that In the history of computing,
1:10:02we almost never replace things.
1:10:04We just add archeological layers of like, we're building the thing that we
1:10:08really want, but we have to build it in terms of what's already there and like
1:10:11widely available and it's actually fine.
1:10:15And that's, that's.
1:10:16How like you kind of have the psychological aspect that we talked
1:10:20about earlier, where like this crazy new thing has to look and sound
1:10:24familiar, but also very pragmatically it has to be implemented based on
1:10:29things that already exist where you don't have to really replace anything.
1:10:33That's, that's kind of my take on the web, right?
1:10:35Right.
1:10:36I love that.
1:10:36I did this year, I did a three week journey through some of the
1:10:42national parks of the United States.
1:10:45And we also, spent a couple of days at the Grand Canyon where we just See like
1:10:50those like massive, massive, like layers of layers on top of layers that just reach
1:10:56back, I think like millions of years.
1:10:58I don't recall the exact facts anymore, but I think it's a very good observation
1:11:03that, we rarely replace something categorically, but we just build on top.
1:11:08Maybe we phase one thing out, but that takes like, decades often.
1:11:13And, it's kind of a miracle how capable the web has gotten, given how weird
1:11:21it is and how many words it has.
1:11:23So I think I like that observation a lot.
1:11:26And, yeah, given the, given often the web for me is like a love hate relationship,
Outro
1:11:33So, uh, Anselm, this has been a really great conversation.
1:11:37I've learned a lot about Jazz.
1:11:38I've been very inspired by the way, how you think about the entire space overall.
1:11:44So maybe you want to have a, you have a last chance to plug anything,
1:11:48give any shout outs, but other than that, I'll thank you for your time.
1:11:53Yeah, I mean, thank you.
1:11:54I really enjoyed this conversation as well.
1:11:56Definitely shout outs to Ink and Switch because they are my biggest inspiration
1:12:01and what kind of, what gave me a lot of the ideas in the first place.
1:12:04In terms of plugging stuff, again, coming back to psychology, like I can tell
1:12:09developers about all the advantages of Jazz and so on, but like, So far, what
1:12:14has worked best in getting them to adopt it for even like a small experiment or
1:12:18even getting them to start doing the guide and the official docs is just
1:12:22being like, look, I've got these like shiny holographic stickers for Jazz.
1:12:27And like, I've got boring stickers as well.
1:12:30And like, everyone can get them at meetups.
1:12:32I put them on tables and stuff, but like, if you want one of the special shiny ones,
1:12:36you have to build something with Jazz.
1:12:37And like, if you just do the official guide that counts as doing something with
1:12:41Jazz Just show me like wherever you are in the world, either we meet in person
1:12:45somewhere or I'll mail it to you, but you, you get the special shiny sticker.
1:12:49Okay.
1:12:49That's the deal.
1:12:51All right.
1:12:51There's, there's a first on the podcast.
1:12:53There weren't any holographic stickers yet.
1:12:56So I might just as well give this a try afterwards.
1:13:00And the next time we see each other, I might steal one of those.
1:13:04But thank you so much.
1:13:06Thank you so much.
1:13:07I really enjoy myself.
1:13:08Thanks for having me, Johannes.
1:13:10Thank you for listening to the Local First FM podcast.
1:13:13If you've enjoyed this episode and haven't done so already, please
1:13:16subscribe and leave a review.
1:13:18Please also share this episode with your friends and colleagues.
1:13:21Spreading the word about this podcast is a great way to support
1:13:24it and help me keep it going.
1:13:26A special thanks again to Rosicorp and PowerSync for supporting this podcast.