#107: Building Michael’s First Ruby Application

Better other other host, Aaron. Hey, Don Michael,

It’s I mean, all right. I’ll get the ruler out then. I guess.

Yeah. Yeah. We’re gonna do some some railing. We’re gonna we’re gonna do some

I, that should be enough time. So a couple things that we did beforehand that we’re going to take as a given. Although if you’ve ever done rails before, you know that this isn’t a small thing. The setup is always a pain in the ass. So Michael has already loaded a VirtualBox instance of Ubuntu. And he has installed Postgres as a database. He’s installed a Ruby binary through the RVM tool.

That’s the one that I like other people like RBN, or ASDF, or some other ones. RVM is Ruby versioning. Manager, it’s similar to nvm. If you do node, it’s just a way to have an easy way to have Ruby binaries, and have the be different kinds of Ruby binaries on your system. So those things are already all done. And so we can just start with just doing the real stuff itself.

I have a Diet Coke from McDonald’s with Kraken and cinnamon fireball in it.

Yeah, I think that we’ll probably put the code up on GitHub too, I would assume yes,

Awesome. So the first thing we’re going to do is we have to create the Rails app. And you’re going to do that by using the rails command. We’re gonna use that command a bunch, it has a bunch of different options and switches and stuff. I already gave you the full command in our Discord. Right?

So I had to write out this command because the rails new command uses a lot of command line flags. And there’s a specific configuration that I like. I like to skip any test because I prefer our spec. And we’re going to skip boot snap. Because I find bootstrap to be a pain in the ass. I don’t want to get into it. And then we’re going to tell it to use Postgres as the databases that have SQL Lite. So, yep, you’ve named the app, dux-ruby, and

Oh, it’s a Hello World, right. That’s what we’re doing.

of a grid, you sit in a box? And then if you hit a button, someone throws a cheerio in for you?

Congrats, Kansas,

So some one thing wrong. Something I really like about this is that a lot of times when people are learning a new language, they have the experience of like, okay, I know a couple things. Now, what do I do? And I like this kind of app, because it’s very, like small and contained, but still has enough complexity that you can sort of play around. And, you know, explore the things you’ve just learned.

Yeah, yeah. And actually, a CRUD is something that rails like, is exceeds that, like, if you’re doing a CRUD app. Rails is is a great, like possible solution for you. Like, there’s certain things that Rails is good at certain things, it’s not good at a lot of stuff that like react really shines out like heavy, single page UI interactivity stuff.

Rails is like so so like, I wouldn’t build like a Google Maps kind of clone in Rails? Probably. Probably not. But something like, like, oh, like what to do items I have to do, or like a blogging service, or whatever, like Rails is great at that kind of stuff. So you got the rails new command, go ahead and hit enter. And hit enter. And stuff. Yeah, so

what it’s doing right now is it’s running through a forest script. Thor is a Ruby like sub language thing for scripting. And oh, so

Yeah, our first snag. So the first thing you need the postgres development package, this is a Ubuntu thing. I’m getting you the URL right now. So it’s sudo apt install PostgreSQL which you already have PostgreSQL dash drag, which I think I saw you install and then lib PQ dash Dev is the one you’re missing. That’s the like development library stuff for it, which it needs because when it’s installing a gem, it needs to have access and right

just to LS real quick. I think it created it already.

Oh, yeah, go ahead and rm rf it just just kill it and start over again. I want to, I think the the script might do some other stuff after it installs the gems. We might hit one more snag with one of the dependencies for the JavaScript file. Very cool. So, um, so Ruby gems are like libraries similar to like Node packages or whatever. And what it’s doing right now it’s running through a script, it’s creating a bunch of seed files for you for the app.

And it’s installing the any gems that you need by default. And it looks like it’s done. Go ahead and type bin slash rails space S. There you go. Okay, and then go back to a browser, and go to localhost colon 3000. No database error. Oh.

Okay, so do so it’s giving you an error page. Right now, Russell’s error pages are actually pretty good overall, they show you like a useful error message. And then it shows you the relevant part of the code that’s airing an issue a stack trace. So it’s telling you to run bin slash rails DB create. So go ahead and copy that out, and then run it. Copy that out and run it.

So the development database is the one we’re going to use locally for like development and like manual testing. And then the test database is what’s going to be used by the automated test suite. Rail, we’re not going to do a whole lot of test writing, because it’s time consuming, and we only have an hour. But we will write a couple tests.

Yep, your hello world. So cross that one off the list. Okay. That’s cool that it’s different. It used to look different than that.

Yeah, so the the mantra in Rails is convention over configuration. And what I always tell people new to Rails is always do things the rails way, like go with the least resistance possible, until you’re comfortable. And sometimes you have to go off the rails, sometimes you have to do things a little bit differently.

And you do have to configure stuff. That’s okay. But you should know when it’s correct to do that. And you should know what the impact will be when you do that. Um, do you want to run through the directories really quick, and I can walk you through the app.

the app directory is what’s going to store the bulk of your business logic. And like, basically, this is like the core of the app with a couple exceptions, but like the bulk of your app is going to be here. Assets is stuff like your JavaScript and style sheets. And I guess, your images, anything that gets like, compiled up and like served.

Like that’s kind of supplementing the app channels, we’re not going to worry about that’s for action cable, we’re not doing that tonight. Controllers is. So you mentioned models, views and controllers, that’s the MVC pattern. Rails is like 100% built off of that, like paradigm. So controllers is what sits in between the user and the database. Helpers is like, try to describe them.

If you if you want to write like little methods and things that will help out your Ruby code, like, maybe you’re just constantly writing the same method for calculating sales tax or something, you throw a helper in there to do that for you. And that’s where they that code live. JavaScript is if you were doing regular like, like Webpack style stuff, it would go in that folder. Jobs is for background jobs.

Like if you wanted to have something run with like sidekick, or Redis. Or you would do it in there, like sending mails or whatever mailers is, where you are sending emails out. models is like where your domain concepts live. So if you have like a user, you’d have a user model, it’s like your user class will live in there. And that like the the thing about Rails is that any of the things in models, map, excuse me, maps directly to a database table.

And then views is stuff that it’s the HTML that’s going to render you can think of us as like templates. So that’s the app folder. The other ones are bin which is going to store like binaries like commands such as rails or a bundle, which For your migraine management, config is like general application config, there’s a lot of stuff in here, we may have to visit that later.

Um, the DB folder has the seeds file that you’re looking at, which is like you can put in for development, especially this is really handy, you can say, This script will create all of the objects, you need to just start manually testing. Yeah. So frequently, what people will do is they’ll put a couple like generic user accounts in there, maybe like a couple sample items, so that all you have to do is run the seed script.

And then you can start the rails server and then just start testing. It’s also where the migrations will be stored. And we’ll come back to what that means later. lib is like, there’s different schools of thought and what goes in lib. Generally, that’s where you’re going to put stuff that is like kind of meta code. Like it’s, you’re writing some Ruby scripts that are meant to work with the app itself, but not like the user facing part of the app.

It’s like the the, it’s like the DevOps of the rails scat real stack. The log folder holds the just the logs, it’s when your development log in the test log, any of the output that gets outputted, while you’re doing stuff gets dumped into those files. Public is static files that are rendered to the user in certain cases, such as a 404, or 500.

If you want to file that’s just straight HTML and doesn’t involve the database, or rails objects at all, you can stick it in that folder. Storage, we’re not worrying about that. Temp is just a temp folder, we’re not going to worry about that either. vendor, we probably won’t use, we were going to use a third party SAS library to start. That might be where you put that eventually.

But I think for the purposes of Expedition, we’ll just probably stick it in this folder. And then the last one that’s important is in that root folder, the gem file. The gem file is like the, what is it called in, in node? The package dot Jason? Yes. gem file is the package dot JSON of Ruby. So it has all each line is like a gem space a name.

So gem rails gem Kuma gem, eg like it’s all these different, like libraries, and then you install them with the command bundle install. So that’s that’s like a very, like 10,000 foot view survey of the app. I think the first thing is what is what’s like the central domain concept here. Like I think you were describing me before the show, it’s like a task. Right?

So what would you like to call a single item? Let’s let’s come up with a name for this first, can we call it a task? Task is great. Okay, so go to a terminal. So all the commands to interact with this, this, the Rails app itself, are done through the command line. And we’re going to use the rails command again. So type bin slash rails, or just rails, either one is fine.

And then you can either type G or you can type generate, it’s the same thing. I do G because I’m lazy, you can type out generate. And we’re going to use scaffold, because this is going to be the most the fastest way to do this. So type the word scaffold, the Generate scaffold, and then type task, all lowercase. Don’t hit enter yet. Um, what are a couple like fields, you know, a task is going to like think of the most basic possible task

Okay. So do so after task do space, and then type description colon string. And then you said location. So, it’s also a string, I’m assuming we could

Don’t worry about that. We’re gonna come back to that. Okay. So it’s a great location. You don’t need that.

If it’s going to be if it’s complete or not complete dude as a Boolean.

complete them. Yes. I

go ahead and do what’s called important and urgent, right? Those are the two things.

do those as Boolean also, okay? Okay, so you’re what you’ve typed is, in Rails generate scaffold task description, colon, string, complete colon, Boolean, important colon, Boolean, Virgin colon, Boolean.

Okay, so what scaffold does is, scaffold is going to create the the model that like the initial class for it, it’s going to create the controller with all of the crud actions already flushed out, it’s going to create the views that you need for all of those different controller actions, it’s going to create the database migration to actually add the table with the columns that you’re specifying here.

And it’s going to add the route, which is to Rails runs its own server, like how you have a patchy or whatever. Rails will take the requests in, it’ll consult the routing table and say, based on the URL you gave me, it matches this route, which maps to this controller action. And I’ll show you what those mean in just a moment. Go ahead and hit Enter, Enter,

Okay, so the first thing, let’s go through each of these files you have the first one I see in the West is dB, migrate a whole bunch of numbers, and then it says create tasks. Time. So yeah, go ahead. And you can find that in your editor under the DB migrate folder, put it open that Okay, so this what am I Gration is this is one of the things I really liked about Rails.

When your database, the like the progress of your database over time is done through migrations. And what a migration is, is like, it’s a bit of database modifying code that has a timestamp on it.

And the timestamps kind of show like the evolution of the database over time, so I’ve worked on apps that have migrations that go back like five, six years, you can really see like the history of the app over time, you will create these generally not ever delete them, you can, but there’s really no reason to, when you clone the app down, and you set it up initially, it will run through each of these migrations, one after another,

and then like modify the database sequentially. So the end result should be item potent, and you should end up with the database in exactly the state it needs to be for the app. So this one that we created the the migrations called create tasks. And as you can see, there, it says, Create Table tasks. And then the do with the pipe and the T that’s called a block. Don’t overthink it, a block is just like a Ruby thing you could think of it it’s sort of like a closure.

Like it’s lazily evaluated. Generally, like conceptually, what you might want to think about it as is like, a block is like, given this stuff at the beginning of the line, do this stuff within it. So you have the CREATE TABLE task, or you have the CREATE TABLE like command, and then you’re saying like, okay, take this CREATE TABLE stuff, and then we’re going to run this additional code on that stuff. And then finish the task.

It’s like a subroutine. And you can see it’s creating each of the fields, therefore, does that make sense? What you’re seeing, like,

oh, you’ll notice there’s T dot timestamps, that is on that it’s just a given that’s on any, like rails model always have timestamps. And that gives you a column called created at, which is when the record was created, and updated at which is when the record was last touched. And then the there will also be a column, if it is a surrogate key called ID, and that is on every table, you don’t see it, because it’s just a given.

And like, there’s a lot of like rails magic that expects there to be an ID column. That is a primary key. And that is also like unique. So the next thing you see there is it says app slash models task. So go ahead and open that file up.

Okay, so this is very basic. And you can see he says, class task. And then the less than it says less than application record, less than is Ruby for like, inherits from world like subclass of. So it’s like task as a sub classing application, right?

Um, so application record is a generic ORM like object relational mapping, that represents like it, what it means is like this, this class is going to map directly to the database table. So the fields that are available or the attributes that are available to this class will map one to one with fields that are available in the database column itself. And then we have oh, so there’s routes.

That’s for the routing table, a resource is like, it’s a, like a domain concept that is exposed to the user via the web. Do the next line is up controllers tasks controller, go ahead and open that one up. The naming scheme is really important. The rails magic will expect a model called task to have a controller called tasks controller, there are ways to change that. But generally speaking, you shouldn’t.

So in this controller you’ve got so in Ruby, the word to make a function is called def, or presumably define. So if you have like def space new, that’s a function called New. Each one of these corresponds to a different controller action or like a given a request, it will route to one of these methods, and then do stuff. But you can see like there’s index and show, new, edit, create, update, delete, that’s all your crud actions. And each of these is

restful. So it’s the rest is representational, Representational State Transfer. And what that means is like, given an HTTP verb, such as get put, patch, post, delete, given one of those verbs, and a URL, the verb will affect how the URL is perceived by the server itself. So if you see there for delete, it says Delete space slash tasks slash one, right. And then you see where it says, For show, it says get slash tasks slash one.

So that’s the same URL. But the difference is that one of them is using the verb get, and one of them’s using the verb Delete. And depending on what verb is used, that will affect which action is used. Sometimes, when you’re when you’re doing an app, you’ll have a like a link or something, and you’re thinking it’s going to be like, a delete action.

But if it’s not actually passing the right HTTP verb in, it’ll get perceived as a show action is that, and then you can get errors and weird behaviors and like, Oh, why is it doing this? And that’s why. And then you can see the views. So there’s like app views, tasks, index, edit, show new form tasks, those correspond to the controller actions you just saw. So I think that’s that’s it.

So the first thing to do is go back to your browser, and then check out what error message you get when you refresh. Okay, so what’s it telling you

So, go back to the terminal. And the way we run migrations is type rails space. Yep, you got it, dB for database, colon, migrate. And then hit enter. And there you go.

So it runs the migration.

Okay, you’re ready to go?

So run, run that command, but this time append, so no space, just append his current status to the end there. So what that does is that shows you a list of all the migrations, and it shows you whether or not they’ve been run. And yeah, the app looks the same. Because we’re just looking at the root of the app. Go ahead and put slash tasks on the end.

There you go. Okay, so you’re seeing a page now that says tasks and it says new task with a link. And if you click on that link, it shows you a page it says new task. There’s a field that says description. And then there’s looks like three checkboxes

Yeah, so that’s, that’s the scaffold at work. Um, I personally, I generally don’t use scaffolding On the apps I write because I usually just, I have a way I like to do it. And I just write my stuff manually. But I think that it’s important, like, at least in the beginning, because it handles a lot of stuff that might be overwhelming otherwise. So you already have, go ahead and just throw it out, like, go ahead and write one, create a task.

There you go. You just created it, it shows you a little status message at the top there. You’re seeing so check out the URL, what URL you’re seeing there.

Okay, so let’s, let’s say that we just, we just were coming into the app. And this is the first page we’re seeing ever we don’t know what else we’re seeing. We don’t know anything else about the app. So go to your terminal, and type rails to space routes. This is the show you the routing table. You can basically see what it’s how they line up, right? Yeah, yeah, yeah, yeah. Okay. So like, let’s look at the first line.

The thing on the far left is the, the route helper prefix. So like, it says, tasks, and you’ll also see like, new underscore, task, edit underscore task, and then just saying your task. Each of those things can be appended with our underscore path or underscore URL. And then rails internals will know to map that, it’ll consult the routing table, and it will give you the URL or the path that goes along.

The the thing right after that the next column is the HTTP verb, you have get POST, PUT patch, put Delete. The next column is the URL like template, I guess you would call it. Like, so you see, like there slash tasks for index. The one you’re highlighting now is for edit, and that says, slash tasks slash colon ID slash edit. Yeah, go ahead and type. So check it out. So that’s showing you the edit page now.

And if you look back in the routing table, back to the routing table real quick. So you see that at the end of that line, it says tasks colon tasks, hash edit. That’s telling you it’s the tasks controller, and it’s the Edit action, the Edit method. So that though now, you know that if you’re looking at, for example, in your browser, it’s the slash tasks slash one. If you look at the list there, which action do you think you’re viewing right now?

task get this? How do you know it’s not task update? It’s the same URL. Right? It?

Right, exactly. So you see the get like the get action there. And that’s telling you that using show and update, right? Congratulations.

You’re now a Rails engineer. Excellent. So yeah, so there you go like this is I mean, I would say we’re like halfway there, right. But this is like this is you now have a functional, like input output basis that you can start with,

And you can see both tasks in the list their

What do you want to do next with this? What do you what do you think is the next incremental feature? Okay, so,

and and you want to see it in the grid form.

Okay, so go into your app slash views folder. And go with the tasks. Yep, you got it, and then go to index. Yep. Alright, so this should look familiar to you. Yes. Okay, so a couple of rails or Ruby slash rails things, a Ruby thing is you see that at tasks there? Yeah. Whoops. Sorry. Back there you Yes,

yeah. So on line six, it says add tasks to the, the, the at symbol at the beginning of, like a string like that indicates that it’s an instance variable. Um, this would be like in PHP, like $1 sign. So at tasks being this is a variable that is like, local to this scope, and the name is tasks.

This then you have dot each, Ruby, like many like a C++ or, or sorry, not C++, Java is like this with a dot notation, right? dot indicates that you are going to send the the app tasks, you’re going to send it the message called each and each is, as you might imagine, like an enumerator, like it’s going to iterate through this collection, then you have do the word do that is implying you’re starting a block.

So you’re going to take the tasks, you’re going to iterate through each task. And then on each of those tasks, you’re going to perform this, the commands that are within this block. And then after that, you have pipe task pipe, that indicates that in this block, you have a local scoped to justice block a variable called task that represents the current task item that you are viewing.

The value you put in between the pipes is completely arbitrary. You can call it whatever you want. But it represents symbolically it represents the item you’re currently on.

correct. Okay. Yeah. So the pipes just indicate it’s like demarcating, like, this is the name for the for the enumerated, like, current thing. After that, you just refer to it by the name of Yeah, like, for each

there’s the copyright. So then you see also the less than percent looks like ASP style syntax. Yeah. And then you have less or less than percent equals on line seven. Yes. So the difference there, and this is really important, less than percent by itself does not Echo to the, to the extreme output to the server, less than percent equals does Echo to the stream output. Gotcha.

So less than percent is when you want things to just you’re saying like, Hey, this is Ruby code straight logic. Yeah. And then if I say percent equals means, this is Ruby code, but whatever the output is, of this block of this string, or command should be emitted to the server. What are you having seen the page for this index? What do you think link to does

Yeah, so this is something that can be difficult at first for people beginning out, there’s a lot of what my coworker what’s called PFM, which is pure magic. And Rails has a ton of it. So in this case, you’re exactly right. Link to is a method. In Ruby, you don’t have to use parentheses for argument lists. But you can if you want, if it makes it clearer, you can just do a space. So it’s linked to the first argument is show this task as a string.

The second argument is an object or it could be other things. There’s other commands you can get for it. In this case, though, we’re giving it a task object. And rails will identify oh, what kind of model is this object? And then it will, it will see that this is a task class. And then it knows that task classes are the task model. And it knows that the task model uses the task resource.

So it like it infers all of this for you. And then it like it, figures it all out, and then just makes it happen. Yeah, I see you’re typing out the manual Psalm.

Yes, yeah. Go ahead. Save, save it and then reload the page.

Yes. That is that is exactly correct. And it will show up. I should be identical.

Exactly, right. Okay. And there’s additional arguments you could do with link to, but we don’t need to do that right now. Sure, sure. Yeah. Okay, so, uh,

where do you think what do you think render task is doing? Like, what do you think it’s referring to? I guess so. So

Yes. So that’s the thing that’s, you’re correct. Except that it’s the the name task here is referring to the object. And then what Rails is going to do is it’s going to look at the object and look at what type it is. And then from that type, it’s going to infer, oh, it’s a task resource. Where do I start Task resources? Oh, there are the tasks folder of views. And then it’s going to look for the partial that is named as the singular inflection of that resource. So

But our tasks were RWR.

But this should also actually partial is exactly right. That’s, that’s the word that rails uses for these things. Um, partials are always prefixed with an underscore. And there’s a whole lot of shit you can do with partials as far as passing in arguments and like localized variables and stuff. We may or may not get to that today. But this I mean, this is just an HTML.

ERB is embedded Ruby, which is like that. This is files underscore task dot HTML dot E. RB dot ARB just indicates it’s like how, in PHP, you have the dot php extension. It tells Ruby, it tells rails, this is a has file has Ruby in it, and you should parse the Ruby out before you render the HTML, right. So you’re just took the the div.

Right? It’s a good and rerender Okay, so only halfway there. What happened here?

Right? So, so what do you think you’d have to do to change this? So I think

Boom. Yeah, nice. Well done.

Okay. So there are a bunch of different ways that we can do this, I’m going to give you the one that’s going to be the fastest to execute fastest in terms of us doing it on the show, not in terms of performance.

And so we’re going to do that. So the first thing I want you to do is in that index file, I want you to create, like, I created like a table tag, right? That’s what we’re going to do here. That probably be easiest.

Okay, so, go ahead and take that URL block, and then go ahead and just grab the whole thing. It’s sticking inside of the first TD. Let’s let’s start with that. And go ahead and like save that, and then load it up in the browser. Let’s make sure that it works. Oh, cool. Okay. All right. So

what we have on the tasks model, I want you to open up a terminal, we’re going to go into the console. So type a Rails space C for console. This is like a repple, like a, what is it read execute something or other? I forget references, where it’s just it’s a terminal. It’s like this console that you’re in right now. You have access to any rails command. Or like any plain Ruby, it’s like a Python console or whatever. It’s a JavaScript console. Type uppercase t task.

And then type dot first. Yep, that’s it, and enter. So, task dot first says, given a task, which is the task model that we created, give me the first record. Alright, so remember how we created those complete, important and urgent as Boolean fields? Yes. Okay. So type, do task dot. Where space parentheses complete colon true. Let’s think complete give you a Boolean gave you a default scope.

Oh, sorry, no space after the where? The parentheses an argument of where? To go. Okay, so see the SQL query there? Yes. So what’s that doing?

what about if you did what you wanted to do what was urgent? How would you do that?

Yep. And there you go. And you’re seeing the two tasks that you had marked as urgent previously. What about if you wanted to do both urgent and important? How do you think you would do that?

True. Look around and find out. Boom, there you go. Got one. Okay. So let’s, let’s add really quickly, let’s go into the task model. And let’s add some helpers. Some like assisting code here. Within the class, we’re going to use the keyword scope. And scope is kind of think of it like a filter. So scope, space, colon Complete. And then comma.

And then this is, I call it stabby. Syntax, it looks like a little dagger, do dash greater than. And then space. Really prends. And then complete colon true. Or sorry, were complete colon true, just like you had in the, in the console. Yes. Okay. And then do the same thing for important and urgent. Okay, save that. Go back to your console.

And type reload, bang, reload, exclamation point. Yeah, that’s the one. Okay, and now do task complete. Cool. So you can see it’s doing the same thing as it did before we typed out with the where clause. So

cool, though, is that you can chain them together. And then active record, which is like the ORM that sits underneath all this, it will evaluate all the things you’re asking to do. And then it will craft the SQL query as efficiently as reasons you can. So try doing task dot important, not urgent.

right. So let’s get it. it infers that you want to do like a huge amount in Union, but like, and have both of them. If you were doing joins and stuff with associations, which maybe we can do on a future episode, it would figure out which kind of join is best. And it would do that for you. It’s, it’s pretty incredible, like, what they can do with that.

Okay, so given this, we are going to go performance inefficient, but show performance efficient. Um, take a guess at what you would do for each of this.

Cool. All right. So that I think you know what to do for the rest, so

The top right and bottom left ones also show more tasks than they should be as well, for the same reason that, yeah, so what we’re going to do is we’re going to try using the NOT operator. So go into the entry for the top right one. And I think this is important, but not urgent. Any index file, yeah. Okay. Yeah.

So right after dot important, on line 19, type dot knots, and O T. And then do parentheses. And we’re gonna have to expand with the syntax here. Try colon, urgent. Let’s see if that works.

Because we have a scope called urgent, and there’s also a field a Boolean field called urgent, it might just know what to do. Let’s see if that works. Oh, it didn’t. It did not. Okay. Hold on, hold on. So look down to the bottom there. See the black box at the bottom? That’s actually a live console. Keep going down the mouse. Oh, here. Gotcha. Yeah, click right there. So type tasks.

So you see you have like a console right there. And what it’s doing is it’s giving you a debugging console, right at the point of execution. So let’s experiment with a couple things here. Try at tasks dot important. And then try after the important do dot where. Or you could just you know, this is a Boolean field. Instead of dot not just do where urgent colon false. That’s easier.

There’s frequently with the the pure magic that Rails has. I’ll frequently just be like, does this work? And I’ll just try something. And sometimes it just works. Like sometimes the the magic just happens. And sometimes it doesn’t. And it’s kind of a crapshoot. And that is one of the things that makes rails be kind of annoying to learn initially.

looks a little better. Is that each one? Exactly the way it should be? I have Yeah. So

yeah, at this point, this is a like this is I think, the MVP, we are going

Since this is built in REL seven, REL seven actually has this really cool stuff called stimulus J S. And let’s say it’s reflex, um, and turbolinks, or the sorry, it’s just called turbo now. And that is like, prime stuff for doing single page apps. I’m gonna have to play around with that, before we do this next episode, because I haven’t even worked in the shit yet.

Because Bell seven just came out recently. But I’ve been meaning to learn it. So this would be a cool thing that I can learn. And then we can kind of go through it together. But like, it’s the demos that I’ve seen, it’s, it’s really amazing. They do a lot of like prefetching. And a lot of like, predictive requests and stuff. And it’s very fast. And this is sort of their answer to everyone using react to the front end and rails as an API back end.

But all in the same app. The Basecamp folks, we’re like, we’re gonna go ahead and make our own in house JavaScript library that we’re going to use. And so that’s what they did. And it’s like, the the stream demos that I’ve seen have been like, really incredible. So Michael, was adding a class to the link to new task.

Where have you been? It’s like three hours. I

have a cool I don’t know a cool discord.