DejaVue | Inertia.js (with Joe Tannenbaum)

Vue.js can be used in many different ways - with a meta framework, as a plain SPA, via the script tag and also with Inertia! Created in the Laravel ecosystem with adapters for various back- end front-end frameworks, Alex and Michael got a special guest on the episode who couldn't fit better to illustrate what Inertia is capable of.

Joe Tannenbaum, Software Engineer at Laravel and Inertia contributor goes all in-depth on the capabilities of the library, as well as sweet features and changes coming up for the future Inertia v2 release.

Looking for an easy way to write applications? After this episode, you might have found it.

Enjoy the episode!

Our Guest

Joe Tannenbaum

Chapters

(00:00) - Welcome to DejaVue
(00:56) - What is Laravel and when did you got into it?
(05:40) - Does Laravel has starter kits?
(07:41) - Laravel Cloud, funding and growth
(13:22) - What are TUIs?
(16:37) - What is Inertia?
(22:15) - How would Authentication work with Inertia?
(24:01) - Adapters for Phoenix and Rails
(25:08) - Feature in Inertia version 2
(32:53) - Breaking changes for v2
(33:56) - Composition API or Options API?
(37:27) - What part is the routing layer?
(38:48) - Further Inertia Helpers
(41:14) - Inertia's SSR story
(45:17) - Data fetching
(46:48) - When not to Inertia?
(47:45) - How much do you think about Inertia when coding?
(50:09) - Too many amazing things to use
(52:20) - Wasn't Inertia "done"?
(54:23) - Wrapping up

Links and Resources

Get 15% OFF for your Vue Toronto ticket with code DEJAVUE *

Your Hosts

Alexander Lichter

Michael Thiessen

---

Links marked with * are affiliate links. We get a small commission when you register for the service through our link. This helps us to keep the podcast running. We only include affiliate links for services mentioned in the episode or that we use ourselves.

Creators & Guests

Host

Alexander Lichter

Web Engineering Consultant • Founder • Nuxt team • Speaker

Host

Michael Thiessen

Full-time Vue educator

Guest

Joe Tannenbaum

Software engineer @laravelphp

Editor

Niki Brandner

Sound Engineer

What is DejaVue?

Welcome to DejaVue, the Vue podcast you didn't know you needed until now! Join Michael Thiessen and Alexander Lichter on a thrilling journey through the world of Vue and Nuxt.

Get ready for weekly episodes packed with insights, updates, and deep dives into everything Vue-related. From component libraries to best practices, and beyond, they've got you covered.

Alexander Lichter: 00:00

Hey, everybody. Welcome back to DejaVue.

Michael Thiessen: 00:03

Your favorite view podcast. You just don't know it yet. I'm here with Joe Tannenbaum and Alex, my co host. You may have seen him here before. And we've got a lot of interesting things here to talk about today.

Michael Thiessen: 00:17

Laravel, Inertia, JS, you know, some great stuff.

Alexander Lichter: 00:21

Exactly. So Joe is a software engineer at Laravel at your open source team as well. He's a public speaker, so you might have seen, 1 or 2 or 3 or more talks of him, maybe at Laracon, recently. Also, everything is linked in the show notes and description. Maybe you've also seen his Larica series about, terminal UIs, if you're into that.

Alexander Lichter: 00:40

Otherwise, definitely give it a a swing. It's it's lots of fun. And besides that, he's also a host at the PHP X NYC meetup being in New York. So, Joe, welcome to the show. How are you doing?

Joe Tannenbaum: 00:52

I'm doing great. Thank you so much for having me. I appreciate appreciate it.

Alexander Lichter: 00:56

Of course. Of course. So maybe let's start with the obvious thing. Being a software engineer at Laravel, how is that going? Laravel, maybe for anyone not familiar with the framework, maybe let's just start with what is Laravel and, yeah, how it is working on the open source team there?

Joe Tannenbaum: 01:11

Sure. It's, fantastic. Laravel is, one of the biggest PHP frameworks out there, and, it's full featured. It's stable. It's mature.

Joe Tannenbaum: 01:20

So it's kind of got a lot of first class offerings, and inertia is one of those things. So it's our it's our solution for linking, the JavaScript side of the equation with the PHP side of the equation in a really seamless way. I think most people who have any idea for me about me, are surprised. They're like they're like, this guy has JavaScript? I thought he just lived in the terminal all the time.

Joe Tannenbaum: 01:43

But, because all I've been talking about for so long is are are Chewy. So I'm excited to, to flex this muscle a little bit as well. So excited to be here.

Alexander Lichter: 01:54

Perfect. So yeah. How how long how long are you, like, around with Laravel? When do you start using it? Maybe start using it first time professionally?

Alexander Lichter: 02:01

When when did your Laravel journey start there?

Joe Tannenbaum: 02:04

My Laravel journey started, I believe, in 2014, maybe a little earlier. I think it was 5.4, so we're now at, 11 something. So, I've been around for a while. It was suggested to me, I think, I was on CodeIgniter before that if anybody knows PHP frameworks at all. Yep.

Joe Tannenbaum: 02:24

So I was on CodeIgniter, and I came over to Laravel because the code read like English, and it was really a unique experience at that time, during software development and using frameworks. It was it it was really fluent, and it was just very easy to understand and and latch onto. And so I switched, and I I haven't looked back. I mean, I've played with a lot of other tech, but, like, Laravel is the the undercurrent of of my my stack for the most part.

Alexander Lichter: 02:50

Sweet. Yeah. I remember, like, it's it's very funny because I also started dabbling into coding letter, like, a little bit, and I was like

Michael Thiessen: 02:56

Mhmm.

Alexander Lichter: 02:57

Not sure. And I discovered Laravel back then in time, before, like, doing only JavaScript nowadays.

Joe Tannenbaum: 03:03

Yeah.

Alexander Lichter: 03:03

Yeah. It's it's pretty amazing. Also, like, I think 5.5, 5.6, something like that was was one of the last versions I was, on and still have projects in Laravel that are just there and need a little bit of maintenance here and there, but, like, yeah, it's it's crazy what the framework all gives. And it's in a way interesting that that that's a thing in in PHP that you get, like, authentication, for example, that you just get the queues and jobs workers, everything out of the box if you need it and and everything around it.

Alexander Lichter: 03:31

Yep. While yeah. In the JavaScript world, it just feels like there there is no, like, such a full featured framework. Like, you have this, take everything on your own and, like, oh, here's the rendering library and here's the state management tool and this and that and a bit of the back end. I I mean, there are some tools like Adonis.js for example, that that somehow they don't get the the the critical mass in terms of adoption. So that's definitely interesting to see that this exists in the PHP universe and that lots of people are building amazing things with it.

Joe Tannenbaum: 04:01

Yeah. It's it's nice to have a lot of decisions made for you for common things that you need, like auth, like Queue, like the ORM. And then also, there's a whole ecosystem of very stable packages that you can choose from if you want to go a different way with it. So you still have the choice, but I can scaffold up, like, a fully auth app connected to whatever database driver I want in in under a minute. Like, it's done.

Joe Tannenbaum: 04:27

And then I can just start actually building the app itself, which is always I don't know. I feel monstrously productive with Laravel, which is, which is why I now work there.

Michael Thiessen: 04:39

Yeah. That sounds amazing. And it sounds so different than the JavaScript side of things where you're like, okay. Like, like, like Alex was saying, you gotta figure out, you have to spend hours just deciding which auth provider am I going to use? Oh, and then which, which package to connect to that?

Michael Thiessen: 04:57

You know, like, how am I going to and then you have to actually set it up. And then you're like 2 days later, you're like, sweet. I got my auth. Now I gotta

Joe Tannenbaum: 05:05

I got the base going. So let's go now let's build the thing. Yeah. And

Michael Thiessen: 05:07

then you deploy it, and then you find out, oh, it only worked locally and then not yeah. And then you

Alexander Lichter: 05:12

have to

Michael Thiessen: 05:13

kind of this whole Yep.

Joe Tannenbaum: 05:14

Oh, like, it's like okay.

Alexander Lichter: 05:17

The different run times. And then, oh, yeah. Common JS and ESM, and, oh, there's incompatibility there. It's sometimes, it's like a real pain.

Michael Thiessen: 05:26

Yeah.

Joe Tannenbaum: 05:26

I think that's why the starter kits are so popular. Right? Because people don't wanna make those decisions all the time. They just want something plug and play that works. And so that's they seem to be quite popular right now.

Joe Tannenbaum: 05:37

The the starter kits in the JS ecosystem.

Alexander Lichter: 05:39

That's absolutely true.

Michael Thiessen: 05:40

Does Laravel have starter kits or is it just a starter kit unto itself? Because it has so many things like right out of the box.

Joe Tannenbaum: 05:50

Yeah. It does come with a lot of things out of the box. And then we have 2 different starter kits if you wanna bundle in stuff like, you know, out of the box authentication and teams and, 2 factor auth. Like, all of this comes with like, we have a a package system called composer. And so that's 1 composer install away.

Joe Tannenbaum: 06:09

So you just and you can choose within those starter kits, different stacks. So you can have Livewire, which is our, more server focused non JS, client side rendering. It's kinda hard to describe if you don't know what Livewire is, but it's sort of this, like, very magic y, you're writing JavaScript without writing JavaScript thing. And then there's the inertia stuff which allows you to build out your client side with either, React, Vue, or Svelte with just a little connective tissue between Laravel and the client side. So, yeah, those are just a composer install away, and then you can just get cooking on what you actually are building because you don't wanna build app, like, off for the 100th time.

Joe Tannenbaum: 06:51

Like, nobody wants to do that. We're all done doing that. So you wanna just build, you know, the crux of the app. Like, what is the thing you're actually building? And you can just get there super fast.

Joe Tannenbaum: 06:59

Yeah.

Alexander Lichter: 07:00

Absolutely. And, I mean, then also, like, Laravel Spark is a thing where you get basically all the back end focused, feature sets of, like, oh, yes. You can billing setup with thousands of, like, payment providers and subscriptions and everything that just works out of the box. You can use it and, as you said, focus on the important parts.

Joe Tannenbaum: 07:17

Totally. We we have a lot of first party packages that are not built into Laravel itself but are maintained by Laravel and the Laravel team. And most of them, the vast majority of them are free. You can just install them and it's good to go. And we have a couple paid offerings such as Spark, and Nova is our admin package.

Joe Tannenbaum: 07:33

So you can have a a fully featured admin just plugged right into your models that just works, out of the box, which is pretty cool.

Alexander Lichter: 07:41

Absolutely. And maybe before we come to Inertia, there is there was one, let's say, larger announcement, recently that we also wanted to touch on a little bit. Laravel Cloud have been coming. So maybe you can tell a bit about what Laravel Cloud is, why it it comes now, and of course the maybe a bit of the funding aspect.

Joe Tannenbaum: 07:59

Sure. Sure. Probably not gonna talk about the funding so much because I don't have a lot of info on that just as an aside. Yeah. So Laravel Cloud is the sort of natural progression of where Laravel has been going.

Joe Tannenbaum: 08:13

So we have, Laravel Forge and Laravel Vapor. Vapor is our our serverless, offering, and Forge is a bring bring your own provider, and we will provision servers within your provider, sort of offering. So you you connect to DigitalOcean or Hetzner or whatever wherever you're coming from, and we'll auto provision your servers based on the needs of a Laravel application. And then we can easily set up, like, scheduled jobs and edit your environment variables and everything right from a beautiful dashboard. So that's been around for a long time, and that's very popular.

Joe Tannenbaum: 08:47

And so cloud is just the next step in that evolution where we know how a Laravel app gets up there. We know how it's deployed. We know how it's built. Can't we just plug and play that? Can't we just point us to a repo, and then we just fill in the gaps, basically?

Joe Tannenbaum: 09:01

And so, it's managed on our side of the equation. It's a fully managed service. And, it's sort of the the Vercel of the of the Laravel world. So we're very excited. The team, I I'm not on the cloud team, but I watched the chats flying by and it's, they're they're working at quite the pace.

Joe Tannenbaum: 09:20

It's very impressive.

Alexander Lichter: 09:22

I can imagine. So you say, like, the the first cell for Laravel, if you like, just summarize it in one sentence, so to say.

Joe Tannenbaum: 09:29

Yeah. Yeah. It's a it's a it's a platform as a service. Yep.

Alexander Lichter: 09:32

Yeah. And Yep. That will it also come with, let's say, performance improvements? So, like, it's set in you know, okay. It's a Laravel application.

Alexander Lichter: 09:39

You can you can really focus on on all that it needs.

Joe Tannenbaum: 09:44

Yeah. It's these the the environments and the infrastructure is tuned for the Laravel application. So, it's ready to serve up and it's ready to scale, at whatever traffic is is is coming your way. So, yes, it's it's all very specific to Laravel, which is which is great.

Alexander Lichter: 10:02

Amazing. Yeah. I'm really looking forward how that goes, especially that's also the the first time there was funding Laravel because, of course, you can't build, like, a platform as a service. Just like I mean, you can start slowly in bootstrapping, but then there's also competition. So if you really wanna do it with a big bang, there is, funding involved.

Alexander Lichter: 10:19

So, I'm I'm really curious to see how that's going and, also see how that will maybe shake up the ground a little bit because I think especially in terms of that, let's say, that part of the DX, just like point repository and get up and going, in the JavaScript ecosystem, that works pretty well, but also because it's it's, like, it's a bit different from from the from the strategic point of view. Like, okay. Build your things, you put them up. It's Node. Js.

Alexander Lichter: 10:41

It's fine. So, yeah, curious to see that in the in the PHP world as well, especially with Laravel.

Joe Tannenbaum: 10:47

Yeah. I mean, building a a product as complex as cloud obviously requires scaling up the team. And I think they went from, like, 8 to I think we have 34 people now, you know, in a in a short amount of time. But it's you know, we're hiring additional engineers, infrastructure support. There's a lot of components and then as well as business people to help us run the business.

Joe Tannenbaum: 11:08

So, there's a lot of moving pieces as well as me. I mean, I, I was part of that hiring spree. I've only been there for a couple months, so, Yeah. You know, that's, that's what's required to build a product such as that.

Michael Thiessen: 11:20

Absolutely. Yeah. Sounds exciting. And it's, it's also exciting to be at a company that is growing and and doing things like that as opposed to just, like, slowly just chugging away doing the same thing or declining or, you know Totally. Even, like, amidst this, you know, climate of layoffs and stuff.

Michael Thiessen: 11:40

It's like, yeah, it's, it's great to see that there are companies doing really well in that way.

Joe Tannenbaum: 11:46

Yeah. I, the, it was always surprising to people, the output of the Laravel team, even when it was 8 to 10 people, because it was just constant. I mean, there was, there were new releases all the time. There were new packages being put out. It was, it was just an a constant flow of productivity.

Joe Tannenbaum: 12:01

And now that it's 30, 34 or whatever it is, it's, it's flying. I mean, we had a company retreat after Laracon and people gave presentations on the sort of stuff they were working on because we're all over the world. We're spread out. It's a completely remote company. So I have a I have a general idea of what's being worked on.

Joe Tannenbaum: 12:19

But I was listening to these people present, and I was like, these are everybody's at the top of their game. These are these are, like, these are very smart people just, like, cruising at a 100 miles an hour. And it's, it's, it's really it's inspiring, honestly. I'm I'm I feel grateful to be in the room with them. Sweet.

Alexander Lichter: 12:39

No. I I I really think, that, like, also the I mean, full remote makes totally sense in terms of, like, hiring top talents and, just, like, seeing and being as I said, being inspired by the flow of other people. I mean, me being on the Nuxt team, I also see that when, like, have team meetings and show, like, oh, look. That's the amazing part. Oh, here, we did that.

Alexander Lichter: 12:57

And you're always like, oh my god. Like, that's that's just so insane what's going on. Exactly. Yeah. That's that's the feeling.

Alexander Lichter: 13:03

And then you're also motivated, of course, to say, like, okay. Let's let's push this forward. Let's let's give you a pass. So, to to a certain degree, I can definitely relate. So it's it's really great to see that it also works in a, let's say, company and, product focused world, not, quote, unquote, only in open source.

Joe Tannenbaum: 13:19

Totally. Totally.

Michael Thiessen: 13:22

Before you had mentioned this term, TUI, can you I've never heard that before. I I have a guess as to what it means because I I see it in the the notes here. But can you explain what that is and why people know you for

Joe Tannenbaum: 13:39

that? Yeah. So TUI is a text based user interface. So you're making entire, user interfaces solely out of, like, characters out of text, and it's, primarily done in the terminal. And so the reason why people know me for that is because there there's this first class Laravel package called prompts that, the genius Jess Archer built.

Joe Tannenbaum: 14:02

She's amazing, and she built, this really beautiful set of components to build, user interfaces in the terminal. And they were reactive, and they were, you know, they would rerender in real time based on, like, validation and input and and whatever you're putting in. So it's it's really impressive in which you presented at Laracon, last year, 2 years ago. Blew people's minds. And so I was one of those people, and I said, this is incredible.

Joe Tannenbaum: 14:30

I started playing with it. And I went to I went to submit a PR to add something to it. And I realized, like, the rendering mechanism here is really fascinating, and we could probably blow this up and just make it full screen instead of these little components. And so I started just playing and I don't know my brain just got like very hooked on it and I just kept pushing it like as far as I could go and try to try to push it to the limits to see what the possibilities were. And I think the culmination is, like, at my at my Laracon US talk, I I did live video in the terminal.

Joe Tannenbaum: 15:04

So it was, like, pulling in video from my phone and live rendering it as, like, ASCII art in the terminal. And I was, like, okay, I think I'm I think I'm good here. I think I've done it all. I think I I don't I think I can back out at this point. So, yeah, that's that's the reason I just would share these little experiments on on Twitter and people, you know, I can I'm standing on the shoulders of giants.

Joe Tannenbaum: 15:24

Like, the rendering mechanism is really what's sort of the impressive underlying thing. I'm doing just a lot of, like, extremely tedious string manipulation and calculation and measuring. But, yeah, it's really you know, it's underlying. It's Jess Archer's work, which is really the impressive bit.

Michael Thiessen: 15:40

Perfect.

Alexander Lichter: 15:41

Yeah. Like, as we briefly discussed before before we hit the record button that, like, your your TUI story slowly, it it hit the peak, you said. Like, that's that's I mean, video in the terminal, it's as crazy as it gets probably, and as fun as it gets as well. So Yeah.

Joe Tannenbaum: 15:57

It was fun. It was a good time.

Alexander Lichter: 15:59

And and then you're you're slowly moving into probably other topics, at least in terms of talks and and the focus as well. And could one of them be inertia in the future?

Joe Tannenbaum: 16:10

Yeah. I've submitted a couple of inertia talks at a couple different places, so I'm hoping that we I get to talk about that, on a stage sometime soon. Well, we'll see.

Alexander Lichter: 16:19

Very nice. Yeah. And then let's let's start straight away with that because we we've heard Interim now, in in terms of the starter kits of Laravel. We heard it, together with, for example, LiveWire. So Mhmm.

Alexander Lichter: 16:32

Maybe let's start with what inertia itself actually is for everybody who never heard that term.

Joe Tannenbaum: 16:37

Sure. Inertia is actually a deceivingly simple package that was created by Jonathan Reinink, who's the co author of, Tailwind. He originally created it. And all inertia is is a thin layer between your Laravel app and your client side code. So if what you want on the client side is JavaScript, if you want Vue, if you want React, if you want Svelte, Inertia is a good little piece of glue.

Joe Tannenbaum: 17:05

It's basically at its core, almost a routing library. Right? So you set up traditional controllers in your Laravel app. And instead of returning a PHP template or what or a blade template as we call them, you just return a view component. And then once you return that initial component, after that, your app is a single page app that you can click around, and it's just sort of dipping back to Laravel to get some JSON coming back, rendering the next component, hydrated with the props.

Joe Tannenbaum: 17:34

So that's that's the sort of high level overview of what inertia is at its core.

Michael Thiessen: 17:40

So my understanding of this is that and and I have never used inertia before, but, so like with a typical, like, Laravel or, Ruby or Rails or something like that, every click will make a full page reload because you're going back to the server. You're going to render some new HTML that gets sent back to the client and then there you go. But with inertia, you're sort of like intercepting that in a way so that instead of returning HTML, it's returning this JSON thing, which inertia then takes instead of doing a full page refresh, it can just take that JSON bit and then pass that off to Vue, which then does the update. Is that is that correct understanding?

Joe Tannenbaum: 18:28

That's totally right. Yeah. So like you said, traditionally, you would return some sort of server side template, which would cause a full, page reload and you're spinning up the app all over again with every request. With inertia, there are these link components. And if you use the link component, that instead fires off an XHR request back to the server, which then returns an inertia response, which is a JSON response with a specific, object return, which indicates back to the client, this is the component we need.

Joe Tannenbaum: 19:00

These are the props you need to hydrate into that component, and then go ahead and render that without doing a full refresh. So that's that's at its core what inertia is. It sort of, Spotify's your app and allows you to write as, you know, as much Vue, React, or Svelte as you want, but we'll focus on Vue for the purposes of this podcast. Yeah. So if we sort of have this this dichotomy in in Laravel world where it's like, if you don't wanna write JavaScript, you should probably use Livewire.

Joe Tannenbaum: 19:29

You'll write very little JavaScript. It's it feels like a server rendered app, but you get a spa feeling. With inertia, write as much JavaScript as you want. It's very JavaScript forward. So once you're in Vue land, write all the Vue you want.

Joe Tannenbaum: 19:43

Do you know, use whatever packages you want. It's it's all it's all for you to to decide. But you can write the structure of the app as if it's a server rendered app, but get the spa results of that. So traditionally, you would have, like, a client side and then sort of, like, build out an API for the spa to talk to. So in this case, you don't have to do that.

Joe Tannenbaum: 20:02

We're gonna glue that together for you.

Alexander Lichter: 20:04

So it's basically replacing your manual work of defining the API endpoints that one should return and just does it for you, so to say, so that every time you do, like, an SPA like navigation, it will fetch the right things from a level application. And Correct. Okay. Good. And when you write the the routes, then you don't have to do that much extra, let's say.

Alexander Lichter: 20:25

Just to say, okay. Use inertia straight away, and that's the component you'd return. And other than that, inertia will figure everything out.

Joe Tannenbaum: 20:31

Yeah. It's really it's it's a weird concept for people that haven't, like you you have to, like, see it to understand it almost because you're, like, well, how does that well, I don't understand how that works. But it is it it is just sort of, like, a wonderful little magic. If you want to write a more traditional feeling server side app but have all the goodness that that a Vue has to offer, it's a really great way of straddling both of those worlds.

Alexander Lichter: 20:54

And that that also means that you can use all the power of Laravel that we mentioned all all earlier, and just write all the, let's say, interactive bits, or maybe the main part of your front end in Vue, and it will just be glued together.

Joe Tannenbaum: 21:09

Yeah. I think that's the main selling point in my eyes is that you get all of the goodness that comes bundled into Laravel, but then you get to write, you know, a proper front end in Vue the way that you probably want to write it. I love writing Vue. So Yeah. It's really it's really best of both worlds and your your back end has never been stronger than just, like, plugging Laravel into that equation.

Joe Tannenbaum: 21:31

Right? And I think if we wanna talk about, like, pros and cons, obviously, you're writing PHP on one side and JavaScript on the other side. So if code sharing is something you're interested in, you don't really get code sharing between the two sides as seamlessly as you might want to. You can do there are packages that convert your PHP objects to TypeScript, so you can get typing on your front end via the Vite build, which is great. So you can share types between the two sides, which is amazing.

Joe Tannenbaum: 22:01

But you if you wanna do actual co sharing, obviously, that's not something that you can do. But I think the power of the back end that you do receive, in my opinion, supersedes that little that little bit.

Alexander Lichter: 22:15

And especially if you can generate it with bit of codegen scripts, that's, that's that's a plus for sure. I wonder how that works with off. So if you have, like, your whole front end setup and you have, like, login button, then how like, are there specific, let's say, Inertia components set up for that? Or is it also does it magically work through that link component that you usually have?

Joe Tannenbaum: 22:36

So, there's a form helper in Inertia, and that has little, methods off of it, such as, like, post, get, put, patch, whatever you would expect off of a form. And that operates in the same exact way as the link component. So you would attach that to the form. It automatically, you know, binds the models to it and then sends that over to, Laravel correctly in the same way that the that the link component navigates as well. Does that make sense?

Alexander Lichter: 23:04

I would say so. Yes. It's more like, let's say, refreshing the auth state and everything. Is that everything will be handled automatically as well? Or is this Yeah.

Joe Tannenbaum: 23:13

In the same it's it's exactly so if you let's say that you auth somebody and you wanna redirect their dashboard, you can return a redirect and inertia understands, oh, I'm redirecting, and it will redirect you correctly within the client side of the app.

Alexander Lichter: 23:28

That's pretty cool. So really like everything that Laravel can do by default is modeled through inertia to make the front end understand it and handle that correctly.

Joe Tannenbaum: 23:37

Yep. It's really it's it's so straightforward. It's a little eerie.

Alexander Lichter: 23:44

It it sounds a bit too good to be true, but it is there. Right?

Joe Tannenbaum: 23:48

It's it's pretty great. It's my preferred way to write apps. And my stack is, you know, Laravel, Tailwind and Vue, connected with inertia. So it's the, the Vilt stack, I think is what it's called. I don't even know what it, you know, something like that.

Joe Tannenbaum: 24:01

But, Yeah. And then we also have adapters for, they're community, maintained, but there's adapters for rails and there's adapters for Phoenix as well. So you can just plug those in and have the same sort of functionality with inertia. Because the inertia piece of it is shockingly small. Like, I dove into it for the first time a couple of months ago because I had to work on inertia v 2 with Jonathan.

Joe Tannenbaum: 24:25

And I was surprised at how little actual code there was to actually make the all of this work. It's really just a little bit of glue between the 2 the two sides of the equation.

Michael Thiessen: 24:35

That's the best kind of tool where it's like the simplicity, not not even just in how it's used where it sort of just like just works and it feels like magic, but also when you when you realize that there's so little code that actually makes it work and it's just like it just feels so nice as opposed to, like, you know, some things are like, okay. We got this to work, but you look at the code and you're, like, okay.

Joe Tannenbaum: 25:02

Never touch it.

Michael Thiessen: 25:02

Yeah. That's some, real hacky stuff going on in there, but, you know, great.

Joe Tannenbaum: 25:08

Yeah. Yeah. And prior prior to version 2, the app operated sort of along the same way that a browser would operate. So if you let's say you clicked on a link, the request was still going out, and you clicked on another link, it would cancel that request and and just revert to the newer so in the same way that the browser would do that, it was modeled after that. In v 2, we rewrote the router, in a pretty significant way to handle async requests so that you could have things like polling and deferred.

Joe Tannenbaum: 25:41

So we have we have we have new polling mechanisms so that you can have async polling that doesn't get necessarily canceled as you navigate around the app if you need it. We also have something called deferred props, which is I don't need this upfront when you load this, so you can mark it on the server side. This is a deferred prop and it will not get evaluated in the first run. And then it'll immediately ask back for those props and hydrate them back in once the page is loaded. So that you can have those little, you know, if you have a data heavy dashboard, you can have some of those pulsing gray placeholders that we all love.

Alexander Lichter: 26:16

And Skeleton loaders and stuff.

Joe Tannenbaum: 26:17

Yeah, skeleton loaders. And then inertia will automatically ask for the props that would hydrate those and pull those in. So it really it's funny. We when we started talking about 2.0, the first thing was like, well, we should have some concept of async. We don't have that right now in here.

Joe Tannenbaum: 26:35

And it led to this thing where we went, well, if we have async, we could do this. And I go, well, if we do that, we could also do this. And, like, it just sort of kept building on itself when we have a bunch of, nice little quality of life improvements out of that.

Alexander Lichter: 26:49

Sweet. So, like, that means v 2 added, that the new concept of having async things around, like, you said, deferred props, for example. What else came new into into Inertia version 2 for all people maybe tried Inertia version 1 back in time? So, like, what's what's the news there?

Joe Tannenbaum: 27:05

So we also have, prefetching. So if you hover over a link or if you can also prefetch on mount, you can prefetch pages in the background and then get instant clicks into them once once you navigate around. So you can decide on a case by case basis what you want prefetched in. On top of that, because of this whole async thing that we added, we also have stale while we validate, caching so that you can say, okay. Well, I have a I have a version of this page, but it's a little stale.

Joe Tannenbaum: 27:33

But in the background, fetch a fresh one. And once it's here, rehydrate that down in. So they give the instant response, but you can show a little, like, refreshing in the side or however you wanna indicate that and get props back down as soon as you get fresh data. So that's another that was a big one that we that we worked on really hard. So a lot of the prefetching stuff is new.

Joe Tannenbaum: 27:53

Oh, we also have here's a big one and this was tough, but we we cracked it, I'm hoping, I think. We're well, I just wrote the rest of the test for you yesterday, so I think we're in a good place. And they're passing on it. And they're passing. I got a lot of green check marks.

Joe Tannenbaum: 28:07

Alexander Lichter: 28:07

Perfect.

Joe Tannenbaum: 28:08

So this is a weird thing. So let's say you're clicking around an app that is client side rendered, and you log out, and you press the back button.

Michael Thiessen: 28:19

Mhmm.

Joe Tannenbaum: 28:19

You don't wanna see things that you shouldn't see. Right? This is sort of a common problem. And this was a complaint in Inertia 1 a lot. So it's like, oh, I've logged out.

Joe Tannenbaum: 28:27

I press back. I can still see everything that I saw. So now we have this concept of clear history. Right? So we store pieces of data.

Joe Tannenbaum: 28:39

We store the props for the page in the window history state. Right? So I don't know if you're familiar with this whole, concept. This was a deep dive for me, a couple of months ago. So, we store we store page data in history state.

Joe Tannenbaum: 28:54

You can't actually delete past pieces of history state. You can only deal with the history state that you're actually looking at right now. So you can go backwards and forwards in it, but you can't, delete past pieces of history state. So we came up with this thing where we are encrypting history state. And then when you decide to clear history, we just rotate the key so that it can't be decrypted anymore.

Joe Tannenbaum: 29:17

And if we get an encryption miss, we fetch it fresh from the server and the server decides, well, are they off? Do they have permission to see this anymore? So you you get that fresh information from the server that determines at the source what the user should actually see based on the current state. So that was our solution and it took 5 different iterations to finally get there and figure out what that looked like. But Jonathan is a very smart fella and he was like, what if we encrypted the state?

Joe Tannenbaum: 29:45

And I was like, my guy. He figured it out. So, yeah, that was a that was a cool thing.

Alexander Lichter: 29:51

You encrypted also based on the city JWT token, of the user then that, like, only the user can actually decrypt it again? Or is it, like, based on what is it encrypted?

Joe Tannenbaum: 30:01

So we're using the, window dot cryptosuttle. What whatever that I I can't remember off the top of my head. It's the crypto built into the browser that we're using. And what we do is we store the key for that in the Windows session storage. So whatever the rules of the Windows session storage are, so once that gets cleared, if they close out the browser, that history is now gone.

Joe Tannenbaum: 30:24

Like, if they they will not be able to decrypt the history. And all we do on a clear history, you can say from the back end or from the client side, clear history, and it just deletes the key from the Windows session storage and generates a new key. So that it travels with the session, that the user is currently experiencing and therefore, follows the same rules and deletes itself once that session is gone. Does that make sense? I don't know if I explained that well.

Alexander Lichter: 30:50

No. I think that that totally makes sense, especially because you are in some degree with, like, cookies and everything and, like, say, the more server side paradigm. It's also yeah. Totally makes sense to attach to your session storage. That's, that's good. Yeah.

Michael Thiessen: 31:04

Sounds like a good way to, to solve that problem. And I've definitely experienced that before in, things that I've built where, yeah, you log out and you go back and you're like, wait, I'm logged out. Shouldn't I not be able to see this? How do I fix this? And then it's usually like like something with the auth library or something you can't really do in user land in the same way.

Joe Tannenbaum: 31:27

Yeah. We we clicked through a lot of popular apps to see how other people were handling this, and it's typically not really handled, to be honest. Like, it happens very regularly. I think it was GitHub. If you click through, they're they're, like, storing all this stuff in memory.

Joe Tannenbaum: 31:47

So as soon as you refresh the page, it's gonna fetch it fresh. But if you don't refresh the page, I think there it doesn't I don't know if it kills it. There are a lot of strategies to doing this, and we tried storing it we tried storing the data in clearable places, but the browser storage limits are so low. We plopped our one of our solutions into a real app that was operational to see, like, how it would operate and work. And we hit the storage limit in, like, 2 seconds.

Joe Tannenbaum: 32:12

And we're like, oh, okay. Well, it's just, like, ejecting stuff now. So I guess 10 megabytes probably wasn't enough. Like, so Nope. The the window history state has a monster amount of storage.

Joe Tannenbaum: 32:22

So we just we just put it there and it ends up working. So yeah. Fingers crossed. I think I think we found the thing that's gonna ultimately work till some security expert comes along and slaps our wrists and tells us we're wrong. I don't know.

Joe Tannenbaum: 32:35

We'll see.

Alexander Lichter: 32:36

Well, that's that's the chance for everybody listening and there's a security expert to dive into it.

Joe Tannenbaum: 32:41

No. No. No.

Alexander Lichter: 32:43

Security at Laravel?

Alexander Lichter: 32:44

No. But but, guys, if you do, then always do responsible disclosure. Very important to mention that. So so that's good.

Alexander Lichter: 32:53

Is there are there any other breaking changes coming to Inertia v 2?

Alexander Lichter: 32:56

Because, I mean, if you do a v 2, it's probably all only shiny features, but also, I guess, some breaking changes.

Joe Tannenbaum: 33:01

There's not a ton of breaking changes actually. We really tried to make the migration path very smooth. I think one of the bigger breaking changes is we're dropping v 2 finally, so we're not supporting v 2 anymore. And I think that's reasonable. It's been end of life for I think you would know better than I would.

Joe Tannenbaum: 33:17

I think 10 months. 10 months?

Alexander Lichter: 33:19

Yeah. Like, I mean, Vue's 3 has been out for for quite a while, but, like, AOL was end of last year and yeah. I think it's it's a good point to say, hey. If you want to, you can use Inertia 1 with it. So,

Joe Tannenbaum: 33:30

people It's still included Inertia 1. Yep. Yep. So we decided to to slim it down and have Inertia 2.

Alexander Lichter: 33:36

That makes sense. Also, like, giving a slight nudge to for people to, hey. You can upgrade.

Joe Tannenbaum: 33:40

Yeah. Yeah.

Alexander Lichter: 33:41

And but you still support the options API in Vue 3, I guess, with inertia? So that that doesn't matter which API you write, I guess?

Joe Tannenbaum: 33:48

Yeah. Both are supported, so it doesn't matter. You can you can easily write out the options or the composition, and it'll it'll work either way. Yep.

Alexander Lichter: 33:56

Sweet. But on that note, what do you prefer? Which of the 2 APIs? Personal question.

Joe Tannenbaum: 34:00

I feel like this is the this I like the composition API personally. I'm I'm a big fan. It I will say that in the beginning, I had to, like, force myself to do it a lot in order to, like, understand it and, like, rock it in a way that that made sense to me and it made it feel better. But once it one day it just clicked and I was like, oh, this is the way. I don't see any other way.

Joe Tannenbaum: 34:21

This is so much better.

Michael Thiessen: 34:22

Yeah. That sounds pretty, pretty typical of like getting over that initial hurdle. But then once you do, you're like, yeah, This how how can I ever go back?

Joe Tannenbaum: 34:32

Yeah. I agree.

Alexander Lichter: 34:33

If it Clicks it clicks.

Joe Tannenbaum: 34:34

Are are you not on the, are you not on the composition API side of the equation?

Alexander Lichter: 34:39

No. I I'm I totally am. I'm a big proponent of the composition API. And, like, there there are, like, tons of discussions that I I, like I I I I think both Michael and I, we created tons of content around that, like options API versus composition API. We had Avenue on the podcast talking about that.

Alexander Lichter: 34:55

We had other people from the Vue core team also on on that, tons of, like, Twitter and Reddit discussions. So, yeah, I think the the 3 of us are in the on the same line there, but there are still people and I also understand that to some of you, so, like, options API is a way because, let's say, big team, not everybody is, like, a front end expert. Some back end just have to write front end code and so on. It's like, okay. Review is easy.

Alexander Lichter: 35:15

Everything looks kinda the same. I don't have to think about abstractions, and also guidance and structure. So I understand even though I wouldn't touch the Options API nowadays anymore if I don't have to.

Joe Tannenbaum: 35:27

Yeah. I just think it it feels a little less magic and a little more like you're just writing JavaScript and it's working as intended. And I think that's, that's what finally made it click was that the magic layer is a little bit removed and you can just see like, oh, it's defined up here and I'm doing this and now it's showing up in my template. And it's, it's just a lot more like a to b and a lot less like a to b to c to d, you know. Yes.

Joe Tannenbaum: 35:50

True.

Alexander Lichter: 35:50

And with the script setup syntax, which is also the only way anyone should write a composition API, it's my own hot take.

Joe Tannenbaum: 35:57

Thank you.

Alexander Lichter: 35:58

Like actually, it's it's not even a it's not even a hot take, Evan You as well, so that's so, like, they made a mistake, quote, unquote, that's, like, what hurt Vue three the most was really releasing the composition API without script setup because just with the setup function, sure, for migration, okay, exception made, fine. But, like, without that, that macro is just so lengthy. It's so difficult to read. And without it, it's clean. It's wonderful.

Alexander Lichter: 36:22

It's what we expect from you.

Joe Tannenbaum: 36:24

It's also the it's the recommended path. Right? It's what they yeah. Okay. Yeah.

Joe Tannenbaum: 36:27

100%.

Michael Thiessen: 36:28

And what was it like it wasn't a long time before they did release it. Like the it was like maybe 6 months or something. Yeah. It was like just remembering, but

Alexander Lichter: 36:36

1 1, 2 minor versions. It didn't take long. That's correct.

Michael Thiessen: 36:39

Yeah. But like by then, everyone was like, had already formed opinions on the composition API, and written articles about

Alexander Lichter: 36:47

Yes.

Michael Thiessen: 36:47

About it, and a bit of drama and stuff. And then yeah. It would have been who knows what would have happened if it was, if that was sidestepped. That's true.

Alexander Lichter: 36:57

But on the other hand, I mean, that's also part of it in a way. It's like, okay. You you experiment. The new API is the way to go. And if there is a way to make it even more elegant and more clean with the help of the compiler, I'm all for it, and it's nice that we have that that standard now.

Alexander Lichter: 37:10

Like, lots of things emerge that way. So, but I agree. It probably wouldn't have hurt the adoption that much and more people would use the Unio, but we never know. You never know. So coming coming back to your Inertia real quick from from the the the typical question.

Alexander Lichter: 37:27

We should maybe ask everybody coming on anyway, so I remember when I used Laravel and Vue a lot, I always had that that feeling of, like, okay, you drop in Vue and you build your whole front end in Vue, and it was before Inertia was around. I think it was, like, experimental or whatnot. I can't fully remember to be fair. I always had a feeling like that if you use Vue and then the Vue router because, like, okay, you wanna check I don't know. What was the model open?

Alexander Lichter: 37:50

Does that? You have the conflict of, like, which part of the application really does the routing. Is it Laravel now? Because, okay, you don't wanna use it fully as an API necessarily versus, oh, yeah, there are some routes in Vue, but you need an equivalent in Laravel because if you want to refresh the page, then things shouldn't break. Is my assumption correct that this is also fixed for Inertia just because it's like one mental model, so to say?

Joe Tannenbaum: 38:13

Yeah. The the Laravel is your routing layer. Like, you you route in Laravel. You don't do any routes in at on the client side at all. Inertia handles the negotiation between the 2 the 2 things for you.

Joe Tannenbaum: 38:26

So you the decision making process becomes a lot more simple in the Inertia model of things. Like, it's it's very clear, like, what belongs in the server and what belongs on the client. And the client just ends up being the view layer as it should be. So, like, your interactivity belongs there. And, even your validation gets still gets easily routed through the server.

Joe Tannenbaum: 38:48

So if you're doing form validation, you know, there's the form helper comes bundled in with, like, hey, does this field have errors? Because I know about it because I know how Laravel returns errors to me. So you can just say, you know, form dot errors dot name. And if it exists, you know, the field has an error and, like, the the server's already validated it. And even Tim McDonald, who's on the team, wrote a package called precognition that does live inertia validation as you type.

Joe Tannenbaum: 39:18

So that, like, it it sort of does that that negotiation as you're typing with special headers, and it runs only the validation piece of your controller of the form input and returns so you can get validation in real time. So that's I don't know how popular that one is to use, but it's a really it's a really cool piece of tech that he that he whipped up. Yeah. I think the good thing about inertia is like that decision making process does become a lot clearer. It's very clear, like this is, you know, let's lean on server where server shines and let's lean on client where client shines and you don't have to figure out like, okay, are are my routes in the client?

Joe Tannenbaum: 39:54

They're not. They're not in the client anymore. They're just server. Yep. I think

Alexander Lichter: 39:58

the the formalization part is also a good one because I was I was thinking about translations, for example, that you also, like, have them in Laravel and the if if Inertia has a way to also fetch them from from the server side. And same with validation of, like, okay. Can I just say, hey? That's my form. That's roughly what I expect.

Alexander Lichter: 40:14

Math like, mix and match, so to say. And you also answered that one already. But yeah. With regards to translation, it would be interesting too if that's possible.

Joe Tannenbaum: 40:21

You know, that's a good question. I haven't done a lot of localization with inertia apps, but I know people who have. And I know, you know, that's something probably you'd have to lean on, like, a community package for. I don't think we don't really have, like, a first party answer to that yet. Mhmm.

Joe Tannenbaum: 40:38

But, yeah, I know there are ways to inject the localization because there's a huge localization mechanism within Laravel itself that allows you to easily localize strings. And so I I believe there's, like, a view translation layer that allows you to inject that in, but I don't I don't know off the top of my head, to be honest.

Alexander Lichter: 40:55

That is totally fine. But, I mean, as you said, there are so many community packages out there. Probably, there is at least one that's, covering that, which is also amazing to see in the in the Laravel ecosystem. I feel like in Vue, it's pretty similar. Like, we have so many things now around, so it's it's also great to see that.

Joe Tannenbaum: 41:12

Totally. Totally.

Alexander Lichter: 41:14

And maybe there there's one more, at least for me, elephant in the room, which is Is that a PHP joke? Are you making a PHP joke right now? Nice.

Alexander Lichter: 41:24

Yeah. Well caught. Well caught. It's not PHP. It's another few letter acronyms.

Alexander Lichter: 41:29

It's SSR. So Oh, yes. As as as someone being on the Nuxt team, I was wondering, can you do server side rendering with inertia as well to render your whole application on the server side through well, I'm curious how that will work, if that's possible.

Joe Tannenbaum: 41:45

Yes. So we do we do have an SSR story. And so, how that works is that, inertia runs a a command in the background that spins up a node process and feeds it through that. So if you're, say, setting up, you know, inertia on Forge, Forge has, like, a little I believe they have a checkbox that just says like inertia SSR. Like, it'll detect if you're inertia and you have SSR enabled and you can just, add the daemon daemon daemon?

Joe Tannenbaum: 42:15

I'm now realizing

Alexander Lichter: 42:16

Daemon, but I'm not sure. Yeah.

Joe Tannenbaum: 42:17

Add the daemon, actually. It'll add the daemon so that it'll run that node process continually in the background for SSR requests. So that is sorted. We do have that. I'm sure it's not as clean as, like, if you were writing JavaScript on both sides, it's probably a cleaner a cleaner story there, but we do we do support that.

Joe Tannenbaum: 42:36

Yes.

Alexander Lichter: 42:37

Interesting. So but that means you don't spin up a new process every time. It's just like have a continuous daemon running and then just like, oh, there's a new SR request.

Joe Tannenbaum: 42:44

Yeah. And it feeds it in. It knows, where to point that request to in order to get the SSR back.

Alexander Lichter: 42:49

And is it also scaled for, like, I don't know, supervision whatsoever to, like, if if there are, let's say, 100 requests a second, if you're super popular because, I don't know, tata auto tweeted it.

Joe Tannenbaum: 43:03

To scale up the daemons, you mean?

Alexander Lichter: 43:04

Yeah. Like, just because I know Node. Js is not the best when it comes to string concatenation, which is SSR mainly about.

Joe Tannenbaum: 43:09

So Yeah. Yeah. Yeah. Yeah. Yeah.

Joe Tannenbaum: 43:12

You can you can do a supervisor config to to scale that up and down as necessary for sure. Yep. Wonderful.

Alexander Lichter: 43:18

But it that's not done automatically, I guess. Do you have to, like, do a little bit of DevOps work there?

Joe Tannenbaum: 43:23

In the Forge dashboard, you can specify, the you can just kind of plug in numbers, if you, if you don't want to dive into the config file specifically and it'll, it'll, scale that as necessary via the the daemon config.

Alexander Lichter: 43:38

Yeah. Makes sense. Very interesting. But then good to know that this works. And you said there are also community like, there are also other frameworks support like React or Svelte.

Alexander Lichter: 43:47

Do they also have SSR support just to

Joe Tannenbaum: 43:49

Yes. Okay.

Alexander Lichter: 43:50

And same for the community adapters for, let's say, Phoenix, like the Elixir or Web Framework or or Rails?

Joe Tannenbaum: 43:56

That's a good question. I I don't work on those adapters, but I assume that they probably do. I would be surprised if they don't have those. Okay. Our ours is just wrapped up in a little I think it's PHP artisan inertiacolon SSR or something like that.

Joe Tannenbaum: 44:11

So it's it's kinda wrapped in, like, a really clean little command that you can run that will spin up the correct process that will and they'll talk to each other. I assume that that the other adapters have that. I don't know off the top of my head.

Alexander Lichter: 44:22

Really interesting. Yeah. But then that's great to hear because around, like, SSR is always a a big topic, especially with public facing sites. So good to hear that this works too even though it's like I remember there was like a PHP v eight project wants to run the v eight engine in PHP and all that and, of course Yeah. Yeah.

Alexander Lichter: 44:38

I don't think it's a thing anymore. But People

Joe Tannenbaum: 44:40

people get wacky, but, yeah, it's it's Yeah. It's like

Alexander Lichter: 44:44

when when I try to use, like, when I wanted to use Laravel and Vue and SSR together, that was like the way it's like, hey, maybe one day this could work, but, yeah, spinning up Node.js processes, I think the better way to go there.

Joe Tannenbaum: 44:56

Yeah. Yeah. Let let Node would Node do what Node is supposed to do, you know? Yeah. Well, one day, maybe even have something faster than Node for for server-side rendering. I mean, we have a bun and stuff or like, Deno, but yeah. One one day.

Alexander Lichter: 45:09

I was thinking maybe the last topic, the whole data fetching part. You so you said, like Mhmm. Okay. If you navigate around, it's not a problem. Inertia will do everything.

Alexander Lichter: 45:17

If you fetch data to say, like, hey. I want specific data from a third party API or from maybe my Laravel page, you you do it differently than just saying, I don't know, I use Fetch or Axios or whatever?

Joe Tannenbaum: 45:30

Yeah. So it depends. That's where a little bit of decision making has to come in. So if if what you want is to affect the current inertia page or component, then you should do that the official you can you can do programmatic fetching. You can say, you know, router.getorrouter.post to programmatically fetch, and then it will treat it as an inertia response and update the component.

Joe Tannenbaum: 45:54

If you are doing something outside, if you're doing a 3rd party, you know, go going off-site or something like that, you would have to reach for either Fetch or Axios and just do that manually. You know, we're not, inertia is not really in the business of becoming, like, an Axios wrapper in that way. Like, we wanna keep it confined to, being a negotiation between the Inertia app and the server. So if you wanna go off the beaten track and go fetch data arbitrarily somewhere else, you would just grab either fetch Axios, whatever whatever flavor you wanna grab and and do that manually. Yeah.

Alexander Lichter: 46:29

So it's the components responsibility then as well. Yeah. Makes sense. Yeah. Yeah. Got it. We we provide everything that you would need to to fetch inertia responses and update the components properly in, like, a thin little, you know, router methods. But everything else, yeah, you would you would you would do that on your own.

Alexander Lichter: 46:48

And, are there, like, when when it comes we talked a lot about pros. We talked a lot about amazing things inertia can do. Is it like any any cons, any drawbacks where you think, hey. Maybe you shouldn't inertia when you wanna do this.

Alexander Lichter: 47:01

Or in these cases, inertia might not be a good tool or can't do this and that. Anything comes to your mind from the top of your head.

Joe Tannenbaum: 47:08

I would venture to say that perhaps, like, optimistic updates are maybe not where inertia shines because you don't you're not sharing a language between the two sides, and I think that gets a little sticky. And I would love to have a better story there and understand that better and try to try to bridge that gap a little better. But it's I think it's easier when your server and your your, front end are are speaking the same language to share that code and share the logic accordingly. Yeah. I think that's to me, that's top of mind in terms of something that I wish we had a better answer for at the moment.

Michael Thiessen: 47:45

When you're writing an inertia app or I guess a a Vue, Laravel, inertia app, the Vilt stack, how much of your time do you actually spend thinking about inertia stuff? Because it sounds like for the most part, you're just like back and forth between the Laravel side and the Vue side, and inertia is sort of like yeah. You have to think about it when you're putting in the link component and, you know, dealing with form stuff and, like, you know, a few edge cases and stuff like that. But, like, how how much of that time is spent on inertia, or does it just sort of, like, fade away a little bit?

Joe Tannenbaum: 48:25

In my opinion, inertia is an implementation detail. It's not really something top of mind when you are actually building out the app because when you're in view, you're in view and you just do that. I think you're pulling certain things in from inertia if you choose to. You're pulling in a form helper, you're pulling in the router if you need to, but you don't really think about it that much. You're not you're not saying like, how does inertia do this?

Joe Tannenbaum: 48:52

Like, it's not really that. You're just thinking about the component that you're in because you get to be a little siloed about it when you build in this sort of, like, inertia mechanism. So when when you're on the server, you're on the server. When you're on Vue or the client side, you can just think about the component that you're in and just sort of focus on that alone. So I'm I don't spend a lot of time going, what's up with inertia here?

Joe Tannenbaum: 49:16

How does inertia work here? You know, it's sort of outside of the link component and the form helpers. There's not like a ton I'm reaching for outside of that, and that that gets you, you know, 90% of the way.

Michael Thiessen: 49:26

That sounds, pretty nice that it can do all that and just be like yeah. Like, it almost sounds too good to be true. I'll have to check it out sometime and and play around with that.

Joe Tannenbaum: 49:37

Yeah. Especially if you're you said you can't I think you said you come from a rails background or you've or you've done a little bit of rails in the past?

Michael Thiessen: 49:43

Yeah. Rails with with Vue on the front end, but, like, rendered into the, the Vue there.

Joe Tannenbaum: 49:52

Right. I would love to hear what you think about the the experience, because I think I think you're gonna be a little blown away. Because if that's the experience that you previously had, I think you're gonna feel a lot better about this, this mechanism of of rendering our apps.

Michael Thiessen: 50:07

Well, it sounds like it. So if I yeah.

Michael Thiessen: 50:09

If I get a chance to, I've never I've never done Laravel or PHP stuff either. So, I mean, I keep hearing more and more about it, and people keep hyping it. And so, you know, there's that's part

Joe Tannenbaum: 50:23

the part in the back

Michael Thiessen: 50:24

of my mind that's like, okay, I gotta try something, you know. So if I have if I have time I mean, this is the problem with this podcast is we have every week we talk with awesome people about different things, and they're like, hey, check out this cool thing. And I'm like, oh, I should do, I should do something with that. And then the next week is, oh, I should maybe build my own like rich text editor editor with like all these features. Oh, that'd be cool.

Michael Thiessen: 50:49

And then Yeah. You know, and yeah, I don't have that much time, you know?

Joe Tannenbaum: 50:54

The the list is a 100 items long at this point and it just now this is a 101st on the list. Yeah.

Alexander Lichter: 51:00

Yeah. And it might go up a few places though. Yeah.

Michael Thiessen: 51:04

Yeah. Yeah. Exactly.

Joe Tannenbaum: 51:04

I think it might be useful. I I saw somebody tweet about this the other day where they have an app and it's where they just try out new tech or they rebuild with new tech. So like they have an established app, like something a little more complex than say a to do list, you know, app. And, oh, I should try out this tech. Let me just re I know what the use case is here.

Joe Tannenbaum: 51:24

I know how this fundamentally works. Let's just rebuild it with the new tech and see how it feels. And I think that's kind of a smart way to do it. And eventually, you get tired of building that app and you pick a new app that's like a little starter app. So just to be able to, like, hit the ground running in a domain that you're very familiar with and that you've built a couple times with new tech, I think, would give you a good perspective on that.

Joe Tannenbaum: 51:44

It's I think I'm thinking about doing that.

Michael Thiessen: 51:46

That's a great idea because then and like, especially, like, if you're going from Nuxt to Laravel, then you probably have to rewrite the majority of it. But then

Joe Tannenbaum: 51:56

Yeah.

Michael Thiessen: 51:56

If you're trying out just like, oh, I've got Laravel now, let me try it with Inertia. Let me try it with LiveWire and see how that feels. Then it's like, like a lot of it can stay the same and you can just like swap out different things and, and Totally. That that would be neat.

Joe Tannenbaum: 52:12

Yeah. Food for thought.

Michael Thiessen: 52:14

I'll add to my

Alexander Lichter: 52:15

list. Perfect. 102.

Alexander Lichter: 52:20

On on that note, I remember it was, like, I don't know, beginning of the year or something, that there was, a big tweet from from Taylor Otwell, the creator of Laravel about LiveFire version versus Inertia. And I think he also mentioned the way that, like, Inertia is kind of, let's say, it's done.

Alexander Lichter: 52:37

We had also Evan You here saying, like, oh, yeah. I don't know. A project is it can be it can be finished piece of something, like feature frozen. And in in what way now that inertia v 2 is there? In what way does it also apply to to inertia as in, like, hey.

Alexander Lichter: 52:51

Don't expect any crazy features here anymore. Is it is it done? And and way like feature complete? That's a good question.

Joe Tannenbaum: 53:00

Jonathan's intention is to keep inertia scope pretty tight. It does a one job and it does it really well. And I am very on board with that vision. I think that's very smart. I think it's easy to get, you know, let these things blow out of control and sort of become a different beast than the original intent was.

Joe Tannenbaum: 53:17

And so we were considered a a complete software. Like, there wasn't you know, outside of bug fixes, there wasn't really a lot that needed adding. I think this new async layer opened up some possibilities that maybe, leveled it up a little bit. And but I I would say, like, don't expect, like, big wild things coming out of inertia. Like, it really is a very small piece of glue between 2 different pieces of your application.

Joe Tannenbaum: 53:48

And so we're happy to enable things that keep it up to date with, you know, the standards of web development and what you would expect an app to do in 2024. But I don't think it you know, I don't know how mind blowing the thing is coming out of inertia itself would be. I think it just allows you to use the new mind blowing stuff coming out of Laravel and the new mind blowing stuff out of Vue, as easily as possible. I think it's it's a much smaller piece of the puzzle than I think people might realize, where it's really just connecting 2 excellent other things together.

Alexander Lichter: 54:23

Perfect. I I think that's a a pretty amazing, end statement for for the episode. Like, we we we can't we we don't even have to say anything else there. That's that's lovely, except there's one more question, of course. So, Joe, where can people follow you?

Alexander Lichter: 54:39

Anything you wanna plug? Anything you wanna mention?

Joe Tannenbaum: 54:42

I it's just no plugs, but you can follow me on Twitter, at Joe Tannenbaum. And everywhere else, I'm at Joe Tannenbaum. So if you wanna follow me anywhere else, that's also good to go. And, I really appreciate you guys having me on. Thank you so much.

Alexander Lichter: 54:56

Of course. You're welcome. Thanks, thanks for joining. All the talks you mentioned, all the links, everything will be in the show notes in the description, all your handles as well. Mhmm.

Alexander Lichter: 55:06

So so thanks thanks a lot for coming on, telling us a bit more about Laravel Inertia, and, everything around it. And, I hope to talk to you very soon, maybe for Inertia, v 3 5, 10 years. Who knows? It might take a little while for that. In a decade, I'll be back on.

Joe Tannenbaum: 55:23

I'm happy to be happy to go back on.

Alexander Lichter: 55:25

Exactly. Or other topics

Joe Tannenbaum: 55:26

early. We'll see.

Michael Thiessen: 55:27

Maybe Thank

Joe Tannenbaum: 55:27

you so much.

Michael Thiessen: 55:27

Maybe you can come up to VueConf Toronto in November of the year.

Joe Tannenbaum: 55:31

Yeah. When's that happening?

Michael Thiessen: 55:32

November 18th to 20th?

Alexander Lichter: 55:35

Yeah. We'll be both there. Okay.

Michael Thiessen: 55:37

Yeah. We're both there.

Alexander Lichter: 55:37

Yeah. We'll actually There. That'd be fun. Be sick. Yeah.

Michael Thiessen: 55:40

And, to our listeners, if you want a discount of 15% DEJAVUE. It's a code. It'll get you that.

Alexander Lichter: 55:49

Also link for that code in the description. Yeah. Perfect. Yeah. It's not too

Michael Thiessen: 55:54

far away for you. It's a No.

Joe Tannenbaum: 55:56

It's it's totally easy. That's easy.

Michael Thiessen: 55:58

Flight or a medium length drive?

Joe Tannenbaum: 56:01

Yeah. Like, you drive, but, you know, doable. Yeah. Yeah.

Alexander Lichter: 56:04

Absolutely. That that would be that would be really sick. So and, of course, if anyone listening will come there too, we're looking forward to talk to you, have a little chat, discuss about option versus composition API and which amazing back end framework you use. So we'll definitely psych for that. Of course, don't forget to watch if that's the latest episode than the older ones.

Alexander Lichter: 56:23

Right? We have lots of other cool episodes as well. And if that's not the newest one, then what are you doing here? You have to catch up faster, faster. So stay tuned for that, and talk to you soon, folks.

Alexander Lichter: 56:32

Thank you. Bye bye.