49:16I think that's a nice segue.
49:17And we've been mostly covering sort
of like the, the more cultural aspects
49:21of Linear so far, given this is the
local-first podcast where we haven't
49:27yet talked too much except for the
beginning about syncing, et cetera.
49:31And I don't think we need to spend
another hour and hour going all
49:35the way there, but maybe just
briefly connecting the dots there.
49:38I think the reason.
49:40that what gives you this competitive
advantage allows you to build that high
49:44quality product is that you have laid that
foundation with the, the sync engine that
49:51takes out of like the, the picture, the
entire complexity nightmare that, moving
49:57data from A to B and back to A can be.
50:00And so you've solved that and like
on your shoulders of Giant, now
50:05the, the the, the product can be
built by people who don't have all
50:09of that knowledge of data syncing.
50:12And I think that is like a superpower
that enables new products like Linear.
50:17Yeah.
50:17I mean, I do have a talk
on, your conference on that.
50:20It's, it's probably
available on YouTube as well.
50:23If you want to, if you want to check it
out and put it into the, I don't know,
50:26notes for this, this, this podcast.
50:28But yeah, in short, like, The
initial idea of the sync engine was
50:32not to make it developer friendly.
50:34That sort of happened as an afterthought.
50:36And that was, in my mind, maybe the
more more important aspect in the end.
50:41Like, we wanted it to be fast and support
offline mode and enable, the application
50:45to be quick and that is important, but
what we found out what, what we like even
50:49more was that engineers would be able
to just ship features much, much faster
50:55without having to think about a vast,
area of, of A functionality that usually
51:00takes quite a bit of time, which is sort
of error handling or networking, waiting
51:03for things to come back, supporting
two different code paths for like when
51:07you make your local changes versus when
somebody else makes those edits for you.
51:12It's all abstracted away so that you
don't need to think about these things.
51:16And it works for certain
kinds of applications.
51:19Definitely not all like if you're
building, something that has, a lot of
51:23information or building a search engine
and obviously not, like, you need to be
51:26able to have that data locally or pretty
close to your, to your clients and be able
51:31to sort of fetch the pieces that you see
on screens and then keep them up to date.
51:35But for anything that
resembles an application.
51:37That has sort of a limited set of data,
and that data piece can, like, the
51:41amount of data that you have in the
whole application can be large, but it
51:44still needs to be limited to, what you
can browse at a , given point in time.
51:48And then this model just
works absolutely beautifully.
51:51And.
51:52I sort of had this inkling at Uber
already, like, I don't want to
51:55build anything in the traditional
sort of networking model anymore.
51:59Like, I think sort of sync is such a
better user or developer experience.
52:04And, and the Linear, like, it's, it's
clear that, I, I, I, well, I won't ever
52:09have a job after Linear, but, if I did,
I, I, I would not work in any other way
52:14than just doing a sync engine again.
52:16I'm working in this environment
because it just makes the, yeah, the
52:20developer experience so much faster
and you can just ship functionality.
52:22Like, the easiest way to think about
it is to literally say that, you're
52:27effectively just building the front end.
52:29You have, data in memory, you've got
data objects, which you render on screen.
52:33Then you modify those and that's it.
52:36Your feature is done.
52:37Everything else is handled,
the synchronization, other
52:40users making the same edits.
52:42There's nothing else you need to
do in order to build a feature.
52:45You just build the frontend and
you're done with your entire feature.
52:49And that's pretty powerful.
52:51And I think that also like empowers the
already capable front end developers
52:57even further, since I think so far
in this more traditional three tier
53:04web app where you have your, your
front end that you're building.
53:07And then somehow like you're doing your,
your fetches or RPC calls, et cetera.
53:13But then you also need to worry about
like, okay, sorry, I need to serialize a
53:16bit of data over there, send it over here.
53:19Now I need to do something there.
53:21And like, Oh, what if.
53:22This now changes and I
need to send this back.
53:25If we can take that entire part out of
the picture and front end developers are
53:30only dealing with like the, the client
side state management, and that's it.
53:34And then either you have, you're
relying on like a external sync engine
53:40that already works super well for you
and you just need to integrate it, or
53:44you have the luxury of having someone
like yourself in a team who builds
53:49your own, runs it, et cetera, which
I think will be not always required.
53:55I think the better the off the shelf
sync engines will get the more products
54:00can already be built with that.
54:02And I think someone like yourself
will rather be needed when a
54:06product really diverges from
that, from that standard path.
54:10And so I would probably say that
maybe in a couple of years from now,
54:15you could probably build something
like Linear in terms of like the
54:19data syncing capabilities with like
something like automerge, et cetera.
54:24Some of those.
54:25Upcoming sync engines, and then
it's probably rather a matter of can
54:30it also handle all of the scaling
patterns and the extra user experience
54:35patterns that you want to really nail.
54:38I want to give an example of,
like, how hard RPC actually is.
54:42Because I don't think people
understand, like, before they've tried
54:46it out and then run into these edge
cases, which always are edge cases.
54:49But once you run into them, you're
like, oh, shit, what do I do now?
54:53You need to rethink your
entire architecture in order
54:55to make that, make that work.
54:56So A simple example, you've got,
some sort of model object and it
55:01has two properties, and the user
makes a change to those properties
55:05and sends it out as an RPC call.
55:08And you're also connected with a WebSocket
to receive changes that other people do.
55:12Now, you send out the RPC call and
wait for sort of acknowledgement
55:16for the server um, that, you
know, everything was applied fine.
55:20While that's going on, you receive a
packet that, another user updated a
55:24certain property on that model object.
55:27What do you do?
55:28Like, and that becomes a really, really
hard problem because suddenly, like,
55:33you, you really don't know what to do.
55:35Like, you can't rely just on
that RPC call coming back.
55:38Because, again, your backend has
multiple servers on it, so you can't
55:42rely on the timing of these things.
55:44It's not just, one single server
running things, you know, serially.
55:48It's multiple servers writing to
the database, and then somebody is
55:51able to sort of send you a message,
and the RPC call might go through.
55:56have already been sent but hasn't reached
you yet because the network is slow.
56:00So when you receive that RPC
code, you don't know if all the
56:04values in there are up to date.
56:06And now you need to figure out what to do
with the updates for that model object.
56:11And when you realize that, you're
like, Yeah, I effectively need
56:14to implement another sync engine
in order to make that happen.
56:17There needs to be a queue of sorts.
56:19And it becomes very, very complex.
56:22It's funny.
56:22So like, it's a sort of a boiling frog
situation where you start out with like
56:28your, your blissfully ignorant happy
path of just like doing a fetch call
56:34to your backend and like, you get your
data back and you test this on localhost
56:39with like your one client over there and
your locally running server over there.
56:43And like, everything just works and like
you ship the feature, like you mark the
56:49issue as done on, on Linear, but then as
it goes on production and like multiple
56:55users hit it, you get some really cryptic
error messages that you, you even have a
57:00super hard time replicating that locally
and you, you've spent hours on it.
57:04Hours and hours and days and days,
like reading through log messages.
57:07Oh, we realized I actually, we don't have
the right log messages for that in place.
57:11So you'll need to spend another two
weeks shipping that until you've like,
57:16finally have all of like the signal that
you pull out of the giant bag of noise.
57:21To finally, like, have at
least some confirmation of
57:25that something is going wrong.
57:27And once you have that hypothesis
to even replicate it locally that's
57:31already takes heaps and heaps of time.
57:34And then, like, The way how you pull
yourself out of that is by step by step,
57:41applying changes that will ultimately lead
you to a sync engine, but that's such a
57:46painful and inefficient way to get there.
57:50I think it's, primarily probably
a problem to get, get us from.
57:54A to B, like A being the status quo
of the world right now, where like
58:00everything is built with the sort of RPC
ish way to B where most products where
58:05it's a good fit are built with sync
engines is probably just that instilled
58:10tribe knowledge that by now like all
the technologies are sort of like.
58:15Fostering that, that status quo where like
all the libraries are built around RPC
58:23and we're, we're kind of blind to, yeah,
it's kind of the spoiling frog situation
58:28where it's already cooking like crazy,
but we don't realize it yet how much
58:32complexity we've built for ourselves.
58:34And how simple things could be.
58:36For sure.
58:37So it becomes simpler to not you
know, implement that WebSocket and
58:40just have the user hit refresh to
get the latest version of that page
58:44and be ignorant about or bliss.
58:46Yeah,
58:47exactly.
58:48Which just dials up the temperature,
58:52but this is where I'm so excited about
Linear and the success of Linear since
58:58people can't ignore products like Linear.
59:02There's like, Oh my gosh,
what makes it so great?
59:05And then people want to.
59:06understand how did you like explain the
success and sure a lot of it will be
59:11attributed to like oh they have such
those great people and they have such
59:16great design and they have that amount
of like border radius but then a lot
59:22of it will also come down to the to
the implementation this is what I where
59:26I hope that this will drive a lot of
like Similar to how Nike focuses not as
59:32much on the products, but on the great
athletes, you're the great athlete.
59:35And I'm very much looking forward
that people want to be like you.
59:40I really, enjoy working in a
local-first environment, and I hope that
59:44everybody else picks that up as well.
59:47And there's starting to be tooling
around it, around the, local-first as
59:51well, that you can use out of the box.
59:53That will probably work
for most of the cases.
59:56It will still be hard to scale that up.
59:58But at least you can get started and
maybe then figure out whether you need