localfirst.fm
All episodes
March 13, 2024

#5 – Kyle Mathews: Benefits of using a sync engine, personal local-first apps, ElectricSQL

#5 – Kyle Mathews: Benefits of using a sync engine, personal local-first apps, ElectricSQL
Sponsored byExpoCrabNebula
Show notes

Transcript

0:00:00 Introduction
0:00:00 And so you're like, Hey, API, give me the data from my widgets.
0:00:04 And then I render it.
0:00:05 So it's sort of an imperative step, kind of like manually telling the client,
0:00:10 tells the server, give me that thing.
0:00:12 Where sync engines, it's a a move from an imperative to declarative.
0:00:17 So instead of saying, give me that data, it's sort of like for this page,
0:00:22 I declare, I need this data and then the sync engine makes it so, often
0:00:25 run into the problem where like, just like sort of getting data is easy,
0:00:28 but subscribing to updates is hard.
0:00:30 Welcome to the local-first FM podcast.
0:00:33 I'm your host, Johannes Schickling, and I'm a web developer, a
0:00:36 startup founder, and love the craft of software engineering.
0:00:39 For the past few years, I've been on a journey to build a modern, high quality
0:00:43 music app using web technologies.
0:00:45 And in doing so, I've been falling down the rabbit hole of local-first Software.
0:00:50 This podcast is your invitation to join me on that journey.
0:00:54 In today's episode, I'm speaking to Kyle Matthews, who's in the past
0:00:58 has been the founder of Gatsby.
0:01:00 js and is now exploring local-first software.
0:01:03 In our conversation, Kyle shares his experience building some small scale
0:01:08 local-first apps for his personal use and how using a data syncing engine
0:01:12 frees up a lot of his development time.
0:01:15 Before getting started, also a big thank you to Expo and Crabnebula
0:01:19 for supporting this podcast.
0:01:21 And now my interview with Kyle.
0:01:24 Hey, Kyle, welcome to the show.
0:01:25 How are you doing?
0:01:26 Uh, doing great.
0:01:27 Uh, glad to be here.
0:01:29 Thank you so much for, for coming on.
0:01:31 You're another fellow early Local-Firster.
0:01:34 So I'm very curious to hear about your background and then hear
0:01:37 about what led you to Local-First.
0:01:39 So, uh, I've been doing web development of various sorts
0:01:44 for like the last 15 plus years.
0:01:46 I've seen a lot along that way, you know, like the whole jQuery era, did Backbone.
0:01:50 js for those who read history books and, you know, it was early React, GraphQL.
0:01:55 I actually started with Drupal.
0:01:57 Funny fact, Drupal, Drupal was big back in 2000, still widely used, but
0:02:00 people are like a little more expansive about their view of Drupal back then.
0:02:04 Then switched to kind of JavaScript, single page apps,
0:02:06 like really early 2010 ish.
0:02:08 And, uh, yeah, I've been kind of writing that ever since.
0:02:10 Yeah, then, then of course, uh, Gatsby 2015 introduced that, uh, which kind
0:02:15 of like, Took react and it was sort of the first proper production ready,
0:02:19 you know, react, uh, meta framework.
0:02:21 And so kind of rode the whole react, uh, wave for a long time.
0:02:25 But yeah, in general, my interest is what are the tools we use to build software?
0:02:32 Cause like, I think software is very important and.
0:02:34 The quality of the tools that we use determine the quality
0:02:37 of the software that results.
0:02:39 We shape our abilities and our ability to shape us.
0:02:41 It's sort of like we, we, we shape our tools and then the
0:02:44 tools shape everything else.
0:02:45 Cause I think there's really like high leverage to kind of
0:02:48 continually pondering that question.
0:02:49 Cause if we can genuinely move to a genuinely better tool, then
0:02:55 there's enormous Effects that result from that, not just in our actual
0:02:59 day to day life, but like, you know, we're a software creators.
0:03:02 Like there's a lot, a lot of people whose lives are affected by software.
0:03:05 So yeah, I've seen like genuinely better tools emerged in sort
0:03:08 of my, my software career.
0:03:09 So like, I think react was a massive step forward.
0:03:12 I think Grackula was a smaller step forward, but also a genuine step forward.
0:03:15 And I feel like, you know, local-first, it feels like this is
0:03:19 another sort of massive step forward.
0:03:20 Leap forward, um, and how we build software.
0:03:23 And I think it's something that in the coming years, more and more software
0:03:27 will be kind of built in this fashion.
0:03:29 I definitely agree.
0:03:30 I mean, uh, I'm also definitely a connoisseur of good tools, but luckily
0:03:36 there's a lot of good tools and many different areas of development overall.
0:03:41 Like you just.
0:03:42 You can also look at other language ecosystems.
0:03:44 I'm definitely very interested and inspired by all the good stuff that's
0:03:49 happening in the Rust ecosystem, but also super cool ideas that you find in
0:03:53 other ecosystems, such as like the Elixir ecosystem with live views, et cetera.
0:03:58 So there's like a lot of great tools and great ideas, uh, in all of those places.
0:04:03 But I'm curious, which sort of problems have you experienced
0:04:08 in the past that has led you.
0:04:11 To, to local-first in particular, and where you now see a different approach,
0:04:17 The State Transfer Problem
0:04:17 You could sort of think of like client server development,
0:04:20 there's sort of three problems.
0:04:21 There's sort of the UI, like how do we construct the UI?
0:04:25 How do we do interactivity, charting stuff?
0:04:28 So there's a lot of like different areas within like the UI and then
0:04:31 there's sort of backend problems.
0:04:32 There's a lot of like complicated computing bits.
0:04:34 There's like, how do you run infrastructure at scale?
0:04:38 How do you.
0:04:39 Make things efficient.
0:04:40 So you're not like, you know, spending enormous amounts of money, uh, security.
0:04:44 There's endless domains of problems in the backend.
0:04:47 Um, and then there's kind of like the middle bits, which is like state transfer.
0:04:51 Like, how do you move bytes back and forth?
0:04:54 Cause generally the client can't hold all the data.
0:04:57 So you have to like, say, I need part of the data to be pulled over.
0:05:00 And like, generally things are changing to like, how do you get that data from
0:05:03 the server to the client and so on?
0:05:06 And so there's a lot of.
0:05:07 Problems around moving state back and forth.
0:05:10 And so, yeah, so I think I'll go first.
0:05:11 It's interesting because I feel like the front end and the backend, there's been
0:05:16 just enormous number of innovations, both sides, all the investment and,
0:05:21 and, and react it's felt and solid and view, uh, and like VEET and Webpack.
0:05:26 And there's just like enormous investment that's gone into making the front
0:05:30 end experience dramatically better.
0:05:32 Plus all the, you know, all the libraries, there's like NPM has like Millions
0:05:35 of libraries or something like that.
0:05:36 I don't know.
0:05:36 Like each of those things is just like enormous effort from individuals
0:05:40 and groups all across the world.
0:05:42 And it's made the UI world dramatically better place.
0:05:46 Like it's, it's just remarkable to me how much faster it is to build.
0:05:51 Amazing stuff versus like 15 years ago.
0:05:54 Like I, the first like big JavaScript dashboard I built, it took me like
0:05:58 six months to ship the first version, partly because I wasn't a very good
0:06:01 programmer, but partly because like, there was just like no guidance anywhere.
0:06:05 Now there's just like endless starters, endless use cases.
0:06:08 Like React is such a compact, simple abstraction.
0:06:11 It's dramatically better.
0:06:12 And that's because there's been like tons of innovation there.
0:06:15 And the backend too, there's like all the cloud giants are pouring tons of research
0:06:18 into stuff and there's like tons of.
0:06:21 Individual cloud services where before you're like, Hey, that's
0:06:24 three months of programming.
0:06:24 And now it's like two hours to implement an API and off you go.
0:06:28 So there's been lots of innovations too in the back end, but yeah, the state
0:06:31 transfer bit, like the, you know, moving bits back and forth hasn't really, I
0:06:36 don't know, got as much investment.
0:06:38 Partly.
0:06:38 I think it's like, it's not always a problem.
0:06:40 Often.
0:06:40 It's pretty simple.
0:06:42 You know, if you're just sort of like, Building a dashboard.
0:06:44 You're like, get me the data for the dashboard, render the data.
0:06:48 It's not a very complicated problem oftentimes, but I think what we're seeing
0:06:52 is that we're like the best teams, the best apps investing disproportionately
0:06:58 their time compared to everyone else, because that's kind of where, where the
0:07:01 best teams see a kind of an advantage that they can like build something
0:07:04 significantly better than other people.
0:07:06 And so what I think you're seeing now is like the best.
0:07:10 Apps in the industry, you know, like the Figmas, the Linear, Superhumans,
0:07:13 et cetera, they're pointing now towards sort of state transfer, like, how
0:07:19 do you load your app extremely fast?
0:07:21 Because everything's cached locally.
0:07:23 How do you have real time sync between, you know, different people?
0:07:26 So you can build like, rich collaborative experiences.
0:07:28 How do you, you know, save locally and then sync backwards?
0:07:32 So you're not like, Doing little spinners all the time when you save stuff.
0:07:35 So it's like always fluid and fast.
0:07:37 And they're all kind of arriving at the same idea, which is like, Hey, this
0:07:41 whole like rest, you know, like posting things back and forth, pushing bites
0:07:46 around manually, doesn't cut it anymore to build like really complicated, amazing
0:07:51 apps, you need a higher abstraction.
0:07:54 You need something more sophisticated for.
0:07:57 Handling that state transfer and, and that's sort of like this local-first and,
0:08:00 or, you know, like sync engines, it's kind of like the component that sort of
0:08:03 handles that, that state transfer back and forth between the client and server.
0:08:08 What are Sync Engines?
0:08:08 That's super interesting.
0:08:09 So you, you mentioned the term sync engine that, that might be not
0:08:12 familiar with everyone in the audience.
0:08:15 So could you elaborate a little bit what a sync engine is
0:08:18 and how that might relate to.
0:08:21 The, the approaches that you've mentioned before.
0:08:24 I feel like it's the best term for uniting a bunch of different
0:08:29 tools and their approaches.
0:08:30 But yeah, the basic idea is that REST API, Grackle API, TRPC, whatever.
0:08:37 They're all based around rendering a page for widgets.
0:08:40 It's a widget page.
0:08:42 And so you're like, Hey, API, give me the data from my widgets.
0:08:46 And then I render it.
0:08:47 So it's sort of an imperative step, kind of like manually telling the client,
0:08:52 tells the server, give me that thing.
0:08:54 Where sync engines, it's a a move from an imperative to declarative.
0:08:59 So instead of saying, give me that data, it's sort of like for this page,
0:09:04 I declare, I need this data and then the sync engine makes it so, and often
0:09:08 run into the problem where like, just like sort of getting data is easy,
0:09:11 but subscribing to updates is hard.
0:09:13 Like everyone kind of notices there's a massive gulf and
0:09:16 difficulty between those two things.
0:09:18 And so what's cool about sync engines is that because it's sort of more of a
0:09:23 declarative step, there's actually no additional complexity to get subscription.
0:09:27 This guy is the same thing.
0:09:28 You're just saying, I need this data.
0:09:30 And then the data shows up.
0:09:31 It's a new abstraction for how data.
0:09:35 Arise on the client where, yeah, again, you're going from imperative to just
0:09:39 being like, you're describing the shape of data that you need to show
0:09:42 up on your site for a particular page.
0:09:45 I know another good analogy.
0:09:46 It's very similar to shift from like jQuery to react where jQuery, you're like,
0:09:51 get this DOM element and tweak the text.
0:09:55 Or get this DOM element, remove the child, construct two other children, drop it in.
0:10:00 You're like a little kid playing with like blocks or something.
0:10:03 And you're like, you're like fiddling all the time, which was actually fun.
0:10:06 I actually enjoyed it.
0:10:07 It was a fun little challenge, but it's a huge waste of time where, you know, we're
0:10:10 moved to React and React is more like, I don't know, I want it to look like this
0:10:13 and just sort of happens somehow, like React does a bunch of weird magic under
0:10:17 the hood and it just kind of efficiently somehow shifts everything around.
0:10:21 Uh, without tearing and voila, it's there.
0:10:23 You're like, cool, it's there.
0:10:24 And yeah, that's just a lot less to think about.
0:10:26 When you're just like, I want something to be so, and I don't really
0:10:28 care about the complicated details.
0:10:30 That's a lot less to think about.
0:10:32 Which is the value of abstraction?
0:10:33 Because we, we have a finite amount of things we can think about.
0:10:35 So, if we drop two, then we can like, replace it with, Two other stuff instead.
0:10:40 So if you drop a lot of thinking about state transfer, then you have more
0:10:43 time to think about other things.
0:10:44 So you've now explained a little bit, the benefits of a sync engine and
0:10:50 that it simplifies a lot of things.
0:10:51 But for someone who's now like curious, how does this actually work?
0:10:56 Can you explain what a sync engine does and how it does it?
0:11:01 I'll, I'll use an example for the one that I've used the most electric SQL.
0:11:04 So electric SQL is sort of Postgres based and you have, you know, Your tables
0:11:09 and basically the shape is like kind of declared like this is the shape of data.
0:11:13 I want polar.
0:11:14 It's just like a sequel query.
0:11:15 So you're just like, I want.
0:11:16 this table and rows that match this criteria.
0:11:20 And then the sync engine kind of like takes that and then it says like, okay,
0:11:24 I will send you sort of the initial bunch and then any updates that I see from then
0:11:28 on that match that shape off it goes.
0:11:30 That makes sense.
0:11:31 So, and this would be one particular example, one particular technology
0:11:35 for when your starting point is an existing Postgres database.
0:11:40 So is that the way how I should think about it?
0:11:42 That like I have my And like traditional way of how I'm dealing with data in
0:11:48 a more global state, for example, Postgres, and then I'll just slap
0:11:53 a sync engine on top of it, connect my clients to it and off I go.
0:11:57 In theory, in practice, all these tools are like, this
0:12:01 whole space is pretty new still.
0:12:03 So I think that's sort of the platonic ideal that everyone's working towards
0:12:06 is like, you just sort of slap a sync engine on and off you go.
0:12:09 And that does work.
0:12:10 In some parts, you know, all these tools are like, there's some limitations
0:12:14 that you have to kind of live with and that they're working to, to lift, but
0:12:17 there's understandably a decent bit of complexity to kind of like take this
0:12:21 30 year old, whatever old Postgres is technology and toss a new thing onto it.
0:12:26 As long as you live within the abstraction, I kind of, or live within
0:12:28 sort of the existing limitations, then yes, that is actually the very,
0:12:31 very most of the reality I've been building, like a number of sort of
0:12:33 toy stuff, both to play with this local-first approach, Sinkage approach.
0:12:37 But also, you know, exploring a number of other things and it is like very simple.
0:12:41 You just say like new table and then it creates a client side library.
0:12:47 Kind of like very Prisma esque.
0:12:48 Uh, actually they're still using, I think, Prisma under
0:12:50 the hood to generate the client.
0:12:52 And then you just immediately just start reading and writing
0:12:54 from like the local SQLite.
0:12:56 So because they use Postgres in the back end and then SQLite.
0:13:00 It's very straightforward.
0:13:01 Just like write a query and data's there, do an insert off it goes.
0:13:05 So I can't promise it'll work for like, yeah, anything will just work.
0:13:08 But if you're living within sort of the current restriction, it is
0:13:13 Personal Apps - Pt 1
0:13:13 That sounds great.
0:13:14 And I think there is a lot of different approaches, how a sync system could work.
0:13:19 We've also learned a bit about auto merge in previous episodes, but I'm curious to
0:13:23 hear more about your experiences building apps with the stack that you've mentioned,
0:13:28 can you tell a bit more about the apps that you've tried those new approaches?
0:13:33 Uh, yeah.
0:13:34 I mean, none of these apps have been, we've all been for like
0:13:36 personal use, so they're not like anything earth shattering.
0:13:40 The most kind of.
0:13:42 Complicated one is a one I'm just actually finishing up and my wife had been
0:13:46 working on it and it's like a kitchen AI.
0:13:49 So basically you, you can like take a photo of different ingredients in
0:13:54 your kitchen and then the AI will then sort of like convert those into
0:13:57 ingredients in the store and then you can set like, what is the fill level?
0:14:01 When's the expiration date?
0:14:03 And then when you want to go do, do a recipe, you can upload, like
0:14:07 you kind of copy and paste the recipe into it and it kind of like
0:14:10 parses out all of the ingredients.
0:14:12 And then what's interesting is like, it's actually kind of like ingredient
0:14:15 or recipes all kind of describe ingredients slightly differently.
0:14:17 So like just doing like a naive matching or something.
0:14:20 You won't actually work, but then, so I'm using like embeddings to, to
0:14:24 kind of do a more fuzzy semantic match between the ingredients in the kitchen
0:14:28 and like the recipe ingredients.
0:14:29 And so then I'll say like, Hey, here's all the ingredients you have.
0:14:32 Here's the ones you need to buy, but also sort of like tell you, it's
0:14:35 like, Oh, Hey, you're running low.
0:14:36 You should double check if you have enough of this one, or, Oh, this
0:14:38 one is like expired, so you should probably just get some new spice.
0:14:41 So you're, you're, cause the old one doesn't taste very good anymore.
0:14:45 Anyways.
0:14:45 And then it's sort of a one click.
0:14:47 You know, create a shopping list with, uh, we're using Trello.
0:14:50 So just sort of like sends it off to Trello.
0:14:52 Another cool thing that we did is like, we just give it an enum
0:14:55 of sections in the grocery store.
0:14:57 So it's like, there's meat and seafood and dairy and produce
0:15:01 and canned goods and stuff.
0:15:02 And so then each ingredient is coded to one of those sections.
0:15:07 And so then when you go to the store, you have this like neat list of.
0:15:11 Uh, the different things, so it's actually pretty fun to use.
0:15:14 Uh, it'd be pretty fun to build, but, but yeah, so, so the actual
0:15:17 process of building it is, you know, the local-first stuff, the electric
0:15:20 SQL stuff is defining my schema.
0:15:24 Well, another cool thing about all this too, is it's very data centric.
0:15:26 I've noticed a big shift in how I build stuff now versus before is it
0:15:31 used to be steady at the back end and like the database, everything was like
0:15:35 annoyingly complicated that I just sort of delayed it until I was sort
0:15:40 of more or less finished prototyping.
0:15:41 So what I would do is like, just keep all the data in memory in the
0:15:45 browser and then build the UI, try a bunch of stuff and just kind of like.
0:15:48 Have a little JavaScript rays and objects, you know, whatever.
0:15:51 And then finally I was like, okay, now I kind of like know what my
0:15:53 data structure is and everything.
0:15:55 And now I'll just actually set up the database and start
0:15:57 persisting it and whatever.
0:15:59 But now it's like so easy with electric SQL to kind of.
0:16:04 Set up the database and have a client and have everything syncing that like,
0:16:08 like the very first thing I do is write my crate, you know, table stuff and,
0:16:12 and, and I have the tables and which is a huge improvement because it's very
0:16:15 nice having a fully typed database, you know, I, because you have all the
0:16:20 Postgres stuff you can like, you know, pull up PSQL and start writing queries and
0:16:24 anyways, there's a lot of power you get.
0:16:26 For free and you have like type checking, you have, you
0:16:29 know, foreign key constraints.
0:16:31 So you have kind of all these nice things that database give you from
0:16:33 day one while you're just prototyping.
0:16:36 Normally what I do when I'm prototyping is I just blowing
0:16:38 away the database and restarting.
0:16:39 But that again is like 30 seconds or something, um, to do.
0:16:43 It's also quite fun to like chat GPT is like great at like, Creating SQL.
0:16:48 So I use that a ton when I prototype and I just sort of like, just kind of
0:16:51 freehand describe all the data I need, like, and then it spits out, you know,
0:16:55 like five create table statements and I just like pop it in and off I go.
0:16:59 It's very, very productive.
0:17:00 Uh, and it's quite fun just to have a full blown typed database
0:17:05 backed, you know, SQL first reactive system while you're prototyping.
0:17:10 Yeah.
0:17:10 It's both like a very productive prototyping system, but what's
0:17:12 genius about, of course, about the whole thing is like your prototype.
0:17:15 That is immediately your production system too.
0:17:17 Cause I can just like, as soon as I'm done, like, I don't have to like,
0:17:20 fix up a bunch of data problems cause it's, it's been good from the get go.
0:17:23 I just ship it and, and it works perfectly.
0:17:26 And I'm not like, Oh no, I have all this like crap data now that's
0:17:29 accumulated production system.
0:17:30 I took all these shortcuts, you know, to like work on my prototype.
0:17:32 It's just like, it's just, you have all the database
0:17:34 guarantees from, from the get go.
0:17:36 I, I love that story.
0:17:38 I think this is so powerful and the analogy you've provided before
0:17:43 in terms of going from jQuery where you have to do everything manually
0:17:46 to React freeing you up to no longer having to do all of this manually.
0:17:51 Now that really makes sense to me because now you could like you've, you've
0:17:56 mentioned a few of like the, the new, like AI aspects of this, or that the app
0:18:01 is an app just for you and your wife.
0:18:03 And that's totally fine.
0:18:05 Like you're basically now freed up by so much data wrangling of before you
0:18:10 would need to like maybe set up a GraphQL endpoint, a REST endpoint, and you'd
0:18:14 spend so much time just to have all the, the data moving stuff taken care of.
0:18:20 And if that now just works in the same way as React.
0:18:25 Automatically working and keeping your views up to date.
0:18:29 And now if we elevate to the next level of Muslow's hierarchy of, of needs
0:18:35 for, for app development, and we have the data automatically taken care of
0:18:39 now, you can focus actually on what makes the, the app fun and unique.
0:18:44 So that makes a lot of sense.
0:18:46 And I love your anecdotes there of that.
0:18:49 You don't no longer need to think about.
0:18:52 There's this like, it's kind of like stage one, everything
0:18:55 is crap in prototyping mode.
0:18:57 And then at some point you need to make it real and production mode.
0:19:01 But with react, you also don't really distinguish too much about
0:19:04 like, Oh, am I now writing this for production or for, for prototyping?
0:19:09 You're just doing it right.
0:19:10 And it's easy from the get go.
0:19:12 And if you get the same thing for data, that's super powerful.
0:19:16 So I love that.
0:19:17 Yeah, that's actually, that's probably a good analogy is like, How
0:19:20 powerful, how good a quality is, is some part of your stack as if, if
0:19:25 the prototyping is the same as like production, like there's no difference.
0:19:30 Just another random tool I've been using lately, like SST.
0:19:33 I don't know if you've played with that, but they have sort of their live.
0:19:36 Development, uh, Lambda function.
0:19:39 And it's like killer because you develop against an actual Lambda and they kind
0:19:43 of like intercept the call to the Lambda function and send it to your like laptop.
0:19:48 So you kind of have like debugging logs and everything, but your,
0:19:51 everything is actually, Running in, in the cloud and it's like
0:19:54 going to S3 buckets and everything.
0:19:56 So it's like the development environment is the same as your
0:19:59 production environment, um, which is like pretty hard to do.
0:20:01 Otherwise going from dev to production with SST is like, there is no difference.
0:20:06 Like you, it's the same stack, but the react, it's like, if your components
0:20:10 are good for development, they're going to be efficient production.
0:20:12 And yeah, with electric SQL, like it works in dev is going to work in product.
0:20:16 Schemas with ElectricSQL
0:20:16 That's great.
0:20:17 I would love to, to hear a bit more about the details of how you've built this app.
0:20:21 And, um, particularly you've mentioned that you design your tables and
0:20:27 your schemas, and you've mentioned that you're using Postgres, uh, more
0:20:31 for like a server aspect and SQLite For, for the client state, do you
0:20:37 design one schema and that applies to both Postgres and SQLite equally?
0:20:43 Do you distinguish between those?
0:20:46 Yeah.
0:20:46 Yeah.
0:20:46 You create a table in Postgres and then they call it electrifying it.
0:20:50 And then there's sort of sync engine then automatically sets
0:20:53 up that table for you in SQLite.
0:20:55 And also like does migrations and all the other like complicated bits.
0:20:59 You can do local only tables, but I've never needed to.
0:21:05 There could definitely be stuff that's sort of like very specific to a client.
0:21:09 Um, but generally speaking, like all the data, I just want synced all around.
0:21:13 Cause you know, again, one of the cool things about all this is that, you know,
0:21:15 your desktop, if you have a phone running the app and you have a desktop running
0:21:18 the app, they're like always in sync.
0:21:20 So it's, it's kind of like you pull out a phone and it's like, got the data.
0:21:26 Personal Apps - Pt 2
0:21:26 So that kitchen app that you've been describing, that sounds super cool, but
0:21:30 it sounded you've been building a few different local-first apps to really give
0:21:35 this, give this a try and get started with, with that local-first paradigm.
0:21:39 So which other apps have you been building?
0:21:41 Yeah.
0:21:42 And another app that I was pretty pleased with and I think is, uh, another
0:21:45 good example of kind of the benefit of this like sync engine approach.
0:21:49 It's a very simple, it's a one, one page, one view app, but
0:21:54 basically it's like I use Garmin.
0:21:55 I have a Garmin watch for like tracking exercise, like running, biking, et cetera.
0:22:00 And they have a bunch of like charts and stuff that they kind of like pre designed
0:22:03 for you, but I was like, Hey, I want to like, look at it from a different way.
0:22:07 But basically I wanted a pure volume.
0:22:10 Based view of my exercise.
0:22:11 So, cause they're, they're like emphasize like intensity or mileage.
0:22:14 And I'm just like, I just care how long I'm running or how
0:22:18 long I'm biking, et cetera.
0:22:19 And so I was like, Hey, they have an API.
0:22:22 I'll just pull in the data, analyze it, create a chart off, you know, off we go.
0:22:26 So the cool thing about it is that, so basically how the app works is like.
0:22:30 You know, it's using electric SQL again.
0:22:31 So it has all of your activities cached locally.
0:22:34 So when you load it up, like it's instantaneous, it doesn't have to load
0:22:37 a whole bunch of data off the server.
0:22:38 It's just like runs, click SQL query presents the charts and stuff.
0:22:41 But then also when you load it though, it like it hits a Lambda function, which then
0:22:46 syncs in any new activities from Garmin.
0:22:49 Into the system.
0:22:50 And what's fun about that is like, just again, just how simple it was.
0:22:54 Cause all it does is it like hits the API and then writes out
0:22:59 new data into Postgres, which is like, okay, that's fine.
0:23:03 But then the next step, you're like, well, how do you like tell the front
0:23:05 end that like the new data is done or whatever, there's like a bunch of other
0:23:07 stuff, but what's, what's great about it.
0:23:09 It's like, there is no other step because the sync engines just was
0:23:12 like, Oh, there is like a new Garmin activity pushed into the database.
0:23:16 I'm going to push it to the client because it's subscribed to it and it's active.
0:23:20 So it's just kind of like, it just shows up.
0:23:21 That's again, it's kind of an illustration of like, you have this sync engine.
0:23:24 It's not just like reactive in the client.
0:23:27 Like there's a lot of like, we talk a lot about like client reactivity and like,
0:23:30 there's a lot of libraries that do that, but this is more like a global reactivity.
0:23:33 Like the whole system is reactive.
0:23:35 Like any change anywhere, it gets pushed to every other node that cares about that.
0:23:40 And that's just like a really powerful leap forward.
0:23:43 Not just for the, like, Client server, but like, even like server server, like
0:23:47 I thought a lot about like microservices, everyone's like, you know, like one
0:23:52 big problem, microservices, they get very chatty cause they're always
0:23:54 like, cause it's the same problem.
0:23:56 They're always like pulling like, Hey, any new updates, any new
0:23:58 updates, new updates, you know?
0:24:00 And then they're like, anytime they want to do something, they're like, Oh
0:24:02 wait, I got to go get some Jeff there.
0:24:03 I get some Jeff there.
0:24:04 But with the sync engine, it's like, well, no, like each microservice can just
0:24:07 say like, this is the data I care about.
0:24:10 And it has like a local SQLite database running that it can query against
0:24:14 whatever it wants and like every bit of data is like up to date within like
0:24:18 a, you know, fraction of a second that just like would dramatically speed up
0:24:23 a lot of sort of microservices set up and dramatically reduce the chattiness
0:24:26 going on in between different services.
0:24:32 Global Reactive Data
0:24:32 Yeah, I love that analogy.
0:24:34 I think this was really like what blew my mind about React in the, like, when I saw
0:24:39 it the first, the first time, not just that it made my life simpler by not having
0:24:44 to take care of like all of the dumb children, like appending, creating, etc.
0:24:50 So it made everything simpler, but also having all of that just work
0:24:55 automatically without me having to even like tell it like, Hey, now update.
0:24:59 That reactivity for the views, but also for like the local state, but applying
0:25:04 that now for global data, uh, I think that is really a killer feature of
0:25:09 local-first that I think is not well understood by, by a lot of app developers.
0:25:14 It's just so funny because like it's the water we live in, you know, it's like, Oh
0:25:17 yeah, when you're building stuff, you're just, you spend a lot of time moving data
0:25:20 around and checking it and updating it.
0:25:23 And it's just like endless little problems.
0:25:25 Uh, I remember like Gatsby cloud, we would like, it was such a common problem
0:25:30 where it would like ship an update, which like, you know, use a slightly
0:25:34 less efficient query or up the number of calls Internal API calls, and then all
0:25:41 of a sudden, like the post, our Postgres database with like red line, like, and
0:25:44 we like, ah, no, like, or whatever.
0:25:47 And like, it was just like a constant headache because like, when everyone's
0:25:51 constantly like asking for stuff, there's just enormous inefficiencies.
0:25:55 Cause like, I remember that was a big thing where people are like early on
0:25:58 with React, people are like, oh, like.
0:26:00 My jQuery calls are so efficient, you know, and like react is doing
0:26:03 all this extra work and whatever.
0:26:04 But what pretty soon everyone kind of realized it's like, well, yes, like react
0:26:09 does do extra work to accomplish the same goal, but it's only actually more
0:26:14 work if every single jQuery operation was optimal, like you'd actually thought
0:26:21 through the algorithm, you know, in detail for every single one, because in practice.
0:26:27 Everyone was just doing lazy, weird shortcuts.
0:26:30 You're like, you're like, I just got to ship this feature.
0:26:32 So I'm just going to blow it away and rewrite the whole thing or whatever.
0:26:34 He said, we were doing all sorts of like weird, crappy things to, to, to
0:26:38 kind of like update the Dom, which, yeah, it was just like very janky,
0:26:43 very slow all the time and whatever.
0:26:46 So, so, so react was like, yeah, it's like, it was an
0:26:48 overhead to doing automatically.
0:26:50 But it was sort of like a consistent overhead and everything was consistently
0:26:56 a little bit slower than optimal instead of like sometimes optimal,
0:27:00 sometimes widely not optimal.
0:27:03 And so the same thing with like moving data around.
0:27:05 It's like, you know, people are like, Oh, yeah, like, My data fetching is so
0:27:10 clean and so good But you know, you have one engineer who just accidentally grabs
0:27:16 five megabytes of data from their API and like, whoops, and then all of a sudden,
0:27:20 like the whole thing falls to pieces where, again, with like sort of more of
0:27:24 an higher level of abstraction, it's like, you just, it just can't happen because
0:27:29 you can even put in checks, you're like, You can only ask for max of 300 kilobytes
0:27:34 in a batch or something like that.
0:27:35 Whatever.
0:27:36 I mean, there's all sorts of like.
0:27:38 Smarter things that the system can do for you.
0:27:41 All kinds of new abstractions of kind of like both face these same
0:27:45 challenges of, of, or complaints.
0:27:47 It's like, Hey, like I do it really well and you're doing it poorly
0:27:50 in all these cases and whatever.
0:27:52 But if the abstraction is like good enough, it eventually
0:27:55 pretty quickly becomes.
0:27:56 Better in most cases and often better in all cases.
0:28:00 And even if it's not better in all cases, like taken as a whole, it just eliminates
0:28:04 a lot of really suboptimal problems.
0:28:07 It's like memory management, you know, that's sort of another great example.
0:28:10 Like people are like, I manage memory so well, like these GCs, there's
0:28:13 lots of overhead, blah, blah, blah.
0:28:15 And then like.
0:28:16 30 years of, uh, CVEs of, you know, security issues.
0:28:20 It is very, very hard to build fast, efficient data loading and
0:28:24 keeping it up to date and whatever.
0:28:26 After like, you know, spending all this time building local-first stuff,
0:28:29 even like very good apps built with like great teams, like, you know,
0:28:33 name a name, like Vercel's dashboard.
0:28:34 I mean, they're pushing like react server components and all that stuff,
0:28:36 but like you click around their dashboard and there's like endless little, like.
0:28:41 Loading, you know, like if they had a sync engine, they would know that the next few
0:28:48 has all the data and it's up to date and they wouldn't have to like go back to the
0:28:51 server, like, Hey, did anything change?
0:28:52 Did anything change?
0:28:53 Cause I'm sure they have a local cache, but like what
0:28:55 they're doing is always like.
0:28:56 Asking again on every click, they're like, Hey, has anything changed since
0:29:00 the last time this person was here?
0:29:02 And that, like that request, like, or sort of that, that fundamental uncertainty with
0:29:07 an imperative approach, like, just because you just can't, you can't, you can't
0:29:12 know if, if, if the data is up to date, um, there's no way of knowing for sure.
0:29:16 Cause there's no system that's like reliably telling you that like, yes, the
0:29:20 data is up to date for this next view.
0:29:22 You have to check.
0:29:25 And that check.
0:29:26 Take some amount of time, which adds glitchiness into your UI.
0:29:29 And there's just no way of, no way of getting away for that
0:29:31 without, without a sync engine that can like provide the guarantee.
0:29:34 I think it's really interesting.
0:29:36 You've used the term, uh, thinking about your app data first, maybe as opposed
0:29:41 to view first or, or react first.
0:29:45 Yeah.
0:29:46 I think that's kind of a big mental shift that I've also observed in my own app
0:29:52 development evolution of my perspectives.
0:29:56 And I think this has been a really powerful step because it intuitively
0:30:01 makes sense that if you don't have the data, then if you want to render it.
0:30:06 And you don't have it, then you also can't render it.
0:30:09 And so thus you render a loader or a skeleton, et cetera.
0:30:14 Whereas if you think about your app.
0:30:17 Navigation routing user experience overall more in a data first way to
0:30:22 think about, okay, I'm currently here.
0:30:24 This is all the data that I need, but also think a step ahead of like, Oh, what if
0:30:29 I would go to, to this other route here?
0:30:32 Maybe I should already have the bare essentials in terms of the
0:30:36 data for that, that if I'm going there, it's immediately available.
0:30:40 And then you think about your data more, maybe you think about it as a
0:30:44 graph or like a collection of documents, however, you want to think about the
0:30:47 data, how it fits your app's use case.
0:30:49 But once you start thinking about your app data first, I think it's
0:30:54 so much easier to build a really.
0:30:56 high quality, fast user experience then, um, and it's also so much
0:31:01 easier to make that available offline.
0:31:03 I'm not sure whether you need Vercel's dashboard, which is gorgeous, but has
0:31:08 a bunch of loaders, loading spinners.
0:31:09 I don't think you need that necessarily to work offline.
0:31:12 But another way to, if it works on offline, then it's crazy fast.
0:31:17 And I think it would be great if it was a lot faster.
0:31:21 So I would, I would completely agree with kind of thinking about your, about
0:31:25 your app development workflows as data first, as opposed to React or Vue first.
0:31:32 So we've been talking a lot about the, all the good things now that you've
0:31:36 experienced with local-first, but I'm sure you've also experienced like
0:31:40 some pain points, some challenges, um, in regards to that new approach
0:31:45 of building software or in regards to the technologies you've been using.
0:31:49 Tell me a bit about that, which sort of challenges have
0:31:53 Learning curve & other challenges
0:31:53 Yeah, there's definitely a few.
0:31:54 I mean, there is some learning curve.
0:31:56 It's not the same as what was before there.
0:31:58 There's a lot of things that cross over.
0:32:00 So it's not like a huge step.
0:32:02 You're going to have to like spend some time learning stuff regardless
0:32:06 of whatever tool you choose.
0:32:07 You're gonna have to like learn stuff for that that you don't know now.
0:32:09 But I think there's also at this current point of immaturity in the market,
0:32:13 there's not like a clear market leader.
0:32:15 Yeah.
0:32:15 Yeah.
0:32:16 Who's very good and mature that lots of people use.
0:32:18 So, you know, like in in, in sort of we're like, Hey, next Js.
0:32:22 Like that's sort of the obvious choice.
0:32:23 'cause the billion people use it and it, it's kind of
0:32:25 covers everything and whatever.
0:32:26 So you both have the, I have to evaluate a bunch of tools, a
0:32:29 step to get, get into this world.
0:32:31 And then you're like, and then I have to learn a specific tool in depth.
0:32:35 'cause there's, there's, it's just different than, you know,
0:32:37 like no one's done it before.
0:32:39 Almost nobody's done it before.
0:32:40 So you're going to have to like learn stuff to do that.
0:32:41 So that's definitely a bit of an overhead, uh, in this approach.
0:32:45 And another result of the immaturity is like, there's just things that don't work.
0:32:49 So there's sort of the magical, like I'd be kind of describing like sinking,
0:32:53 just like, Oh yeah, they're just sort of magic, but they're not actually magic.
0:32:56 They actually.
0:32:57 are an engineered product and there's stuff that they just don't do yet,
0:33:02 um, that you'd rather like them to do.
0:33:04 And so it's, uh, you know, learning those limitations and like working within
0:33:08 them or even, you know, even decide if you can or not is part of sort of the
0:33:12 evaluation process and building process.
0:33:14 So far for my toy apps, it hasn't been an issue, but like, there's definitely
0:33:17 things that I'm like, I can't build those things with this stack right now.
0:33:21 And like, yeah, the engineering, you know, the teams behind
0:33:22 these, like they know about it.
0:33:23 And like, they're working hard to, to, to fix them.
0:33:26 A lot of stuff is kind of like just the same.
0:33:28 It's just building a map.
0:33:29 You're just like, I need data and data's there.
0:33:31 Before I'd write a REST API call or GraphQL call or whatever.
0:33:35 And on the backend, I'd write a query.
0:33:37 And now you just write the same query, but it runs locally.
0:33:41 And the day to day, just like building views and stuff, it's extremely similar.
0:33:46 You know, it's like before you'd probably like to sort of hash out like
0:33:50 the, the data locally and the client.
0:33:52 But now I just started like, Oh, I need to like change my data model.
0:33:54 So I'll just tweak the, you know, the database structure a
0:33:57 bit and then, you know, change my query a bit in the front end.
0:34:00 So yeah, I mean, day to day, it's like, it's very similar,
0:34:03 but just like less steps.
0:34:05 Cause you don't have to like change your GraphQL or you don't have
0:34:08 to change like the client call.
0:34:10 It's only like two steps.
0:34:11 It's like you change the database table.
0:34:13 And then you change your query in, in, in your, in your component.
0:34:17 And then that's about it.
0:34:18 So it's pretty, it's pretty simple.
0:34:21 That makes a lot of sense.
0:34:22 And I mean, just overall trade as for, for most early technologies, if you're
0:34:27 early to those technologies, you bet on some superpowers and you probably
0:34:32 acquire those new superpowers earlier than most of us, but you also got to
0:34:40 Technical pioneering
0:34:40 Yeah.
0:34:40 It's just like, yeah.
0:34:41 I think the biggest thing is like.
0:34:44 I just randomly have gone into like, Oh, do, do, do, do, do, I'm doing something.
0:34:48 And then like, bam, I hit something and then I'm like stalled for like
0:34:51 a day while I either figure it out or, or figure out a workaround.
0:34:56 So I think it's, it's, it's kind of like if you're using boring technology.
0:35:00 It's like, it may be tedious and hard or whatever, but it's
0:35:04 sort of like a known tedium.
0:35:06 You're like, this is going to take me like one week, where with a new
0:35:10 technology, it's either going to take you an hour or two weeks, you know?
0:35:14 So, uh, it was a lot more uncertainty on what's going to happen.
0:35:18 And you might run into stuff that just like absolute blockers where again,
0:35:21 with the old stuff, it's kind of like every single possible work around.
0:35:25 Has been figured out for every possible thing.
0:35:27 And so it's just a matter of finding that obscure forum post from like
0:35:31 five years ago, where they're like some weirdos, like, Oh, I spent five
0:35:34 days on this, but here's the fix.
0:35:35 And you're like, freak.
0:35:36 Like we are, we have a kinship.
0:35:38 You and I know we two people are the only ones that have run into
0:35:41 this problem before, but thank you.
0:35:43 You, you wrote it down for me, so I don't have to figure it out myself.
0:35:45 So, so yeah, the new technology, it's like most of the problems you run into, you
0:35:49 are the very first person to run into it.
0:35:51 Which is fun.
0:35:51 It's sort of like, yay, you're like, I don't know.
0:35:53 But yeah, it's, it's, you're gonna have to be like a pioneer, sort of a
0:35:56 more robust, I don't know if Europeans talk about pioneers, but anyways,
0:36:00 like American pioneer, you're kind of like, ah, we're going off into
0:36:02 the wilderness and got an axe on our shoulder and, you know, whatever.
0:36:06 We're just gonna like make it happen.
0:36:07 You kind of have to adopt that, that mindset, um, when you're
0:36:11 kind of into new technology.
0:36:13 Yeah, that's very relatable for me.
0:36:15 I've always considered myself to be kind of like a technical pioneer.
0:36:19 So what you've just mentioned in terms of, yeah, sometimes like it's a gamble
0:36:23 and sometimes like it's the, the sort of promise of everything will be simpler
0:36:28 and easier in the future that plays out.
0:36:30 And you can't believe like how the thing that just took so much effort
0:36:34 and so much work in the past is now so easy, or you run into a wall Or
0:36:40 in theory, it would have worked, but you run into some edge case that
0:36:44 you're the first one running into.
0:36:46 And it might be fixed with the next release of whatever you're using,
0:36:50 but you still have run into it.
0:36:52 But luckily you've run into it.
0:36:54 And then the next person is no longer running into it, depending
0:36:58 on how quickly someone releases.
0:37:00 Yeah, there's there's sort of a sense of community service you, you, you.
0:37:04 Get, or at least it's helpful to get with new technologies.
0:37:06 You're like, yeah, I'm going to pay down the cost for everyone else a bit.
0:37:10 So another observation here, I think it's really interesting that
0:37:14 the use cases you've mentioned, your ambitions for those apps.
0:37:20 We're not to like take it to market and like roll it out to millions of users.
0:37:24 It was, I think like part of the fun that you built a software
0:37:28 that's just for you and you can make it as fancy or ugly as you want,
0:37:34 like no, one's going to complain.
0:37:35 and you know like the little quirks, uh, of it and that it took you less effort to
0:37:41 make that happen, to build the thing you wanted to build and like spend less time
0:37:46 with like all of the boilerplatey things.
0:37:48 That's great.
0:37:49 And I think that, that is totally fine.
0:37:51 Like no one's going to take you, take that away from you.
0:37:55 Uh, I think what's still a little bit less proven is like, how do you
0:37:58 really If you were to take that app now and say, I do want to scale it
0:38:03 to millions of users, et cetera.
0:38:04 I think that's another aspect of where we are still pretty early.
0:38:09 And on our pioneering journey, we have not yet figured out like hit all the traps.
0:38:15 But, uh, I think from first principles, I think, uh, this
0:38:22 Developing, deploying, scaling
0:38:22 I don't, I don't see.
0:38:24 Any like showstoppers for sort of scale to millions and a lot of ways again too.
0:38:29 It's like, it's actually no apps do scale to a million.
0:38:33 What happens is people build it and it falls apart and then they like rebuild
0:38:37 it several times and get to millions.
0:38:40 So what actually I think is actually pretty interesting about this and like
0:38:42 promising is like there is a story here prototype to millions with like
0:38:47 no changes to your basic architecture.
0:38:51 Which I don't think anything else can make that claim, but like the base system of
0:38:56 like what everyone plans to do is like you can horizontally scale sync engines
0:39:00 without any issues because you can just have sticky, sticky connections from
0:39:04 clients to, to particular sync engine and it's managing the state for each user.
0:39:07 Postgres is easy to vertically scale.
0:39:10 What's interesting else, but like Postgres actually has like a lot
0:39:12 less demand in this world because far fewer queries are reaching it.
0:39:15 So it's actually like you don't have to scale Postgres nearly as fast as
0:39:19 you kind of typically expect to, you know, with this approach, people either
0:39:22 do sort of normal API stuff because you can still just call Lambda and
0:39:25 do whatever and write to Postgres.
0:39:26 Can I was talking about the Garmin example, you can write locally, like,
0:39:30 I want to do this sort of our sort of event sourcing style where you're like,
0:39:33 the client says, I want this to happen.
0:39:35 And then the back end.
0:39:36 Serverless function picks up the job and then kind of writes
0:39:39 it back and then it gets synced back to the, the client anyway.
0:39:42 So that, that, again, that approach is also extremely scalable because it's
0:39:46 all serverless and stateless and you can have as many workers, you know, spinning
0:39:50 up to, to handle stuff for people.
0:39:51 But yeah, we're not there.
0:39:52 This is all very, that's all very potential.
0:39:54 But I think what's extremely promising is like, you know,
0:39:57 what are the different stages?
0:39:58 What are the three major stages?
0:40:00 It's like how efficient is a tool of prototyping?
0:40:02 How easy is to go from prototype to production and
0:40:05 then how easy it's to scale.
0:40:06 So those are like three distinct problems.
0:40:08 So problem line prototyping, I think both of our experiences, it's a lot
0:40:13 easier to prototype with a stack.
0:40:14 Like it's data centric, you have like a full type safe client, you know, from
0:40:18 the get go, a lot of boilerplate is gone.
0:40:20 Like you just like, bam, you go.
0:40:22 And then again, like prototype production, extremely easy.
0:40:25 Like I, like I've done lots of side projects in the past that I
0:40:28 always kind of came down to it.
0:40:29 Now I'm going to.
0:40:30 Deploy it.
0:40:31 And I was like, uh, I have to rewrite so many things and I have to like, do all
0:40:36 this crap that I didn't have to do before.
0:40:37 Like, Oh no, where's the steak going to go?
0:40:39 Whatever.
0:40:39 Like I I've gotten, I've gotten my sort of go live checklist.
0:40:45 It's like five things and like, it takes me less than an hour.
0:40:49 So it's extremely fast to go from like prototype to production.
0:40:53 And then, you know, production scaling.
0:40:55 Yeah.
0:40:55 That's, that's, that's the part that doesn't really exist, but in theory,
0:40:59 like, I think the architecture is like.
0:41:01 A very scale free, like, it's mainly just a sync engine that, um, needs.
0:41:08 Proven at scale.
0:41:10 I mean, I do think that I fully agree with the way how you delineated
0:41:15 that into those like 3 steps.
0:41:17 Um, but I would even say that the scaling part I think has been proven
0:41:22 by quite a couple of companies by now, whether, uh, Whether it's like thinking
0:41:26 about Replicash, uh, Rosicorp has built with Replicash and Reflect, et cetera.
0:41:31 I think they have a couple of customers that are really going at scale and
0:41:35 the entire system I think is quite inherently scalable and, uh, the, it
0:41:41 doesn't change the, the simplicity of the system, which is, which is the beauty.
0:41:46 Um, and a lot of, a lot of the, a lot of the parts of the system can
0:41:50 still be considered stateless, which makes it a lot easier to reason about.
0:41:54 linear, linear had a really great talk about, uh, linear
0:41:58 CTO, uh, had a really great talk about, uh, how, how they scaled.
0:42:04 And it's, it's pretty fascinating, like all the things that they
0:42:06 did, but yeah, to your point, people have gone down the path.
0:42:10 So, you know, innovation kind of goes through, like,
0:42:13 is this thing even possible?
0:42:15 Or somebody has to, like, discover something.
0:42:16 Like, there's this like, oh, there's this new thing that we can do.
0:42:19 Wow.
0:42:19 Who knew?
0:42:20 And then it's sort of like.
0:42:22 It goes from that to then sort of eventually to sort of a product
0:42:26 where it's kind of like that technology is then encapsulated
0:42:29 to something that anybody can use.
0:42:30 So the fact that multiple independent teams have successfully gone down
0:42:35 this path shows that then sort of now.
0:42:38 What we're seeing is sort of a productization of sync engines.
0:42:41 If you want to do a sync engine, you have to like buy it.
0:42:42 You don't have to build it.
0:42:43 You can just buy it off the shelf.
0:42:44 Um, I think we're pretty close to that being a reality.
0:42:48 Approaching local-first
0:42:48 So you've been going through this journey, I guess, over the last
0:42:52 year or so of like learning about local-first and step by step building
0:42:56 your own apps with local-first.
0:42:58 What would be your advice to an app developer who's curious
0:43:02 about local-first, but has not yet taken their own first steps?
0:43:06 What would be your advice to them?
0:43:08 I don't know.
0:43:08 My, my, my general advice on any technology is just to dive right in.
0:43:12 I mean, there's lots of stuff you can read about it.
0:43:14 So, so by all means, like, you know, listen to cool, cool podcast.
0:43:18 There's lots of blog posts.
0:43:20 Yeah.
0:43:20 So it was definitely lots you can read and listen to and watch and stuff.
0:43:23 But, um, there's no better way to feel it, to like, to understand
0:43:26 it and to really feel it than just to like start building some stuff.
0:43:29 All the different tools have starters and they're very approachable.
0:43:33 They're not like particularly hard to use.
0:43:35 And, you know, Take a day or two and build something.
0:43:39 Cause yeah, it's really just like, when you just see it sinking between
0:43:43 tabs and you're just like, you're just kind of like, you, you really
0:43:47 kind of have to feel whenever you're just like used to doing something.
0:43:50 You just, you just forget about it.
0:43:52 We get numb to all the stuff we do.
0:43:54 So you really just have to like.
0:43:55 To really feel the difference of local-first you just have to build
0:43:58 something and then you're just like where's all this stuff that you just sort
0:44:02 of feel voids in your in your soul you're like you're like where's all the missing
0:44:06 stuff you know like where's all those things I normally do and you're just kind
0:44:10 of like oh they're just gone and then like after you've done a few you're kind of
0:44:13 like You just start to forget about it.
0:44:15 It's like this bad, weird dream of like spending all that time on all
0:44:18 those things that are now gone.
0:44:20 But yeah, you just, you can't really appreciate that until
0:44:22 you've actually built something.
0:44:24 Uh, let's see whether in five years from now, we look back into the days where
0:44:28 we haven't built, been building with local-first and we see it just crystal
0:44:32 clear as that analogy you've given before.
0:44:35 With going from jQuery to React and React freed up, uh, freed us up
0:44:40 from having to think about how to render the views in the correct way.
0:44:45 And now we get the same thing for data.
0:44:48 So this is beautiful.
0:44:50 Now, yeah, talking, talking to younger developers, like sometimes
0:44:53 I mentioned jQuery and I'm like, Oh wait, they've probably don't jQuery is.
0:44:59 And it's just a very weird feeling to be like, Oh, yeah, just jQuery
0:45:02 thing it was like this and they're just like, yeah, okay, whatever like
0:45:05 yeah It'd be it'd be really amazing if like apis was the same thing.
0:45:08 Like yeah, we used to like You'd write like an HTTP method and then you sort
0:45:15 of like make up a name that sort of meant something and then you like how
0:45:20 to like remember to like write it all the same thing and your client you know
0:45:24 you're like it's not a post it's it's a put and you have to like no typos and
0:45:29 they're like that's it's like a lot of tedious, fragile, annoying code to write.
0:45:35 And you're like, yeah, it was, it sucked.
0:45:37 And they're like, I just used like the library and I just sort of typed stuff
0:45:40 and like, you know, Copilot v10 just sort of like spits out whole, whole, whole
0:45:45 stuff, you know, cause it just introspects on my whole data system and like writes
0:45:48 out super efficient stuff for me.
0:45:49 And yeah, I, I, I'm very big on like, you know, getting rid
0:45:53 of work we don't have to do.
0:45:55 Um, and I think there's a lot left in programming that you
0:45:58 really shouldn't have to do.
0:46:00 Outro
0:46:00 Let's leave it here.
0:46:01 Anything you want to share with the audience?
0:46:04 Have fun, build cool stuff.
0:46:06 That sounds great.
0:46:06 Kyle, thank you so much for coming on the podcast.
0:46:09 This was a lot of fun.
0:46:10 Yeah, it was a lot of fun.
0:46:12 Thank you for listening to the localfirst.fm podcast.
0:46:15 If you've enjoyed this episode and haven't done so already, please subscribe and
0:46:18 leave a review wherever you're listening.
0:46:20 Please also tell your friends about it.
0:46:22 If you think they could be interested in local-first, if you have feedback,
0:46:25 questions or ideas for the podcast, please get in touch via hello at
0:46:29 localfirst.fm or use the feedback form on our website, special thanks to Expo and
0:46:35 Crab Nebula for supporting this podcast.