Which serverside web framework is the best? To find out, I built the same app 10 times with 10 different programming languages.. Learn the fundamentals of fullstack web development by comparing MVC frameworks. 

#webdev #programming #top10

🔗 Resources

Ruby on Rails  https://rubyonrails.org/
Python Django https://djangoproject.com
PHP Laravel https://laravel.com/
Java Spring https://spring.io/
C# .NET https://dotnet.microsoft.com/en-us/apps/aspnet
Next.js https://nextjs.org/
Elixir Phoenix https://phoenixframework.org/
Rust Rocket https://rocket.rs/
Go Gin https://gin-gonic.com/
Swift Vapor https://vapor.codes/
Kotlin Ktor https://ktor.io/

📚 Chapters

00:00 I Built 10 Fullstack Apps
01:04 MVC Architecture Explained
01:39 Rails
03:58 Django
05:14 Laravel
06:32 Next
08:23 Spring
09:25 .NET
10:36 Phoenix
11:27 Gin
12:25 Rocket
13:13 Vapor
13:52 Ktor
14:01 The GOAT

🔥 Get More Content - Upgrade to PRO

Upgrade to Fireship PRO at https://fireship.io/pro
Use code lORhwXd2 for 25% off your first payment. 

🎨 My Editor Settings

- Atom One Dark 
- vscode-icons
- Fira Code Font

🔖 Topics Covered

- Comparison of server-side frameworks
- How to build a fullstack web app
- Best way to build a web application
- Comparison of web development tools
2024-02-04T05:29:39.401Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
97576204-2fb3-4bc0-8433-b47c60077efc
7164cac0e9527294865d746080de22a83404e31a9b5735656d4a0d4f2ae6f80c
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
This is a web app.
This is a web app.
This thing here also a web app.
Dude, why am I doing this again?
I built the same app 10 times with 10 different frameworks using 10 different programming languages.
It was a horrible experience, but I learned a lot, and I figured out which full stack framework is the greatest of all time, which will be revealed in dramatic fashion at the end of this video to to maximize the watch time.
On this journey, you will meet 10 different server side frameworks, like Rails, Django, Laravel, Spring dot net, Next.
Js, Phoenix, Rocket, gin, vapor, and ktor.
I realize that's 11, but you don't need to be good at math to be a programmer.
This video was insanely difficult because each one of these Frameworks uses a different programming language.
For each one of them, we will look at the overall developer experience, including things like setup, routing, database integration, and the overall architecture.
Now before we get started, here's a warning.
The framework you choose by the end of this video is going to dictate your life for the next 10 years as you grow your startup into a decade unicorn.
If your startup fails, it's 100% because you didn't choose the right framework.
Reminds me of when my dad made me Choose which of my pet calves to slaughter with my own hands for my 6th birthday.
Now before we look at the code, let's first answer the question of what does a web framework actually do.
There are 3 main things you should know.
1st, they provide an abstraction over your relational database.
They typically have a built in object relational mapper that can migrate code from your preferred programming language into SQL code that can be used by the database.
2nd, they provide routing that can map a URL in the browser to code that you want to run on the server.
And 3rd, They provide a way to dynamically insert data from your database directly into HTML for the UI.
Together, these three elements make up the model view controller architecture or MVC, which is by far the most common approach when building a full stack web app.
The first framework we'll look at is Ruby on Rails, made famous for building some of the biggest companies in the world, like Shopify, Airbnb, and GitHub.
Rails was revolutionary when it came out because it dramatically simplified web development compared to or approaches of the day.
It's still very popular in 2022, and is kind of a rebel in the web development space.
It has adjacent libraries like Hotwire, Stimulus, in Turbo that take an HTML centric approach to building web apps, which goes against the approach you might see in front end frameworks like React, Angular, and at Vue.
To get started with Rails, you'll first need to have Ruby installed, then install the rails gem and run rails new.
I'm developing this app on a fresh install of wm Linux and I did run-in Some issues with the initial setup.
These were errors that could easily be solved with a Google search, but the initial setup was a little more error prone than other frameworks.
Once you get the project set up though, the Rails CLI is extremely powerful.
Not only does it do things like serve the application with Rails Server, but it can also generate a ton of code for you automatically with commands like scaffold.
Now, if we look in the file explorer, you'll notice a bunch of different folders here and that's because Rails is a batteries included framework.
It handles your relational database, testing, logging, and a bunch of other stuff.
It might look pretty overwhelming at first.
Your main application code is contained in the app directory where you'll find folders for models, views, and controllers.
The first thing we'll look at is routing and the routes dot rb file.
From this file, we can map URLs to actions in a controller.
Resources create all the routes we would need for a basic CRUD feature automatically.
It's kind of magical, but What it's actually doing is setting up a mapping between URLs in the browser and controller actions.
Now, when the user visits a URL, it will trigger one of these actions on the server.
That action might go and retrieve some data from your database.
The logic for that data is contained in the model, but before we can use the data in the database, we need to run a migration, which will take the code in the model and sync it up with the actual database, and all the data is managed with an object relational mapper called active record.
And then finally, you have a Vue, which is an HTML dot ERP file.
ERP stands for embedded Ruby, and it allows you to render your data dynamically inside an HTML file.
Overall, this provides a very nice separation of concerns and Rails is very opinionated, which means you can achieve a lot of functionality with very little code.
The Scaffold not only retrieves items from the database, but it also that provides UI to create and update that data as well.
But too much magic can also be a bad thing depending on who you ask.
And Ruby is not the most popular language in the world, but Python is.
What if there is a way we could build web apps like this with Python?
And that's where Django comes in.
It's also extremely popular and has been used to Old massive sites like Spotify and Bitbucket.
When you generate a new Django app, you'll notice the file structure is far less overwhelming than rails, but at the same time it's still very much a batteries included framework.
In addition, your code tends to be a lot more explicit.
For example, we have this manage py file that contains the code for the actual command line interface to generate things in the project.
We could use it to serve the app locally or generate an app to represent a feature of the website.
It also follows the MVC architecture with routes being defined in the urls.py file, and controllers are represented as Python functions and in the views dot py file.
A route points to one of these functions, which itself might want to access data from one of our models.
A model is a Python Class represents the structure of data in an SQL database, a k a the object relational mapper.
And, finally, we have our HTML templates that allow you to embed Python directly into the code.
That's pretty cool, but one extra superpower of Django is that it has an admin feature built into it directly.
As you define models in your application, you can register them with the admin app to easily manage all of your data in the browser.
This is really useful and not something that you'd want to roll out on your own.
Python's great and all, but the original server side language of the web was PHP.
There have been countless PHP frameworks over the years and high level tools like WordPress, but the most popular one today is Laravel, the PHP framework for web artisans.
To use it, you'll first want to install PHP and a tool called Composer.
When I generated my initial app, it took a long time and downloaded a lot of packages.
And as you can see, the initial project has a lot of batteries included, even more so than rails.
If we look at routes, You can see it not only handles web routes, but also API routes and channels for real time communication with WebSockets.
Now, if we We go into the app code, you'll notice it's already been configured with things like user authentication via providers.
A provider is like a shared service that you can use anywhere in the application.
In the HTTP directory, we will find our controllers, and just like Rails, we have a class that contains a bunch of different methods that can access data and render a specific template.
Now, our database models use a tool called Eloquent ORM, which is based on the same active record pattern as Rails.
Now, when it comes to views, PHP is a language that's designed to work with HTML out of the box.
Laravel makes it even easier by building on top of PHP with blade templates.
Another cool point about the ecosystem is that they put a lot of thought into how to integrate front end frameworks like React and Vue.
It has an adjacent tool called inertia that can bridge the gap between front end and back end frameworks.
The next framework we'll look at is Next.
Js, which allows us to build a full Stack application entirely with JavaScript.
Now, in the JavaScript world, there's a million different options we could have chosen here like Nuxt.
Js, Angular Universal, builtkit, nestjs, adonis, and many others.
Maybe I'll make a top ten video just for those.
To get started with Next, we run npx create Next App, and that will generate a starter project.
Now the one thing you'll notice about Next right off the bat is that it doesn't provide any integration for your database.
There are a 1000000 different solutions to choose from, but one of my personal favorites is Prisma.
So I'm going to add Prisma to this project.
The fact that Next.
Js doesn't have a database out of the box is a good thing in my opinion.
The JavaScript ecosystem is just way too crazy.
It's nice to start with a very good minimal framework and then add whatever database integration you want on top of it.
Now that we have a database integrated, let's take a look at the page's directory.
One thing that's different about Next is that routing is handled with the file system.
Each file defined in the page's directory defines a different URL and the browser.
Dynamic routes can be created by wrapping the file name in brackets.
Now, each one of these files exports a React component to define the UI or view.
This is actually really convenient because many other frameworks will ultimately want to have some kind of front end framework.
Having React fundamentally integrated into the framework or can streamline your productivity big time.
Now, things get more complex when you think about data fetching.
Normally, in a React app, you're thinking about client side code, but in Next.
Js, you can also run server side code with functions like get server side props.
This function will run on the server with Node.
Js, and as you can see inside of it, we're using Prisma to fetch some items from the database.
These items can then be delivered as props to the React component where they're rendered in the UI.
Both your server side and client side code is tightly coupled together, which may feel like a bad separation of concerns, but generally speaking it actually works very well.
Overall, Next.
Js feels very minimal compared to other frameworks in this list, but it does a ton of stuff behind the scenes to simplify the annoying parts of web development.
Now, speaking of simple, we're going to do the polar opposite and see what Java has to offer.
Even though Java is a boilerplate driven language for writing instant legacy code, the Spring framework actually makes it very enjoyable to work with.
The first thing you'll Notice when building with it is that it's kind of like a create your own adventure story.
It has a generator that allows you to start with a framework and you can even use Kotlin or Groovy if you'd like, then you choose all the different dependencies that you want to add to this project.
Now, even though Java does have a lot of boilerplate, the code pretty much writes itself, and in my opinion, it feels a lot more robust compared to the dynamic languages that we've looked at so far.
You'll find the source code way down in this deeply nested folder and it also follows the MVC pattern.
The controller is a class and a route is defined using a decorator on each one of its methods.
Spring relies on a lot of metaprogramming to keep your code nice and simple.
It feels very much like Angular in the JavaScript world.
The database models are based on code with the Java persistence API, AI, then we can use that data in templates using Thymeleaf, where you add these attributes to your HTML to define where your data should go.
To be honest though, I didn't have a very good time using Thymeleaf.
I believe.
And that brings me to Java's arch nemesis, c sharp and the dot net framework or asp.net.
It's an open source project maintained by Microsoft and obviously feels very Microsofty, but is extremely popular and reliable.
It's evolved very nicely over the years and has modern supporting libraries like Blazor that allow you to build client side apps using WebAssembly and in c sharp.
To use it, install the dot net SDK, then generate a new MBC application.
I really like the initial project structure.
Everything is clearly named and it's Not too overwhelming.
And you get all the awesome tooling and static typing like you do in Java.
When it comes to routing, the URLs are inferred from the class names in your controllers.
Here, we have an animals controller, which gives us the animals URL, then we have methods in that class that then represent the next URL segment.
The method can take an argument meant to create a dynamic URL.
To represent our data, we have a model that is managed by an ORM called the entity core framework.
And then finally, we have our used, which are written in cshtml.
At the top of one of these files, you'll notice a model where we can access our data, and we can also declare additional data here in c sharp like a title.
It's More verbose than other templating languages, but you get full IntelliSense inside of it, which is really helpful.
Overall, dot net is really impressive.
The only real Drawback is that you have to sell your soul to the big giant tech corporation.
If you wanna take the righteous path, another awesome framework to check out is Phoenix, which is based on the or programming language.
It's a functional language that feels much different than most of the object oriented languages that we've looked at throughout the video.
Don't worry, a 100 second video is coming soon.
Install Call it, then generate a new project.
Like Ruby on Rails, it has a very powerful CLI that can automatically scaffold an entire CRUD application for you.
Routing is also very similar to Rails where we have resources that map all the necessary CRUD URLs to the controller.
In the controller, we have functions name spaced under a module that access data and render the appropriate template.
The model uses an object relational mapper called Ecto, and templates use embedded Elixir, which again feels very similar to Rails.
However, Phoenix has a huge advantage in performance because Elixir is a compiled language.
As an added bonus, every app has a built in live dashboard to closely monitor performance.
And that brings us to another high performance framework worth checking out, gin, which is powered by the Go language.
It Easily wins the best logo award.
To get started, we're not going to use a fancy CLI, but instead create a Go project from scratch.
Gin is a minimal HTTP framework, and is not concerned with the model view controller architecture.
We'll have to figure that out on our own.
It also doesn't contain an ORM for the database, so for That will bring in another package called Gorm.
The nice thing about this approach is that we don't really need to follow the MVC conventions of a framework, which is probably overkill for many applications.
Instead, we can write some very focused functions, and do things in a way that makes sense for our exact business needs.
Like in this app, we just have 2 routes that need to retrieve some data from a database, which itself as modeled with a struct using the ORM.
Then Go has its own built in templating language, so we can simply create a couple of template files here in the project and interpolate the values that we you retrieve from the database.
The end result is a much smaller code base with a lot more low level control.
However, as this application grows bigger, it's going to and harder and harder.
So you really kinda have to know what you're doing.
And that brings us to our next language, Rust, and the web framework Rocket.
As far as I know, the Rust ecosystem doesn't have a full blown MVC a framework like Rails.
And to be honest, I found it very difficult to build a basic application.
My approach was to use Rocket for HTTP and routing, then combine it with Diesel, which is a Rust based ORM, and then finally, a templating language to use the data in HTML called AskComma.
I think this is a reasonable approach, but I didn't quite get to a full working demo with It's a systems language that gives you low level control over memory, which the average web application developer doesn't really need.
I quickly realized that it would take more time and dedication than I'm willing to give for the tail end of a silly YouTube video.
However, there is one Rust based library that I want to bring to your attention called U.
It's a component based framework for building web apps with WebAssembly, and it's coming to a Fireshift tutorial near you soon.
And that brings us to the final framework in this list, Vapor, which is based on the Swift programming language.
This is the only app that I built on my Mac because I found that Anything with Swift just works better on a Mac.
It provides you with a project structure that looks like this.
It's well organized with controllers, models, and routes.
Routes point to methods in the controller, which can access data from a model.
It uses an ORM called fluent, which uses classes along with decorators to model your data.
Swift is a very well designed language and I found it very enjoyable to work with for stuff like this.
The code is concise and readable yet statically typed with awesome tooling like you would get in Java or c sharp.
I also like how it embraces asyncawait when fetching data from your models.
For templating, it has an engine called Leaf, which also felt very modern and practical.
Now that we look at Vapor, I want to also mention Ktor, which is a Kotlin based web application framework.
It's a lot more minimal than something like Spring, but also something worth checking out.
And with that, we've looked at 10 full stack frameworks.
Now I'm ready to show you the best full stack framework in the world.
You're looking at your own reflection in the mirror.
Yes, it was you all along.
Without you, the framework would be nothing.
Actually, no.
No.
That's that's just dumb.
Ruby on Rails is by far the best framework.
Nothing else even comes close.
It's like the magic Jordan of web frameworks.
Thanks for watching and I will see you in the next one.

Speaker 0: This is a web app. This is a web app. This thing here also a web app. Dude, why am I doing this again? I built the same app 10 times with 10 different frameworks using 10 different programming languages.

It was a horrible experience, but I learned a lot, and I figured out which full stack framework is the greatest of all time, which will be revealed in dramatic fashion at the end of this video to to maximize the watch time. On this journey, you will meet 10 different server side frameworks, like Rails, Django, Laravel, Spring dot net, Next. Js, Phoenix, Rocket, gin, vapor, and ktor. I realize that's 11, but you don't need to be good at math to be a programmer. This video was insanely difficult because each one of these Frameworks uses a different programming language.

For each one of them, we will look at the overall developer experience, including things like setup, routing, database integration, and the overall architecture. Now before we get started, here's a warning. The framework you choose by the end of this video is going to dictate your life for the next 10 years as you grow your startup into a decade unicorn. If your startup fails, it's 100% because you didn't choose the right framework. Reminds me of when my dad made me Choose which of my pet calves to slaughter with my own hands for my 6th birthday.

Now before we look at the code, let's first answer the question of what does a web framework actually do. There are 3 main things you should know. 1st, they provide an abstraction over your relational database. They typically have a built in object relational mapper that can migrate code from your preferred programming language into SQL code that can be used by the database. 2nd, they provide routing that can map a URL in the browser to code that you want to run on the server.

And 3rd, They provide a way to dynamically insert data from your database directly into HTML for the UI. Together, these three elements make up the model view controller architecture or MVC, which is by far the most common approach when building a full stack web app. The first framework we'll look at is Ruby on Rails, made famous for building some of the biggest companies in the world, like Shopify, Airbnb, and GitHub. Rails was revolutionary when it came out because it dramatically simplified web development compared to or approaches of the day. It's still very popular in 2022, and is kind of a rebel in the web development space.

It has adjacent libraries like Hotwire, Stimulus, in Turbo that take an HTML centric approach to building web apps, which goes against the approach you might see in front end frameworks like React, Angular, and at Vue. To get started with Rails, you'll first need to have Ruby installed, then install the rails gem and run rails new. I'm developing this app on a fresh install of wm Linux and I did run-in Some issues with the initial setup. These were errors that could easily be solved with a Google search, but the initial setup was a little more error prone than other frameworks. Once you get the project set up though, the Rails CLI is extremely powerful.

Not only does it do things like serve the application with Rails Server, but it can also generate a ton of code for you automatically with commands like scaffold. Now, if we look in the file explorer, you'll notice a bunch of different folders here and that's because Rails is a batteries included framework. It handles your relational database, testing, logging, and a bunch of other stuff. It might look pretty overwhelming at first. Your main application code is contained in the app directory where you'll find folders for models, views, and controllers.

The first thing we'll look at is routing and the routes dot rb file. From this file, we can map URLs to actions in a controller. Resources create all the routes we would need for a basic CRUD feature automatically. It's kind of magical, but What it's actually doing is setting up a mapping between URLs in the browser and controller actions. Now, when the user visits a URL, it will trigger one of these actions on the server.

That action might go and retrieve some data from your database. The logic for that data is contained in the model, but before we can use the data in the database, we need to run a migration, which will take the code in the model and sync it up with the actual database, and all the data is managed with an object relational mapper called active record. And then finally, you have a Vue, which is an HTML dot ERP file. ERP stands for embedded Ruby, and it allows you to render your data dynamically inside an HTML file. Overall, this provides a very nice separation of concerns and Rails is very opinionated, which means you can achieve a lot of functionality with very little code.

The Scaffold not only retrieves items from the database, but it also that provides UI to create and update that data as well. But too much magic can also be a bad thing depending on who you ask. And Ruby is not the most popular language in the world, but Python is. What if there is a way we could build web apps like this with Python? And that's where Django comes in.

It's also extremely popular and has been used to Old massive sites like Spotify and Bitbucket. When you generate a new Django app, you'll notice the file structure is far less overwhelming than rails, but at the same time it's still very much a batteries included framework. In addition, your code tends to be a lot more explicit. For example, we have this manage py file that contains the code for the actual command line interface to generate things in the project. We could use it to serve the app locally or generate an app to represent a feature of the website.

It also follows the MVC architecture with routes being defined in the urls.py file, and controllers are represented as Python functions and in the views dot py file. A route points to one of these functions, which itself might want to access data from one of our models. A model is a Python Class represents the structure of data in an SQL database, a k a the object relational mapper. And, finally, we have our HTML templates that allow you to embed Python directly into the code. That's pretty cool, but one extra superpower of Django is that it has an admin feature built into it directly.

As you define models in your application, you can register them with the admin app to easily manage all of your data in the browser. This is really useful and not something that you'd want to roll out on your own. Python's great and all, but the original server side language of the web was PHP. There have been countless PHP frameworks over the years and high level tools like WordPress, but the most popular one today is Laravel, the PHP framework for web artisans. To use it, you'll first want to install PHP and a tool called Composer.

When I generated my initial app, it took a long time and downloaded a lot of packages. And as you can see, the initial project has a lot of batteries included, even more so than rails. If we look at routes, You can see it not only handles web routes, but also API routes and channels for real time communication with WebSockets. Now, if we We go into the app code, you'll notice it's already been configured with things like user authentication via providers. A provider is like a shared service that you can use anywhere in the application.

In the HTTP directory, we will find our controllers, and just like Rails, we have a class that contains a bunch of different methods that can access data and render a specific template. Now, our database models use a tool called Eloquent ORM, which is based on the same active record pattern as Rails. Now, when it comes to views, PHP is a language that's designed to work with HTML out of the box. Laravel makes it even easier by building on top of PHP with blade templates. Another cool point about the ecosystem is that they put a lot of thought into how to integrate front end frameworks like React and Vue.

It has an adjacent tool called inertia that can bridge the gap between front end and back end frameworks. The next framework we'll look at is Next. Js, which allows us to build a full Stack application entirely with JavaScript. Now, in the JavaScript world, there's a million different options we could have chosen here like Nuxt. Js, Angular Universal, builtkit, nestjs, adonis, and many others.

Maybe I'll make a top ten video just for those. To get started with Next, we run npx create Next App, and that will generate a starter project. Now the one thing you'll notice about Next right off the bat is that it doesn't provide any integration for your database. There are a 1000000 different solutions to choose from, but one of my personal favorites is Prisma. So I'm going to add Prisma to this project.

The fact that Next. Js doesn't have a database out of the box is a good thing in my opinion. The JavaScript ecosystem is just way too crazy. It's nice to start with a very good minimal framework and then add whatever database integration you want on top of it. Now that we have a database integrated, let's take a look at the page's directory.

One thing that's different about Next is that routing is handled with the file system. Each file defined in the page's directory defines a different URL and the browser. Dynamic routes can be created by wrapping the file name in brackets. Now, each one of these files exports a React component to define the UI or view. This is actually really convenient because many other frameworks will ultimately want to have some kind of front end framework.

Having React fundamentally integrated into the framework or can streamline your productivity big time. Now, things get more complex when you think about data fetching. Normally, in a React app, you're thinking about client side code, but in Next. Js, you can also run server side code with functions like get server side props. This function will run on the server with Node.

Js, and as you can see inside of it, we're using Prisma to fetch some items from the database. These items can then be delivered as props to the React component where they're rendered in the UI. Both your server side and client side code is tightly coupled together, which may feel like a bad separation of concerns, but generally speaking it actually works very well. Overall, Next. Js feels very minimal compared to other frameworks in this list, but it does a ton of stuff behind the scenes to simplify the annoying parts of web development.

Now, speaking of simple, we're going to do the polar opposite and see what Java has to offer. Even though Java is a boilerplate driven language for writing instant legacy code, the Spring framework actually makes it very enjoyable to work with. The first thing you'll Notice when building with it is that it's kind of like a create your own adventure story. It has a generator that allows you to start with a framework and you can even use Kotlin or Groovy if you'd like, then you choose all the different dependencies that you want to add to this project. Now, even though Java does have a lot of boilerplate, the code pretty much writes itself, and in my opinion, it feels a lot more robust compared to the dynamic languages that we've looked at so far.

You'll find the source code way down in this deeply nested folder and it also follows the MVC pattern. The controller is a class and a route is defined using a decorator on each one of its methods. Spring relies on a lot of metaprogramming to keep your code nice and simple. It feels very much like Angular in the JavaScript world. The database models are based on code with the Java persistence API, AI, then we can use that data in templates using Thymeleaf, where you add these attributes to your HTML to define where your data should go.

To be honest though, I didn't have a very good time using Thymeleaf. I believe. And that brings me to Java's arch nemesis, c sharp and the dot net framework or asp.net. It's an open source project maintained by Microsoft and obviously feels very Microsofty, but is extremely popular and reliable. It's evolved very nicely over the years and has modern supporting libraries like Blazor that allow you to build client side apps using WebAssembly and in c sharp.

To use it, install the dot net SDK, then generate a new MBC application. I really like the initial project structure. Everything is clearly named and it's Not too overwhelming. And you get all the awesome tooling and static typing like you do in Java. When it comes to routing, the URLs are inferred from the class names in your controllers.

Here, we have an animals controller, which gives us the animals URL, then we have methods in that class that then represent the next URL segment. The method can take an argument meant to create a dynamic URL. To represent our data, we have a model that is managed by an ORM called the entity core framework. And then finally, we have our used, which are written in cshtml. At the top of one of these files, you'll notice a model where we can access our data, and we can also declare additional data here in c sharp like a title.

It's More verbose than other templating languages, but you get full IntelliSense inside of it, which is really helpful. Overall, dot net is really impressive. The only real Drawback is that you have to sell your soul to the big giant tech corporation. If you wanna take the righteous path, another awesome framework to check out is Phoenix, which is based on the or programming language. It's a functional language that feels much different than most of the object oriented languages that we've looked at throughout the video.

Don't worry, a 100 second video is coming soon. Install Call it, then generate a new project. Like Ruby on Rails, it has a very powerful CLI that can automatically scaffold an entire CRUD application for you. Routing is also very similar to Rails where we have resources that map all the necessary CRUD URLs to the controller. In the controller, we have functions name spaced under a module that access data and render the appropriate template.

The model uses an object relational mapper called Ecto, and templates use embedded Elixir, which again feels very similar to Rails. However, Phoenix has a huge advantage in performance because Elixir is a compiled language. As an added bonus, every app has a built in live dashboard to closely monitor performance. And that brings us to another high performance framework worth checking out, gin, which is powered by the Go language. It Easily wins the best logo award.

To get started, we're not going to use a fancy CLI, but instead create a Go project from scratch. Gin is a minimal HTTP framework, and is not concerned with the model view controller architecture. We'll have to figure that out on our own. It also doesn't contain an ORM for the database, so for That will bring in another package called Gorm. The nice thing about this approach is that we don't really need to follow the MVC conventions of a framework, which is probably overkill for many applications.

Instead, we can write some very focused functions, and do things in a way that makes sense for our exact business needs. Like in this app, we just have 2 routes that need to retrieve some data from a database, which itself as modeled with a struct using the ORM. Then Go has its own built in templating language, so we can simply create a couple of template files here in the project and interpolate the values that we you retrieve from the database. The end result is a much smaller code base with a lot more low level control. However, as this application grows bigger, it's going to and harder and harder.

So you really kinda have to know what you're doing. And that brings us to our next language, Rust, and the web framework Rocket. As far as I know, the Rust ecosystem doesn't have a full blown MVC a framework like Rails. And to be honest, I found it very difficult to build a basic application. My approach was to use Rocket for HTTP and routing, then combine it with Diesel, which is a Rust based ORM, and then finally, a templating language to use the data in HTML called AskComma.

I think this is a reasonable approach, but I didn't quite get to a full working demo with It's a systems language that gives you low level control over memory, which the average web application developer doesn't really need. I quickly realized that it would take more time and dedication than I'm willing to give for the tail end of a silly YouTube video. However, there is one Rust based library that I want to bring to your attention called U. It's a component based framework for building web apps with WebAssembly, and it's coming to a Fireshift tutorial near you soon. And that brings us to the final framework in this list, Vapor, which is based on the Swift programming language.

This is the only app that I built on my Mac because I found that Anything with Swift just works better on a Mac. It provides you with a project structure that looks like this. It's well organized with controllers, models, and routes. Routes point to methods in the controller, which can access data from a model. It uses an ORM called fluent, which uses classes along with decorators to model your data.

Swift is a very well designed language and I found it very enjoyable to work with for stuff like this. The code is concise and readable yet statically typed with awesome tooling like you would get in Java or c sharp. I also like how it embraces asyncawait when fetching data from your models. For templating, it has an engine called Leaf, which also felt very modern and practical. Now that we look at Vapor, I want to also mention Ktor, which is a Kotlin based web application framework.

It's a lot more minimal than something like Spring, but also something worth checking out. And with that, we've looked at 10 full stack frameworks. Now I'm ready to show you the best full stack framework in the world. You're looking at your own reflection in the mirror. Yes, it was you all along.

Without you, the framework would be nothing. Actually, no. No. That's that's just dumb. Ruby on Rails is by far the best framework.

Nothing else even comes close. It's like the magic Jordan of web frameworks. Thanks for watching and I will see you in the next one.
This is a web app. This is a web app. This thing here also a web app. Dude, why am I doing this again? I built the same app 10 times with 10 different frameworks using 10 different programming languages. It was a horrible experience, but I learned a lot, and I figured out which full stack framework is the greatest of all time, which will be revealed in dramatic fashion at the end of this video to to maximize the watch time.
programming
On this journey, you will meet 10 different server side frameworks, like Rails, Django, Laravel, Spring dot net, Next. Js, Phoenix, Rocket, gin, vapor, and ktor. I realize that's 11, but you don't need to be good at math to be a programmer. This video was insanely difficult because each one of these Frameworks uses a different programming language. For each one of them, we will look at the overall developer experience, including things like setup, routing, database integration, and the overall architecture. Now before we get started, here's a warning. The framework you choose by the end of this video is going to dictate your life for the next 10 years as you grow your startup into a decade unicorn. If your startup fails, it's 100% because you didn't choose the right framework. Reminds me of when my dad made me Choose which of my pet calves to slaughter with my own hands for my 6th birthday.
software development
software
youtube
video gaming
graphic design
programming
Now before we look at the code, let's first answer the question of what does a web framework actually do. There are 3 main things you should know. 1st, they provide an abstraction over your relational database. They typically have a built in object relational mapper that can migrate code from your preferred programming language into SQL code that can be used by the database. 2nd, they provide routing that can map a URL in the browser to code that you want to run on the server. And 3rd, They provide a way to dynamically insert data from your database directly into HTML for the UI. Together, these three elements make up the model view controller architecture or MVC, which is by far the most common approach when building a full stack web app. The first framework we'll look at is Ruby on Rails, made famous for building some of the biggest companies in the world, like Shopify, Airbnb, and GitHub.
databases
data management
architecture
Rails was revolutionary when it came out because it dramatically simplified web development compared to or approaches of the day. It's still very popular in 2022, and is kind of a rebel in the web development space. It has adjacent libraries like Hotwire, Stimulus, in Turbo that take an HTML centric approach to building web apps, which goes against the approach you might see in front end frameworks like React, Angular, and at Vue. To get started with Rails, you'll first need to have Ruby installed, then install the rails gem and run rails new. I'm developing this app on a fresh install of wm Linux and I did run-in Some issues with the initial setup. These were errors that could easily be solved with a Google search, but the initial setup was a little more error prone than other frameworks. Once you get the project set up though, the Rails CLI is extremely powerful. Not only does it do things like serve the application with Rails Server, but it can also generate a ton of code for you automatically with commands like scaffold. Now, if we look in the file explorer, you'll notice a bunch of different folders here and that's because Rails is a batteries included framework.
It handles your relational database, testing, logging, and a bunch of other stuff. It might look pretty overwhelming at first. Your main application code is contained in the app directory where you'll find folders for models, views, and controllers. The first thing we'll look at is routing and the routes dot rb file.
databases
software
data management
From this file, we can map URLs to actions in a controller. Resources create all the routes we would need for a basic CRUD feature automatically. It's kind of magical, but What it's actually doing is setting up a mapping between URLs in the browser and controller actions.
Now, when the user visits a URL, it will trigger one of these actions on the server. That action might go and retrieve some data from your database. The logic for that data is contained in the model, but before we can use the data in the database, we need to run a migration, which will take the code in the model and sync it up with the actual database, and all the data is managed with an object relational mapper called active record.
databases
data management
data
And then finally, you have a Vue, which is an HTML dot ERP file. ERP stands for embedded Ruby, and it allows you to render your data dynamically inside an HTML file.
Overall, this provides a very nice separation of concerns and Rails is very opinionated, which means you can achieve a lot of functionality with very little code. The Scaffold not only retrieves items from the database, but it also that provides UI to create and update that data as well.
programming
But too much magic can also be a bad thing depending on who you ask. And Ruby is not the most popular language in the world, but Python is. What if there is a way we could build web apps like this with Python? And that's where Django comes in. It's also extremely popular and has been used to Old massive sites like Spotify and Bitbucket. When you generate a new Django app, you'll notice the file structure is far less overwhelming than rails, but at the same time it's still very much a batteries included framework.
In addition, your code tends to be a lot more explicit. For example, we have this manage py file that contains the code for the actual command line interface to generate things in the project. We could use it to serve the app locally or generate an app to represent a feature of the website.
programming
software development
software
It also follows the MVC architecture with routes being defined in the urls.py file, and controllers are represented as Python functions and in the views dot py file.
A route points to one of these functions, which itself might want to access data from one of our models. A model is a Python Class represents the structure of data in an SQL database, a k a the object relational mapper. And, finally, we have our HTML templates that allow you to embed Python directly into the code.
modeling
data
data management
That's pretty cool, but one extra superpower of Django is that it has an admin feature built into it directly.
As you define models in your application, you can register them with the admin app to easily manage all of your data in the browser. This is really useful and not something that you'd want to roll out on your own. Python's great and all, but the original server side language of the web was PHP.
databases
data management
software
programming
software development
There have been countless PHP frameworks over the years and high level tools like WordPress, but the most popular one today is Laravel, the PHP framework for web artisans.
To use it, you'll first want to install PHP and a tool called Composer. When I generated my initial app, it took a long time and downloaded a lot of packages. And as you can see, the initial project has a lot of batteries included, even more so than rails.
software development
software
If we look at routes, You can see it not only handles web routes, but also API routes and channels for real time communication with WebSockets. Now, if we We go into the app code, you'll notice it's already been configured with things like user authentication via providers. A provider is like a shared service that you can use anywhere in the application.
In the HTTP directory, we will find our controllers, and just like Rails, we have a class that contains a bunch of different methods that can access data and render a specific template. Now, our database models use a tool called Eloquent ORM, which is based on the same active record pattern as Rails. Now, when it comes to views, PHP is a language that's designed to work with HTML out of the box. Laravel makes it even easier by building on top of PHP with blade templates.
databases
Another cool point about the ecosystem is that they put a lot of thought into how to integrate front end frameworks like React and Vue. It has an adjacent tool called inertia that can bridge the gap between front end and back end frameworks. The next framework we'll look at is Next. Js, which allows us to build a full Stack application entirely with JavaScript. Now, in the JavaScript world, there's a million different options we could have chosen here like Nuxt.
Js, Angular Universal, builtkit, nestjs, adonis, and many others. Maybe I'll make a top ten video just for those. To get started with Next, we run npx create Next App, and that will generate a starter project. Now the one thing you'll notice about Next right off the bat is that it doesn't provide any integration for your database. There are a 1000000 different solutions to choose from, but one of my personal favorites is Prisma. So I'm going to add Prisma to this project. The fact that Next.
animation
databases
video gaming
multimedia
Js doesn't have a database out of the box is a good thing in my opinion.
The JavaScript ecosystem is just way too crazy. It's nice to start with a very good minimal framework and then add whatever database integration you want on top of it. Now that we have a database integrated, let's take a look at the page's directory. One thing that's different about Next is that routing is handled with the file system. Each file defined in the page's directory defines a different URL and the browser. Dynamic routes can be created by wrapping the file name in brackets.
databases
Now, each one of these files exports a React component to define the UI or view. This is actually really convenient because many other frameworks will ultimately want to have some kind of front end framework. Having React fundamentally integrated into the framework or can streamline your productivity big time. Now, things get more complex when you think about data fetching. Normally, in a React app, you're thinking about client side code, but in Next. Js, you can also run server side code with functions like get server side props. This function will run on the server with Node. Js, and as you can see inside of it, we're using Prisma to fetch some items from the database. These items can then be delivered as props to the React component where they're rendered in the UI. Both your server side and client side code is tightly coupled together, which may feel like a bad separation of concerns, but generally speaking it actually works very well. Overall, Next. Js feels very minimal compared to other frameworks in this list, but it does a ton of stuff behind the scenes to simplify the annoying parts of web development.
Now, speaking of simple, we're going to do the polar opposite and see what Java has to offer. Even though Java is a boilerplate driven language for writing instant legacy code, the Spring framework actually makes it very enjoyable to work with. The first thing you'll Notice when building with it is that it's kind of like a create your own adventure story. It has a generator that allows you to start with a framework and you can even use Kotlin or Groovy if you'd like, then you choose all the different dependencies that you want to add to this project.
spring
software development
architecture
Now, even though Java does have a lot of boilerplate, the code pretty much writes itself, and in my opinion, it feels a lot more robust compared to the dynamic languages that we've looked at so far. You'll find the source code way down in this deeply nested folder and it also follows the MVC pattern. The controller is a class and a route is defined using a decorator on each one of its methods.
Spring relies on a lot of metaprogramming to keep your code nice and simple. It feels very much like Angular in the JavaScript world. The database models are based on code with the Java persistence API, AI, then we can use that data in templates using Thymeleaf, where you add these attributes to your HTML to define where your data should go. To be honest though, I didn't have a very good time using Thymeleaf. I believe. And that brings me to Java's arch nemesis, c sharp and the dot net framework or asp.net. It's an open source project maintained by Microsoft and obviously feels very Microsofty, but is extremely popular and reliable. It's evolved very nicely over the years and has modern supporting libraries like Blazor that allow you to build client side apps using WebAssembly and in c sharp. To use it, install the dot net SDK, then generate a new MBC application. I really like the initial project structure. Everything is clearly named and it's Not too overwhelming. And you get all the awesome tooling and static typing like you do in Java. When it comes to routing, the URLs are inferred from the class names in your controllers.
spring
software development
software
microsoft
databases
Here, we have an animals controller, which gives us the animals URL, then we have methods in that class that then represent the next URL segment. The method can take an argument meant to create a dynamic URL. To represent our data, we have a model that is managed by an ORM called the entity core framework.
animals
And then finally, we have our used, which are written in cshtml. At the top of one of these files, you'll notice a model where we can access our data, and we can also declare additional data here in c sharp like a title. It's More verbose than other templating languages, but you get full IntelliSense inside of it, which is really helpful. Overall, dot net is really impressive. The only real Drawback is that you have to sell your soul to the big giant tech corporation. If you wanna take the righteous path, another awesome framework to check out is Phoenix, which is based on the or programming language.
data
technology
documentation
programming
It's a functional language that feels much different than most of the object oriented languages that we've looked at throughout the video. Don't worry, a 100 second video is coming soon. Install Call it, then generate a new project. Like Ruby on Rails, it has a very powerful CLI that can automatically scaffold an entire CRUD application for you.
software
Routing is also very similar to Rails where we have resources that map all the necessary CRUD URLs to the controller. In the controller, we have functions name spaced under a module that access data and render the appropriate template. The model uses an object relational mapper called Ecto, and templates use embedded Elixir, which again feels very similar to Rails. However, Phoenix has a huge advantage in performance because Elixir is a compiled language.
As an added bonus, every app has a built in live dashboard to closely monitor performance. And that brings us to another high performance framework worth checking out, gin, which is powered by the Go language. It Easily wins the best logo award. To get started, we're not going to use a fancy CLI, but instead create a Go project from scratch.
software
software development
Gin is a minimal HTTP framework, and is not concerned with the model view controller architecture. We'll have to figure that out on our own.
It also doesn't contain an ORM for the database, so for That will bring in another package called Gorm. The nice thing about this approach is that we don't really need to follow the MVC conventions of a framework, which is probably overkill for many applications. Instead, we can write some very focused functions, and do things in a way that makes sense for our exact business needs. Like in this app, we just have 2 routes that need to retrieve some data from a database, which itself as modeled with a struct using the ORM. Then Go has its own built in templating language, so we can simply create a couple of template files here in the project and interpolate the values that we you retrieve from the database. The end result is a much smaller code base with a lot more low level control. However, as this application grows bigger, it's going to and harder and harder. So you really kinda have to know what you're doing. And that brings us to our next language, Rust, and the web framework Rocket.
data management
databases
software
software development
data
programming
business
As far as I know, the Rust ecosystem doesn't have a full blown MVC a framework like Rails. And to be honest, I found it very difficult to build a basic application. My approach was to use Rocket for HTTP and routing, then combine it with Diesel, which is a Rust based ORM, and then finally, a templating language to use the data in HTML called AskComma.
I think this is a reasonable approach, but I didn't quite get to a full working demo with It's a systems language that gives you low level control over memory, which the average web application developer doesn't really need. I quickly realized that it would take more time and dedication than I'm willing to give for the tail end of a silly YouTube video. However, there is one Rust based library that I want to bring to your attention called U. It's a component based framework for building web apps with WebAssembly, and it's coming to a Fireshift tutorial near you soon. And that brings us to the final framework in this list, Vapor, which is based on the Swift programming language.
youtube
software
video gaming
software development
computer science
multimedia
This is the only app that I built on my Mac because I found that Anything with Swift just works better on a Mac.
It provides you with a project structure that looks like this. It's well organized with controllers, models, and routes. Routes point to methods in the controller, which can access data from a model. It uses an ORM called fluent, which uses classes along with decorators to model your data. Swift is a very well designed language and I found it very enjoyable to work with for stuff like this. The code is concise and readable yet statically typed with awesome tooling like you would get in Java or c sharp.
systems
software
languages
software development
data management
I also like how it embraces asyncawait when fetching data from your models. For templating, it has an engine called Leaf, which also felt very modern and practical. Now that we look at Vapor, I want to also mention Ktor, which is a Kotlin based web application framework. It's a lot more minimal than something like Spring, but also something worth checking out. And with that, we've looked at 10 full stack frameworks. Now I'm ready to show you the best full stack framework in the world. You're looking at your own reflection in the mirror. Yes, it was you all along. Without you, the framework would be nothing. Actually, no. No. That's that's just dumb. Ruby on Rails is by far the best framework. Nothing else even comes close.
It's like the magic Jordan of web frameworks. Thanks for watching and I will see you in the next one.
This is a web app. This is a web app. This thing here also a web app. Dude, why am I doing this again? I built the same app 10 times with 10 different frameworks using 10 different programming languages. It was a horrible experience, but I learned a lot, and I figured out which full stack framework is the greatest of all time, which will be revealed in dramatic fashion at the end of this video to to maximize the watch time. On this journey, you will meet 10 different server side frameworks, like Rails, Django, Laravel, Spring dot net, Next. Js, Phoenix, Rocket, gin, vapor, and ktor. I realize that's 11, but you don't need to be good at math to be a programmer. This video was insanely difficult because each one of these Frameworks uses a different programming language. For each one of them, we will look at the overall developer experience, including things like setup, routing, database integration, and the overall architecture. Now before we get started, here's a warning. The framework you choose by the end of this video is going to dictate your life for the next 10 years as you grow your startup into a decade unicorn. If your startup fails, it's 100% because you didn't choose the right framework. Reminds me of when my dad made me Choose which of my pet calves to slaughter with my own hands for my 6th birthday. Now before we look at the code, let's first answer the question of what does a web framework actually do. There are 3 main things you should know. 1st, they provide an abstraction over your relational database. They typically have a built in object relational mapper that can migrate code from your preferred programming language into SQL code that can be used by the database. 2nd, they provide routing that can map a URL in the browser to code that you want to run on the server. And 3rd, They provide a way to dynamically insert data from your database directly into HTML for the UI. Together, these three elements make up the model view controller architecture or MVC, which is by far the most common approach when building a full stack web app. The first framework we'll look at is Ruby on Rails, made famous for building some of the biggest companies in the world, like Shopify, Airbnb, and GitHub. Rails was revolutionary when it came out because it dramatically simplified web development compared to or approaches of the day. It's still very popular in 2022, and is kind of a rebel in the web development space. It has adjacent libraries like Hotwire, Stimulus, in Turbo that take an HTML centric approach to building web apps, which goes against the approach you might see in front end frameworks like React, Angular, and at Vue. To get started with Rails, you'll first need to have Ruby installed, then install the rails gem and run rails new. I'm developing this app on a fresh install of wm Linux and I did run-in Some issues with the initial setup. These were errors that could easily be solved with a Google search, but the initial setup was a little more error prone than other frameworks. Once you get the project set up though, the Rails CLI is extremely powerful. Not only does it do things like serve the application with Rails Server, but it can also generate a ton of code for you automatically with commands like scaffold. Now, if we look in the file explorer, you'll notice a bunch of different folders here and that's because Rails is a batteries included framework. It handles your relational database, testing, logging, and a bunch of other stuff. It might look pretty overwhelming at first. Your main application code is contained in the app directory where you'll find folders for models, views, and controllers. The first thing we'll look at is routing and the routes dot rb file. From this file, we can map URLs to actions in a controller. Resources create all the routes we would need for a basic CRUD feature automatically. It's kind of magical, but What it's actually doing is setting up a mapping between URLs in the browser and controller actions. Now, when the user visits a URL, it will trigger one of these actions on the server. That action might go and retrieve some data from your database. The logic for that data is contained in the model, but before we can use the data in the database, we need to run a migration, which will take the code in the model and sync it up with the actual database, and all the data is managed with an object relational mapper called active record. And then finally, you have a Vue, which is an HTML dot ERP file. ERP stands for embedded Ruby, and it allows you to render your data dynamically inside an HTML file. Overall, this provides a very nice separation of concerns and Rails is very opinionated, which means you can achieve a lot of functionality with very little code. The Scaffold not only retrieves items from the database, but it also that provides UI to create and update that data as well. But too much magic can also be a bad thing depending on who you ask. And Ruby is not the most popular language in the world, but Python is. What if there is a way we could build web apps like this with Python? And that's where Django comes in. It's also extremely popular and has been used to Old massive sites like Spotify and Bitbucket. When you generate a new Django app, you'll notice the file structure is far less overwhelming than rails, but at the same time it's still very much a batteries included framework. In addition, your code tends to be a lot more explicit. For example, we have this manage py file that contains the code for the actual command line interface to generate things in the project. We could use it to serve the app locally or generate an app to represent a feature of the website. It also follows the MVC architecture with routes being defined in the urls.py file, and controllers are represented as Python functions and in the views dot py file. A route points to one of these functions, which itself might want to access data from one of our models. A model is a Python Class represents the structure of data in an SQL database, a k a the object relational mapper. And, finally, we have our HTML templates that allow you to embed Python directly into the code. That's pretty cool, but one extra superpower of Django is that it has an admin feature built into it directly. As you define models in your application, you can register them with the admin app to easily manage all of your data in the browser. This is really useful and not something that you'd want to roll out on your own. Python's great and all, but the original server side language of the web was PHP. There have been countless PHP frameworks over the years and high level tools like WordPress, but the most popular one today is Laravel, the PHP framework for web artisans. To use it, you'll first want to install PHP and a tool called Composer. When I generated my initial app, it took a long time and downloaded a lot of packages. And as you can see, the initial project has a lot of batteries included, even more so than rails. If we look at routes, You can see it not only handles web routes, but also API routes and channels for real time communication with WebSockets. Now, if we We go into the app code, you'll notice it's already been configured with things like user authentication via providers. A provider is like a shared service that you can use anywhere in the application. In the HTTP directory, we will find our controllers, and just like Rails, we have a class that contains a bunch of different methods that can access data and render a specific template. Now, our database models use a tool called Eloquent ORM, which is based on the same active record pattern as Rails. Now, when it comes to views, PHP is a language that's designed to work with HTML out of the box. Laravel makes it even easier by building on top of PHP with blade templates. Another cool point about the ecosystem is that they put a lot of thought into how to integrate front end frameworks like React and Vue. It has an adjacent tool called inertia that can bridge the gap between front end and back end frameworks. The next framework we'll look at is Next. Js, which allows us to build a full Stack application entirely with JavaScript. Now, in the JavaScript world, there's a million different options we could have chosen here like Nuxt. Js, Angular Universal, builtkit, nestjs, adonis, and many others. Maybe I'll make a top ten video just for those. To get started with Next, we run npx create Next App, and that will generate a starter project. Now the one thing you'll notice about Next right off the bat is that it doesn't provide any integration for your database. There are a 1000000 different solutions to choose from, but one of my personal favorites is Prisma. So I'm going to add Prisma to this project. The fact that Next. Js doesn't have a database out of the box is a good thing in my opinion. The JavaScript ecosystem is just way too crazy. It's nice to start with a very good minimal framework and then add whatever database integration you want on top of it. Now that we have a database integrated, let's take a look at the page's directory. One thing that's different about Next is that routing is handled with the file system. Each file defined in the page's directory defines a different URL and the browser. Dynamic routes can be created by wrapping the file name in brackets. Now, each one of these files exports a React component to define the UI or view. This is actually really convenient because many other frameworks will ultimately want to have some kind of front end framework. Having React fundamentally integrated into the framework or can streamline your productivity big time. Now, things get more complex when you think about data fetching. Normally, in a React app, you're thinking about client side code, but in Next. Js, you can also run server side code with functions like get server side props. This function will run on the server with Node. Js, and as you can see inside of it, we're using Prisma to fetch some items from the database. These items can then be delivered as props to the React component where they're rendered in the UI. Both your server side and client side code is tightly coupled together, which may feel like a bad separation of concerns, but generally speaking it actually works very well. Overall, Next. Js feels very minimal compared to other frameworks in this list, but it does a ton of stuff behind the scenes to simplify the annoying parts of web development. Now, speaking of simple, we're going to do the polar opposite and see what Java has to offer. Even though Java is a boilerplate driven language for writing instant legacy code, the Spring framework actually makes it very enjoyable to work with. The first thing you'll Notice when building with it is that it's kind of like a create your own adventure story. It has a generator that allows you to start with a framework and you can even use Kotlin or Groovy if you'd like, then you choose all the different dependencies that you want to add to this project. Now, even though Java does have a lot of boilerplate, the code pretty much writes itself, and in my opinion, it feels a lot more robust compared to the dynamic languages that we've looked at so far. You'll find the source code way down in this deeply nested folder and it also follows the MVC pattern. The controller is a class and a route is defined using a decorator on each one of its methods. Spring relies on a lot of metaprogramming to keep your code nice and simple. It feels very much like Angular in the JavaScript world. The database models are based on code with the Java persistence API, AI, then we can use that data in templates using Thymeleaf, where you add these attributes to your HTML to define where your data should go. To be honest though, I didn't have a very good time using Thymeleaf. I believe. And that brings me to Java's arch nemesis, c sharp and the dot net framework or asp.net. It's an open source project maintained by Microsoft and obviously feels very Microsofty, but is extremely popular and reliable. It's evolved very nicely over the years and has modern supporting libraries like Blazor that allow you to build client side apps using WebAssembly and in c sharp. To use it, install the dot net SDK, then generate a new MBC application. I really like the initial project structure. Everything is clearly named and it's Not too overwhelming. And you get all the awesome tooling and static typing like you do in Java. When it comes to routing, the URLs are inferred from the class names in your controllers. Here, we have an animals controller, which gives us the animals URL, then we have methods in that class that then represent the next URL segment. The method can take an argument meant to create a dynamic URL. To represent our data, we have a model that is managed by an ORM called the entity core framework. And then finally, we have our used, which are written in cshtml. At the top of one of these files, you'll notice a model where we can access our data, and we can also declare additional data here in c sharp like a title. It's More verbose than other templating languages, but you get full IntelliSense inside of it, which is really helpful. Overall, dot net is really impressive. The only real Drawback is that you have to sell your soul to the big giant tech corporation. If you wanna take the righteous path, another awesome framework to check out is Phoenix, which is based on the or programming language. It's a functional language that feels much different than most of the object oriented languages that we've looked at throughout the video. Don't worry, a 100 second video is coming soon. Install Call it, then generate a new project. Like Ruby on Rails, it has a very powerful CLI that can automatically scaffold an entire CRUD application for you. Routing is also very similar to Rails where we have resources that map all the necessary CRUD URLs to the controller. In the controller, we have functions name spaced under a module that access data and render the appropriate template. The model uses an object relational mapper called Ecto, and templates use embedded Elixir, which again feels very similar to Rails. However, Phoenix has a huge advantage in performance because Elixir is a compiled language. As an added bonus, every app has a built in live dashboard to closely monitor performance. And that brings us to another high performance framework worth checking out, gin, which is powered by the Go language. It Easily wins the best logo award. To get started, we're not going to use a fancy CLI, but instead create a Go project from scratch. Gin is a minimal HTTP framework, and is not concerned with the model view controller architecture. We'll have to figure that out on our own. It also doesn't contain an ORM for the database, so for That will bring in another package called Gorm. The nice thing about this approach is that we don't really need to follow the MVC conventions of a framework, which is probably overkill for many applications. Instead, we can write some very focused functions, and do things in a way that makes sense for our exact business needs. Like in this app, we just have 2 routes that need to retrieve some data from a database, which itself as modeled with a struct using the ORM. Then Go has its own built in templating language, so we can simply create a couple of template files here in the project and interpolate the values that we you retrieve from the database. The end result is a much smaller code base with a lot more low level control. However, as this application grows bigger, it's going to and harder and harder. So you really kinda have to know what you're doing. And that brings us to our next language, Rust, and the web framework Rocket. As far as I know, the Rust ecosystem doesn't have a full blown MVC a framework like Rails. And to be honest, I found it very difficult to build a basic application. My approach was to use Rocket for HTTP and routing, then combine it with Diesel, which is a Rust based ORM, and then finally, a templating language to use the data in HTML called AskComma. I think this is a reasonable approach, but I didn't quite get to a full working demo with It's a systems language that gives you low level control over memory, which the average web application developer doesn't really need. I quickly realized that it would take more time and dedication than I'm willing to give for the tail end of a silly YouTube video. However, there is one Rust based library that I want to bring to your attention called U. It's a component based framework for building web apps with WebAssembly, and it's coming to a Fireshift tutorial near you soon. And that brings us to the final framework in this list, Vapor, which is based on the Swift programming language. This is the only app that I built on my Mac because I found that Anything with Swift just works better on a Mac. It provides you with a project structure that looks like this. It's well organized with controllers, models, and routes. Routes point to methods in the controller, which can access data from a model. It uses an ORM called fluent, which uses classes along with decorators to model your data. Swift is a very well designed language and I found it very enjoyable to work with for stuff like this. The code is concise and readable yet statically typed with awesome tooling like you would get in Java or c sharp. I also like how it embraces asyncawait when fetching data from your models. For templating, it has an engine called Leaf, which also felt very modern and practical. Now that we look at Vapor, I want to also mention Ktor, which is a Kotlin based web application framework. It's a lot more minimal than something like Spring, but also something worth checking out. And with that, we've looked at 10 full stack frameworks. Now I'm ready to show you the best full stack framework in the world. You're looking at your own reflection in the mirror. Yes, it was you all along. Without you, the framework would be nothing. Actually, no. No. That's that's just dumb. Ruby on Rails is by far the best framework. Nothing else even comes close. It's like the magic Jordan of web frameworks. Thanks for watching and I will see you in the next one.
This
this
is
is
a
a
web
web
app.
app
This
this
is
is
a
a
web
web
app.
app
This
this
thing
thing
here
here
also
also
a
a
web
web
app.
app
Dude,
dude
why
why
am
am
I
i
doing
doing
this
this
again?
again
I
i
built
built
the
the
same
same
app
app
10
10
times
times
with
with
10
10
different
different
frameworks
frameworks
using
using
10
10
different
different
programming
programming
languages.
languages
It
it
was
was
a
a
horrible
horrible
experience,
experience
but
but
I
i
learned
learned
a
a
lot,
lot
and
and
I
i
figured
figured
out
out
which
which
full
full
stack
stack
framework
framework
is
is
the
the
greatest
greatest
of
of
all
all
time,
time
which
which
will
will
be
be
revealed
revealed
in
in
dramatic
dramatic
fashion
fashion
at
at
the
the
end
end
of
of
this
this
video
video
to
to
to
to
maximize
maximize
the
the
watch
watch
time.
time
On
on
this
this
journey,
journey
you
you
will
will
meet
meet
10
10
different
different
server
server
side
side
frameworks,
frameworks
like
like
Rails,
rails
Django,
django
Laravel,
laravel
Spring
spring
dot
dot
net,
net
Next.
next
Js,
js
Phoenix,
phoenix
Rocket,
rocket
gin,
gin
vapor,
vapor
and
and
ktor.
ktor
I
i
realize
realize
that's
that's
11,
11
but
but
you
you
don't
don't
need
need
to
to
be
be
good
good
at
at
math
math
to
to
be
be
a
a
programmer.
programmer
This
this
video
video
was
was
insanely
insanely
difficult
difficult
because
because
each
each
one
one
of
of
these
these
Frameworks
frameworks
uses
uses
a
a
different
different
programming
programming
language.
language
For
for
each
each
one
one
of
of
them,
them
we
we
will
will
look
look
at
at
the
the
overall
overall
developer
developer
experience,
experience
including
including
things
things
like
like
setup,
setup
routing,
routing
database
database
integration,
integration
and
and
the
the
overall
overall
architecture.
architecture
Now
now
before
before
we
we
get
get
started,
started
here's
here's
a
a
warning.
warning
The
the
framework
framework
you
you
choose
choose
by
by
the
the
end
end
of
of
this
this
video
video
is
is
going
going
to
to
dictate
dictate
your
your
life
life
for
for
the
the
next
next
10
10
years
years
as
as
you
you
grow
grow
your
your
startup
startup
into
into
a
a
decade
decade
unicorn.
unicorn
If
if
your
your
startup
startup
fails,
fails
it's
it's
100%
100%
because
because
you
you
didn't
didn't
choose
choose
the
the
right
right
framework.
framework
Reminds
reminds
me
me
of
of
when
when
my
my
dad
dad
made
made
me
me
Choose
choose
which
which
of
of
my
my
pet
pet
calves
calves
to
to
slaughter
slaughter
with
with
my
my
own
own
hands
hands
for
for
my
my
6th
6th
birthday.
birthday
Now
now
before
before
we
we
look
look
at
at
the
the
code,
code
let's
let's
first
first
answer
answer
the
the
question
question
of
of
what
what
does
does
a
a
web
web
framework
framework
actually
actually
do.
do
There
there
are
are
3
3
main
main
things
things
you
you
should
should
know.
know
1st,
1st
they
they
provide
provide
an
an
abstraction
abstraction
over
over
your
your
relational
relational
database.
database
They
they
typically
typically
have
have
a
a
built
built
in
in
object
object
relational
relational
mapper
mapper
that
that
can
can
migrate
migrate
code
code
from
from
your
your
preferred
preferred
programming
programming
language
language
into
into
SQL
sql
code
code
that
that
can
can
be
be
used
used
by
by
the
the
database.
database
2nd,
2nd
they
they
provide
provide
routing
routing
that
that
can
can
map
map
a
a
URL
url
in
in
the
the
browser
browser
to
to
code
code
that
that
you
you
want
want
to
to
run
run
on
on
the
the
server.
server
And
and
3rd,
3rd
They
they
provide
provide
a
a
way
way
to
to
dynamically
dynamically
insert
insert
data
data
from
from
your
your
database
database
directly
directly
into
into
HTML
html
for
for
the
the
UI.
ui
Together,
together
these
these
three
three
elements
elements
make
make
up
up
the
the
model
model
view
view
controller
controller
architecture
architecture
or
or
MVC,
mvc
which
which
is
is
by
by
far
far
the
the
most
most
common
common
approach
approach
when
when
building
building
a
a
full
full
stack
stack
web
web
app.
app
The
the
first
first
framework
framework
we'll
we'll
look
look
at
at
is
is
Ruby
ruby
on
on
Rails,
rails
made
made
famous
famous
for
for
building
building
some
some
of
of
the
the
biggest
biggest
companies
companies
in
in
the
the
world,
world
like
like
Shopify,
shopify
Airbnb,
airbnb
and
and
GitHub.
github
Rails
rails
was
was
revolutionary
revolutionary
when
when
it
it
came
came
out
out
because
because
it
it
dramatically
dramatically
simplified
simplified
web
web
development
development
compared
compared
to
to
or
or
approaches
approaches
of
of
the
the
day.
day
It's
it's
still
still
very
very
popular
popular
in
in
2022,
2022
and
and
is
is
kind
kind
of
of
a
a
rebel
rebel
in
in
the
the
web
web
development
development
space.
space
It
it
has
has
adjacent
adjacent
libraries
libraries
like
like
Hotwire,
hotwire
Stimulus,
stimulus
in
in
Turbo
turbo
that
that
take
take
an
an
HTML
html
centric
centric
approach
approach
to
to
building
building
web
web
apps,
apps
which
which
goes
goes
against
against
the
the
approach
approach
you
you
might
might
see
see
in
in
front
front
end
end
frameworks
frameworks
like
like
React,
react
Angular,
angular
and
and
at
at
Vue.
vue
To
to
get
get
started
started
with
with
Rails,
rails
you'll
you'll
first
first
need
need
to
to
have
have
Ruby
ruby
installed,
installed
then
then
install
install
the
the
rails
rails
gem
gem
and
and
run
run
rails
rails
new.
new
I'm
i'm
developing
developing
this
this
app
app
on
on
a
a
fresh
fresh
install
install
of
of
wm
wm
Linux
linux
and
and
I
i
did
did
run-in
run-in
Some
some
issues
issues
with
with
the
the
initial
initial
setup.
setup
These
these
were
were
errors
errors
that
that
could
could
easily
easily
be
be
solved
solved
with
with
a
a
Google
google
search,
search
but
but
the
the
initial
initial
setup
setup
was
was
a
a
little
little
more
more
error
error
prone
prone
than
than
other
other
frameworks.
frameworks
Once
once
you
you
get
get
the
the
project
project
set
set
up
up
though,
though
the
the
Rails
rails
CLI
cli
is
is
extremely
extremely
powerful.
powerful
Not
not
only
only
does
does
it
it
do
do
things
things
like
like
serve
serve
the
the
application
application
with
with
Rails
rails
Server,
server
but
but
it
it
can
can
also
also
generate
generate
a
a
ton
ton
of
of
code
code
for
for
you
you
automatically
automatically
with
with
commands
commands
like
like
scaffold.
scaffold
Now,
now
if
if
we
we
look
look
in
in
the
the
file
file
explorer,
explorer
you'll
you'll
notice
notice
a
a
bunch
bunch
of
of
different
different
folders
folders
here
here
and
and
that's
that's
because
because
Rails
rails
is
is
a
a
batteries
batteries
included
included
framework.
framework
It
it
handles
handles
your
your
relational
relational
database,
database
testing,
testing
logging,
logging
and
and
a
a
bunch
bunch
of
of
other
other
stuff.
stuff
It
it
might
might
look
look
pretty
pretty
overwhelming
overwhelming
at
at
first.
first
Your
your
main
main
application
application
code
code
is
is
contained
contained
in
in
the
the
app
app
directory
directory
where
where
you'll
you'll
find
find
folders
folders
for
for
models,
models
views,
views
and
and
controllers.
controllers
The
the
first
first
thing
thing
we'll
we'll
look
look
at
at
is
is
routing
routing
and
and
the
the
routes
routes
dot
dot
rb
rb
file.
file
From
from
this
this
file,
file
we
we
can
can
map
map
URLs
urls
to
to
actions
actions
in
in
a
a
controller.
controller
Resources
resources
create
create
all
all
the
the
routes
routes
we
we
would
would
need
need
for
for
a
a
basic
basic
CRUD
crud
feature
feature
automatically.
automatically
It's
it's
kind
kind
of
of
magical,
magical
but
but
What
what
it's
it's
actually
actually
doing
doing
is
is
setting
setting
up
up
a
a
mapping
mapping
between
between
URLs
urls
in
in
the
the
browser
browser
and
and
controller
controller
actions.
actions
Now,
now
when
when
the
the
user
user
visits
visits
a
a
URL,
url
it
it
will
will
trigger
trigger
one
one
of
of
these
these
actions
actions
on
on
the
the
server.
server
That
that
action
action
might
might
go
go
and
and
retrieve
retrieve
some
some
data
data
from
from
your
your
database.
database
The
the
logic
logic
for
for
that
that
data
data
is
is
contained
contained
in
in
the
the
model,
model
but
but
before
before
we
we
can
can
use
use
the
the
data
data
in
in
the
the
database,
database
we
we
need
need
to
to
run
run
a
a
migration,
migration
which
which
will
will
take
take
the
the
code
code
in
in
the
the
model
model
and
and
sync
sync
it
it
up
up
with
with
the
the
actual
actual
database,
database
and
and
all
all
the
the
data
data
is
is
managed
managed
with
with
an
an
object
object
relational
relational
mapper
mapper
called
called
active
active
record.
record
And
and
then
then
finally,
finally
you
you
have
have
a
a
Vue,
vue
which
which
is
is
an
an
HTML
html
dot
dot
ERP
erp
file.
file
ERP
erp
stands
stands
for
for
embedded
embedded
Ruby,
ruby
and
and
it
it
allows
allows
you
you
to
to
render
render
your
your
data
data
dynamically
dynamically
inside
inside
an
an
HTML
html
file.
file
Overall,
overall
this
this
provides
provides
a
a
very
very
nice
nice
separation
separation
of
of
concerns
concerns
and
and
Rails
rails
is
is
very
very
opinionated,
opinionated
which
which
means
means
you
you
can
can
achieve
achieve
a
a
lot
lot
of
of
functionality
functionality
with
with
very
very
little
little
code.
code
The
the
Scaffold
scaffold
not
not
only
only
retrieves
retrieves
items
items
from
from
the
the
database,
database
but
but
it
it
also
also
that
that
provides
provides
UI
ui
to
to
create
create
and
and
update
update
that
that
data
data
as
as
well.
well
But
but
too
too
much
much
magic
magic
can
can
also
also
be
be
a
a
bad
bad
thing
thing
depending
depending
on
on
who
who
you
you
ask.
ask
And
and
Ruby
ruby
is
is
not
not
the
the
most
most
popular
popular
language
language
in
in
the
the
world,
world
but
but
Python
python
is.
is
What
what
if
if
there
there
is
is
a
a
way
way
we
we
could
could
build
build
web
web
apps
apps
like
like
this
this
with
with
Python?
python
And
and
that's
that's
where
where
Django
django
comes
comes
in.
in
It's
it's
also
also
extremely
extremely
popular
popular
and
and
has
has
been
been
used
used
to
to
Old
old
massive
massive
sites
sites
like
like
Spotify
spotify
and
and
Bitbucket.
bitbucket
When
when
you
you
generate
generate
a
a
new
new
Django
django
app,
app
you'll
you'll
notice
notice
the
the
file
file
structure
structure
is
is
far
far
less
less
overwhelming
overwhelming
than
than
rails,
rails
but
but
at
at
the
the
same
same
time
time
it's
it's
still
still
very
very
much
much
a
a
batteries
batteries
included
included
framework.
framework
In
in
addition,
addition
your
your
code
code
tends
tends
to
to
be
be
a
a
lot
lot
more
more
explicit.
explicit
For
for
example,
example
we
we
have
have
this
this
manage
manage
py
py
file
file
that
that
contains
contains
the
the
code
code
for
for
the
the
actual
actual
command
command
line
line
interface
interface
to
to
generate
generate
things
things
in
in
the
the
project.
project
We
we
could
could
use
use
it
it
to
to
serve
serve
the
the
app
app
locally
locally
or
or
generate
generate
an
an
app
app
to
to
represent
represent
a
a
feature
feature
of
of
the
the
website.
website
It
it
also
also
follows
follows
the
the
MVC
mvc
architecture
architecture
with
with
routes
routes
being
being
defined
defined
in
in
the
the
urls.py
urls.py
file,
file
and
and
controllers
controllers
are
are
represented
represented
as
as
Python
python
functions
functions
and
and
in
in
the
the
views
views
dot
dot
py
py
file.
file
A
a
route
route
points
points
to
to
one
one
of
of
these
these
functions,
functions
which
which
itself
itself
might
might
want
want
to
to
access
access
data
data
from
from
one
one
of
of
our
our
models.
models
A
a
model
model
is
is
a
a
Python
python
Class
class
represents
represents
the
the
structure
structure
of
of
data
data
in
in
an
an
SQL
sql
database,
database
a
a
k
k
a
a
the
the
object
object
relational
relational
mapper.
mapper
And,
and
finally,
finally
we
we
have
have
our
our
HTML
html
templates
templates
that
that
allow
allow
you
you
to
to
embed
embed
Python
python
directly
directly
into
into
the
the
code.
code
That's
that's
pretty
pretty
cool,
cool
but
but
one
one
extra
extra
superpower
superpower
of
of
Django
django
is
is
that
that
it
it
has
has
an
an
admin
admin
feature
feature
built
built
into
into
it
it
directly.
directly
As
as
you
you
define
define
models
models
in
in
your
your
application,
application
you
you
can
can
register
register
them
them
with
with
the
the
admin
admin
app
app
to
to
easily
easily
manage
manage
all
all
of
of
your
your
data
data
in
in
the
the
browser.
browser
This
this
is
is
really
really
useful
useful
and
and
not
not
something
something
that
that
you'd
you'd
want
want
to
to
roll
roll
out
out
on
on
your
your
own.
own
Python's
python's
great
great
and
and
all,
all
but
but
the
the
original
original
server
server
side
side
language
language
of
of
the
the
web
web
was
was
PHP.
php
There
there
have
have
been
been
countless
countless
PHP
php
frameworks
frameworks
over
over
the
the
years
years
and
and
high
high
level
level
tools
tools
like
like
WordPress,
wordpress
but
but
the
the
most
most
popular
popular
one
one
today
today
is
is
Laravel,
laravel
the
the
PHP
php
framework
framework
for
for
web
web
artisans.
artisans
To
to
use
use
it,
it
you'll
you'll
first
first
want
want
to
to
install
install
PHP
php
and
and
a
a
tool
tool
called
called
Composer.
composer
When
when
I
i
generated
generated
my
my
initial
initial
app,
app
it
it
took
took
a
a
long
long
time
time
and
and
downloaded
downloaded
a
a
lot
lot
of
of
packages.
packages
And
and
as
as
you
you
can
can
see,
see
the
the
initial
initial
project
project
has
has
a
a
lot
lot
of
of
batteries
batteries
included,
included
even
even
more
more
so
so
than
than
rails.
rails
If
if
we
we
look
look
at
at
routes,
routes
You
you
can
can
see
see
it
it
not
not
only
only
handles
handles
web
web
routes,
routes
but
but
also
also
API
api
routes
routes
and
and
channels
channels
for
for
real
real
time
time
communication
communication
with
with
WebSockets.
websockets
Now,
now
if
if
we
we
We
we
go
go
into
into
the
the
app
app
code,
code
you'll
you'll
notice
notice
it's
it's
already
already
been
been
configured
configured
with
with
things
things
like
like
user
user
authentication
authentication
via
via
providers.
providers
A
a
provider
provider
is
is
like
like
a
a
shared
shared
service
service
that
that
you
you
can
can
use
use
anywhere
anywhere
in
in
the
the
application.
application
In
in
the
the
HTTP
http
directory,
directory
we
we
will
will
find
find
our
our
controllers,
controllers
and
and
just
just
like
like
Rails,
rails
we
we
have
have
a
a
class
class
that
that
contains
contains
a
a
bunch
bunch
of
of
different
different
methods
methods
that
that
can
can
access
access
data
data
and
and
render
render
a
a
specific
specific
template.
template
Now,
now
our
our
database
database
models
models
use
use
a
a
tool
tool
called
called
Eloquent
eloquent
ORM,
orm
which
which
is
is
based
based
on
on
the
the
same
same
active
active
record
record
pattern
pattern
as
as
Rails.
rails
Now,
now
when
when
it
it
comes
comes
to
to
views,
views
PHP
php
is
is
a
a
language
language
that's
that's
designed
designed
to
to
work
work
with
with
HTML
html
out
out
of
of
the
the
box.
box
Laravel
laravel
makes
makes
it
it
even
even
easier
easier
by
by
building
building
on
on
top
top
of
of
PHP
php
with
with
blade
blade
templates.
templates
Another
another
cool
cool
point
point
about
about
the
the
ecosystem
ecosystem
is
is
that
that
they
they
put
put
a
a
lot
lot
of
of
thought
thought
into
into
how
how
to
to
integrate
integrate
front
front
end
end
frameworks
frameworks
like
like
React
react
and
and
Vue.
vue
It
it
has
has
an
an
adjacent
adjacent
tool
tool
called
called
inertia
inertia
that
that
can
can
bridge
bridge
the
the
gap
gap
between
between
front
front
end
end
and
and
back
back
end
end
frameworks.
frameworks
The
the
next
next
framework
framework
we'll
we'll
look
look
at
at
is
is
Next.
next
Js,
js
which
which
allows
allows
us
us
to
to
build
build
a
a
full
full
Stack
stack
application
application
entirely
entirely
with
with
JavaScript.
javascript
Now,
now
in
in
the
the
JavaScript
javascript
world,
world
there's
there's
a
a
million
million
different
different
options
options
we
we
could
could
have
have
chosen
chosen
here
here
like
like
Nuxt.
nuxt
Js,
js
Angular
angular
Universal,
universal
builtkit,
builtkit
nestjs,
nestjs
adonis,
adonis
and
and
many
many
others.
others
Maybe
maybe
I'll
i'll
make
make
a
a
top
top
ten
ten
video
video
just
just
for
for
those.
those
To
to
get
get
started
started
with
with
Next,
next
we
we
run
run
npx
npx
create
create
Next
next
App,
app
and
and
that
that
will
will
generate
generate
a
a
starter
starter
project.
project
Now
now
the
the
one
one
thing
thing
you'll
you'll
notice
notice
about
about
Next
next
right
right
off
off
the
the
bat
bat
is
is
that
that
it
it
doesn't
doesn't
provide
provide
any
any
integration
integration
for
for
your
your
database.
database
There
there
are
are
a
a
1000000
1000000
different
different
solutions
solutions
to
to
choose
choose
from,
from
but
but
one
one
of
of
my
my
personal
personal
favorites
favorites
is
is
Prisma.
prisma
So
so
I'm
i'm
going
going
to
to
add
add
Prisma
prisma
to
to
this
this
project.
project
The
the
fact
fact
that
that
Next.
next
Js
js
doesn't
doesn't
have
have
a
a
database
database
out
out
of
of
the
the
box
box
is
is
a
a
good
good
thing
thing
in
in
my
my
opinion.
opinion
The
the
JavaScript
javascript
ecosystem
ecosystem
is
is
just
just
way
way
too
too
crazy.
crazy
It's
it's
nice
nice
to
to
start
start
with
with
a
a
very
very
good
good
minimal
minimal
framework
framework
and
and
then
then
add
add
whatever
whatever
database
database
integration
integration
you
you
want
want
on
on
top
top
of
of
it.
it
Now
now
that
that
we
we
have
have
a
a
database
database
integrated,
integrated
let's
let's
take
take
a
a
look
look
at
at
the
the
page's
page's
directory.
directory
One
one
thing
thing
that's
that's
different
different
about
about
Next
next
is
is
that
that
routing
routing
is
is
handled
handled
with
with
the
the
file
file
system.
system
Each
each
file
file
defined
defined
in
in
the
the
page's
page's
directory
directory
defines
defines
a
a
different
different
URL
url
and
and
the
the
browser.
browser
Dynamic
dynamic
routes
routes
can
can
be
be
created
created
by
by
wrapping
wrapping
the
the
file
file
name
name
in
in
brackets.
brackets
Now,
now
each
each
one
one
of
of
these
these
files
files
exports
exports
a
a
React
react
component
component
to
to
define
define
the
the
UI
ui
or
or
view.
view
This
this
is
is
actually
actually
really
really
convenient
convenient
because
because
many
many
other
other
frameworks
frameworks
will
will
ultimately
ultimately
want
want
to
to
have
have
some
some
kind
kind
of
of
front
front
end
end
framework.
framework
Having
having
React
react
fundamentally
fundamentally
integrated
integrated
into
into
the
the
framework
framework
or
or
can
can
streamline
streamline
your
your
productivity
productivity
big
big
time.
time
Now,
now
things
things
get
get
more
more
complex
complex
when
when
you
you
think
think
about
about
data
data
fetching.
fetching
Normally,
normally
in
in
a
a
React
react
app,
app
you're
you're
thinking
thinking
about
about
client
client
side
side
code,
code
but
but
in
in
Next.
next
Js,
js
you
you
can
can
also
also
run
run
server
server
side
side
code
code
with
with
functions
functions
like
like
get
get
server
server
side
side
props.
props
This
this
function
function
will
will
run
run
on
on
the
the
server
server
with
with
Node.
node
Js,
js
and
and
as
as
you
you
can
can
see
see
inside
inside
of
of
it,
it
we're
we're
using
using
Prisma
prisma
to
to
fetch
fetch
some
some
items
items
from
from
the
the
database.
database
These
these
items
items
can
can
then
then
be
be
delivered
delivered
as
as
props
props
to
to
the
the
React
react
component
component
where
where
they're
they're
rendered
rendered
in
in
the
the
UI.
ui
Both
both
your
your
server
server
side
side
and
and
client
client
side
side
code
code
is
is
tightly
tightly
coupled
coupled
together,
together
which
which
may
may
feel
feel
like
like
a
a
bad
bad
separation
separation
of
of
concerns,
concerns
but
but
generally
generally
speaking
speaking
it
it
actually
actually
works
works
very
very
well.
well
Overall,
overall
Next.
next
Js
js
feels
feels
very
very
minimal
minimal
compared
compared
to
to
other
other
frameworks
frameworks
in
in
this
this
list,
list
but
but
it
it
does
does
a
a
ton
ton
of
of
stuff
stuff
behind
behind
the
the
scenes
scenes
to
to
simplify
simplify
the
the
annoying
annoying
parts
parts
of
of
web
web
development.
development
Now,
now
speaking
speaking
of
of
simple,
simple
we're
we're
going
going
to
to
do
do
the
the
polar
polar
opposite
opposite
and
and
see
see
what
what
Java
java
has
has
to
to
offer.
offer
Even
even
though
though
Java
java
is
is
a
a
boilerplate
boilerplate
driven
driven
language
language
for
for
writing
writing
instant
instant
legacy
legacy
code,
code
the
the
Spring
spring
framework
framework
actually
actually
makes
makes
it
it
very
very
enjoyable
enjoyable
to
to
work
work
with.
with
The
the
first
first
thing
thing
you'll
you'll
Notice
notice
when
when
building
building
with
with
it
it
is
is
that
that
it's
it's
kind
kind
of
of
like
like
a
a
create
create
your
your
own
own
adventure
adventure
story.
story
It
it
has
has
a
a
generator
generator
that
that
allows
allows
you
you
to
to
start
start
with
with
a
a
framework
framework
and
and
you
you
can
can
even
even
use
use
Kotlin
kotlin
or
or
Groovy
groovy
if
if
you'd
you'd
like,
like
then
then
you
you
choose
choose
all
all
the
the
different
different
dependencies
dependencies
that
that
you
you
want
want
to
to
add
add
to
to
this
this
project.
project
Now,
now
even
even
though
though
Java
java
does
does
have
have
a
a
lot
lot
of
of
boilerplate,
boilerplate
the
the
code
code
pretty
pretty
much
much
writes
writes
itself,
itself
and
and
in
in
my
my
opinion,
opinion
it
it
feels
feels
a
a
lot
lot
more
more
robust
robust
compared
compared
to
to
the
the
dynamic
dynamic
languages
languages
that
that
we've
we've
looked
looked
at
at
so
so
far.
far
You'll
you'll
find
find
the
the
source
source
code
code
way
way
down
down
in
in
this
this
deeply
deeply
nested
nested
folder
folder
and
and
it
it
also
also
follows
follows
the
the
MVC
mvc
pattern.
pattern
The
the
controller
controller
is
is
a
a
class
class
and
and
a
a
route
route
is
is
defined
defined
using
using
a
a
decorator
decorator
on
on
each
each
one
one
of
of
its
its
methods.
methods
Spring
spring
relies
relies
on
on
a
a
lot
lot
of
of
metaprogramming
metaprogramming
to
to
keep
keep
your
your
code
code
nice
nice
and
and
simple.
simple
It
it
feels
feels
very
very
much
much
like
like
Angular
angular
in
in
the
the
JavaScript
javascript
world.
world
The
the
database
database
models
models
are
are
based
based
on
on
code
code
with
with
the
the
Java
java
persistence
persistence
API,
api
AI,
ai
then
then
we
we
can
can
use
use
that
that
data
data
in
in
templates
templates
using
using
Thymeleaf,
thymeleaf
where
where
you
you
add
add
these
these
attributes
attributes
to
to
your
your
HTML
html
to
to
define
define
where
where
your
your
data
data
should
should
go.
go
To
to
be
be
honest
honest
though,
though
I
i
didn't
didn't
have
have
a
a
very
very
good
good
time
time
using
using
Thymeleaf.
thymeleaf
I
i
believe.
believe
And
and
that
that
brings
brings
me
me
to
to
Java's
java's
arch
arch
nemesis,
nemesis
c
c
sharp
sharp
and
and
the
the
dot
dot
net
net
framework
framework
or
or
asp.net.
asp.net
It's
it's
an
an
open
open
source
source
project
project
maintained
maintained
by
by
Microsoft
microsoft
and
and
obviously
obviously
feels
feels
very
very
Microsofty,
microsofty
but
but
is
is
extremely
extremely
popular
popular
and
and
reliable.
reliable
It's
it's
evolved
evolved
very
very
nicely
nicely
over
over
the
the
years
years
and
and
has
has
modern
modern
supporting
supporting
libraries
libraries
like
like
Blazor
blazor
that
that
allow
allow
you
you
to
to
build
build
client
client
side
side
apps
apps
using
using
WebAssembly
webassembly
and
and
in
in
c
c
sharp.
sharp
To
to
use
use
it,
it
install
install
the
the
dot
dot
net
net
SDK,
sdk
then
then
generate
generate
a
a
new
new
MBC
mbc
application.
application
I
i
really
really
like
like
the
the
initial
initial
project
project
structure.
structure
Everything
everything
is
is
clearly
clearly
named
named
and
and
it's
it's
Not
not
too
too
overwhelming.
overwhelming
And
and
you
you
get
get
all
all
the
the
awesome
awesome
tooling
tooling
and
and
static
static
typing
typing
like
like
you
you
do
do
in
in
Java.
java
When
when
it
it
comes
comes
to
to
routing,
routing
the
the
URLs
urls
are
are
inferred
inferred
from
from
the
the
class
class
names
names
in
in
your
your
controllers.
controllers
Here,
here
we
we
have
have
an
an
animals
animals
controller,
controller
which
which
gives
gives
us
us
the
the
animals
animals
URL,
url
then
then
we
we
have
have
methods
methods
in
in
that
that
class
class
that
that
then
then
represent
represent
the
the
next
next
URL
url
segment.
segment
The
the
method
method
can
can
take
take
an
an
argument
argument
meant
meant
to
to
create
create
a
a
dynamic
dynamic
URL.
url
To
to
represent
represent
our
our
data,
data
we
we
have
have
a
a
model
model
that
that
is
is
managed
managed
by
by
an
an
ORM
orm
called
called
the
the
entity
entity
core
core
framework.
framework
And
and
then
then
finally,
finally
we
we
have
have
our
our
used,
used
which
which
are
are
written
written
in
in
cshtml.
cshtml
At
at
the
the
top
top
of
of
one
one
of
of
these
these
files,
files
you'll
you'll
notice
notice
a
a
model
model
where
where
we
we
can
can
access
access
our
our
data,
data
and
and
we
we
can
can
also
also
declare
declare
additional
additional
data
data
here
here
in
in
c
c
sharp
sharp
like
like
a
a
title.
title
It's
it's
More
more
verbose
verbose
than
than
other
other
templating
templating
languages,
languages
but
but
you
you
get
get
full
full
IntelliSense
intellisense
inside
inside
of
of
it,
it
which
which
is
is
really
really
helpful.
helpful
Overall,
overall
dot
dot
net
net
is
is
really
really
impressive.
impressive
The
the
only
only
real
real
Drawback
drawback
is
is
that
that
you
you
have
have
to
to
sell
sell
your
your
soul
soul
to
to
the
the
big
big
giant
giant
tech
tech
corporation.
corporation
If
if
you
you
wanna
wanna
take
take
the
the
righteous
righteous
path,
path
another
another
awesome
awesome
framework
framework
to
to
check
check
out
out
is
is
Phoenix,
phoenix
which
which
is
is
based
based
on
on
the
the
or
or
programming
programming
language.
language
It's
it's
a
a
functional
functional
language
language
that
that
feels
feels
much
much
different
different
than
than
most
most
of
of
the
the
object
object
oriented
oriented
languages
languages
that
that
we've
we've
looked
looked
at
at
throughout
throughout
the
the
video.
video
Don't
don't
worry,
worry
a
a
100
100
second
second
video
video
is
is
coming
coming
soon.
soon
Install
install
Call
call
it,
it
then
then
generate
generate
a
a
new
new
project.
project
Like
like
Ruby
ruby
on
on
Rails,
rails
it
it
has
has
a
a
very
very
powerful
powerful
CLI
cli
that
that
can
can
automatically
automatically
scaffold
scaffold
an
an
entire
entire
CRUD
crud
application
application
for
for
you.
you
Routing
routing
is
is
also
also
very
very
similar
similar
to
to
Rails
rails
where
where
we
we
have
have
resources
resources
that
that
map
map
all
all
the
the
necessary
necessary
CRUD
crud
URLs
urls
to
to
the
the
controller.
controller
In
in
the
the
controller,
controller
we
we
have
have
functions
functions
name
name
spaced
spaced
under
under
a
a
module
module
that
that
access
access
data
data
and
and
render
render
the
the
appropriate
appropriate
template.
template
The
the
model
model
uses
uses
an
an
object
object
relational
relational
mapper
mapper
called
called
Ecto,
ecto
and
and
templates
templates
use
use
embedded
embedded
Elixir,
elixir
which
which
again
again
feels
feels
very
very
similar
similar
to
to
Rails.
rails
However,
however
Phoenix
phoenix
has
has
a
a
huge
huge
advantage
advantage
in
in
performance
performance
because
because
Elixir
elixir
is
is
a
a
compiled
compiled
language.
language
As
as
an
an
added
added
bonus,
bonus
every
every
app
app
has
has
a
a
built
built
in
in
live
live
dashboard
dashboard
to
to
closely
closely
monitor
monitor
performance.
performance
And
and
that
that
brings
brings
us
us
to
to
another
another
high
high
performance
performance
framework
framework
worth
worth
checking
checking
out,
out
gin,
gin
which
which
is
is
powered
powered
by
by
the
the
Go
go
language.
language
It
it
Easily
easily
wins
wins
the
the
best
best
logo
logo
award.
award
To
to
get
get
started,
started
we're
we're
not
not
going
going
to
to
use
use
a
a
fancy
fancy
CLI,
cli
but
but
instead
instead
create
create
a
a
Go
go
project
project
from
from
scratch.
scratch
Gin
gin
is
is
a
a
minimal
minimal
HTTP
http
framework,
framework
and
and
is
is
not
not
concerned
concerned
with
with
the
the
model
model
view
view
controller
controller
architecture.
architecture
We'll
we'll
have
have
to
to
figure
figure
that
that
out
out
on
on
our
our
own.
own
It
it
also
also
doesn't
doesn't
contain
contain
an
an
ORM
orm
for
for
the
the
database,
database
so
so
for
for
That
that
will
will
bring
bring
in
in
another
another
package
package
called
called
Gorm.
gorm
The
the
nice
nice
thing
thing
about
about
this
this
approach
approach
is
is
that
that
we
we
don't
don't
really
really
need
need
to
to
follow
follow
the
the
MVC
mvc
conventions
conventions
of
of
a
a
framework,
framework
which
which
is
is
probably
probably
overkill
overkill
for
for
many
many
applications.
applications
Instead,
instead
we
we
can
can
write
write
some
some
very
very
focused
focused
functions,
functions
and
and
do
do
things
things
in
in
a
a
way
way
that
that
makes
makes
sense
sense
for
for
our
our
exact
exact
business
business
needs.
needs
Like
like
in
in
this
this
app,
app
we
we
just
just
have
have
2
2
routes
routes
that
that
need
need
to
to
retrieve
retrieve
some
some
data
data
from
from
a
a
database,
database
which
which
itself
itself
as
as
modeled
modeled
with
with
a
a
struct
struct
using
using
the
the
ORM.
orm
Then
then
Go
go
has
has
its
its
own
own
built
built
in
in
templating
templating
language,
language
so
so
we
we
can
can
simply
simply
create
create
a
a
couple
couple
of
of
template
template
files
files
here
here
in
in
the
the
project
project
and
and
interpolate
interpolate
the
the
values
values
that
that
we
we
you
you
retrieve
retrieve
from
from
the
the
database.
database
The
the
end
end
result
result
is
is
a
a
much
much
smaller
smaller
code
code
base
base
with
with
a
a
lot
lot
more
more
low
low
level
level
control.
control
However,
however
as
as
this
this
application
application
grows
grows
bigger,
bigger
it's
it's
going
going
to
to
and
and
harder
harder
and
and
harder.
harder
So
so
you
you
really
really
kinda
kinda
have
have
to
to
know
know
what
what
you're
you're
doing.
doing
And
and
that
that
brings
brings
us
us
to
to
our
our
next
next
language,
language
Rust,
rust
and
and
the
the
web
web
framework
framework
Rocket.
rocket
As
as
far
far
as
as
I
i
know,
know
the
the
Rust
rust
ecosystem
ecosystem
doesn't
doesn't
have
have
a
a
full
full
blown
blown
MVC
mvc
a
a
framework
framework
like
like
Rails.
rails
And
and
to
to
be
be
honest,
honest
I
i
found
found
it
it
very
very
difficult
difficult
to
to
build
build
a
a
basic
basic
application.
application
My
my
approach
approach
was
was
to
to
use
use
Rocket
rocket
for
for
HTTP
http
and
and
routing,
routing
then
then
combine
combine
it
it
with
with
Diesel,
diesel
which
which
is
is
a
a
Rust
rust
based
based
ORM,
orm
and
and
then
then
finally,
finally
a
a
templating
templating
language
language
to
to
use
use
the
the
data
data
in
in
HTML
html
called
called
AskComma.
askcomma
I
i
think
think
this
this
is
is
a
a
reasonable
reasonable
approach,
approach
but
but
I
i
didn't
didn't
quite
quite
get
get
to
to
a
a
full
full
working
working
demo
demo
with
with
It's
it's
a
a
systems
systems
language
language
that
that
gives
gives
you
you
low
low
level
level
control
control
over
over
memory,
memory
which
which
the
the
average
average
web
web
application
application
developer
developer
doesn't
doesn't
really
really
need.
need
I
i
quickly
quickly
realized
realized
that
that
it
it
would
would
take
take
more
more
time
time
and
and
dedication
dedication
than
than
I'm
i'm
willing
willing
to
to
give
give
for
for
the
the
tail
tail
end
end
of
of
a
a
silly
silly
YouTube
youtube
video.
video
However,
however
there
there
is
is
one
one
Rust
rust
based
based
library
library
that
that
I
i
want
want
to
to
bring
bring
to
to
your
your
attention
attention
called
called
U.
u
It's
it's
a
a
component
component
based
based
framework
framework
for
for
building
building
web
web
apps
apps
with
with
WebAssembly,
webassembly
and
and
it's
it's
coming
coming
to
to
a
a
Fireshift
fireshift
tutorial
tutorial
near
near
you
you
soon.
soon
And
and
that
that
brings
brings
us
us
to
to
the
the
final
final
framework
framework
in
in
this
this
list,
list
Vapor,
vapor
which
which
is
is
based
based
on
on
the
the
Swift
swift
programming
programming
language.
language
This
this
is
is
the
the
only
only
app
app
that
that
I
i
built
built
on
on
my
my
Mac
mac
because
because
I
i
found
found
that
that
Anything
anything
with
with
Swift
swift
just
just
works
works
better
better
on
on
a
a
Mac.
mac
It
it
provides
provides
you
you
with
with
a
a
project
project
structure
structure
that
that
looks
looks
like
like
this.
this
It's
it's
well
well
organized
organized
with
with
controllers,
controllers
models,
models
and
and
routes.
routes
Routes
routes
point
point
to
to
methods
methods
in
in
the
the
controller,
controller
which
which
can
can
access
access
data
data
from
from
a
a
model.
model
It
it
uses
uses
an
an
ORM
orm
called
called
fluent,
fluent
which
which
uses
uses
classes
classes
along
along
with
with
decorators
decorators
to
to
model
model
your
your
data.
data
Swift
swift
is
is
a
a
very
very
well
well
designed
designed
language
language
and
and
I
i
found
found
it
it
very
very
enjoyable
enjoyable
to
to
work
work
with
with
for
for
stuff
stuff
like
like
this.
this
The
the
code
code
is
is
concise
concise
and
and
readable
readable
yet
yet
statically
statically
typed
typed
with
with
awesome
awesome
tooling
tooling
like
like
you
you
would
would
get
get
in
in
Java
java
or
or
c
c
sharp.
sharp
I
i
also
also
like
like
how
how
it
it
embraces
embraces
asyncawait
asyncawait
when
when
fetching
fetching
data
data
from
from
your
your
models.
models
For
for
templating,
templating
it
it
has
has
an
an
engine
engine
called
called
Leaf,
leaf
which
which
also
also
felt
felt
very
very
modern
modern
and
and
practical.
practical
Now
now
that
that
we
we
look
look
at
at
Vapor,
vapor
I
i
want
want
to
to
also
also
mention
mention
Ktor,
ktor
which
which
is
is
a
a
Kotlin
kotlin
based
based
web
web
application
application
framework.
framework
It's
it's
a
a
lot
lot
more
more
minimal
minimal
than
than
something
something
like
like
Spring,
spring
but
but
also
also
something
something
worth
worth
checking
checking
out.
out
And
and
with
with
that,
that
we've
we've
looked
looked
at
at
10
10
full
full
stack
stack
frameworks.
frameworks
Now
now
I'm
i'm
ready
ready
to
to
show
show
you
you
the
the
best
best
full
full
stack
stack
framework
framework
in
in
the
the
world.
world
You're
you're
looking
looking
at
at
your
your
own
own
reflection
reflection
in
in
the
the
mirror.
mirror
Yes,
yes
it
it
was
was
you
you
all
all
along.
along
Without
without
you,
you
the
the
framework
framework
would
would
be
be
nothing.
nothing
Actually,
actually
no.
no
No.
no
That's
that's
that's
that's
just
just
dumb.
dumb
Ruby
ruby
on
on
Rails
rails
is
is
by
by
far
far
the
the
best
best
framework.
framework
Nothing
nothing
else
else
even
even
comes
comes
close.
close
It's
it's
like
like
the
the
magic
magic
Jordan
jordan
of
of
web
web
frameworks.
frameworks
Thanks
thanks
for
for
watching
watching
and
and
I
i
will
will
see
see
you
you
in
in
the
the
next
next
one.
one
success
The speakers discuss various framework and frameworks for building web apps, including the use of framework Ruby on Gladstone and the use of a minimal framework called Ktor for building websites. They also recommend using a framework called Vapor and a framework called Ktor for building minimal apps. The speakers highlight the benefits of using these frameworks for creating a minimal app and emphasize the importance of selecting the right framework and running a migration before building a full app. They also mention the use of Prisma and Hospital for web apps, and the use of the Gorm framework for creating a project. Finally, they recommend using a framework called Ktor for building web apps and thank the audience for watching.
I built 10 web apps... with 10 different languages
This is a web app. This is a web app. This thing here also a web app. Dude, why am I doing this again? I built the same app 10 times with 10 different frameworks using 10 different programming languages. It was a horrible experience, but I learned a lot, and I figured out which full stack framework is the greatest of all time, which will be revealed in dramatic fashion at the end of this video to to maximize the watch time. On this journey, you will meet 10 different server side frameworks, like Rails, Django, Laravel, Spring dot net, Next. Js, Phoenix, Rocket, gin, vapor, and ktor. I realize that's 11, but you don't need to be good at math to be a programmer. This video was insanely difficult because each one of these Frameworks uses a different programming language. For each one of them, we will look at the overall developer experience, including things like setup, routing, database integration, and the overall architecture. Now before we get started, here's a warning. The framework you choose by the end of this video is going to dictate your life for the next 10 years as you grow your startup into a decade unicorn. If your startup fails, it's 100% because you didn't choose the right framework. Reminds me of when my dad made me Choose which of my pet calves to slaughter with my own hands for my 6th birthday. Now before we look at the code, let's first answer the question of what does a web framework actually do. There are 3 main things you should know. 1st, they provide an abstraction over your relational database. They typically have a built in object relational mapper that can migrate code from your preferred programming language into SQL code that can be used by the database. 2nd, they provide routing that can map a URL in the browser to code that you want to run on the server. And 3rd, They provide a way to dynamically insert data from your database directly into HTML for the UI. Together, these three elements make up the model view controller architecture or MVC, which is by far the most common approach when building a full stack web app. The first framework we'll look at is Ruby on Rails, made famous for building some of the biggest companies in the world, like Shopify, Airbnb, and GitHub. Rails was revolutionary when it came out because it dramatically simplified web development compared to or approaches of the day. It's still very popular in 2022, and is kind of a rebel in the web development space. It has adjacent libraries like Hotwire, Stimulus, in Turbo that take an HTML centric approach to building web apps, which goes against the approach you might see in front end frameworks like React, Angular, and at Vue. To get started with Rails, you'll first need to have Ruby installed, then install the rails gem and run rails new. I'm developing this app on a fresh install of wm Linux and I did run-in Some issues with the initial setup. These were errors that could easily be solved with a Google search, but the initial setup was a little more error prone than other frameworks. Once you get the project set up though, the Rails CLI is extremely powerful. Not only does it do things like serve the application with Rails Server, but it can also generate a ton of code for you automatically with commands like scaffold. Now, if we look in the file explorer, you'll notice a bunch of different folders here and that's because Rails is a batteries included framework. It handles your relational database, testing, logging, and a bunch of other stuff. It might look pretty overwhelming at first. Your main application code is contained in the app directory where you'll find folders for models, views, and controllers. The first thing we'll look at is routing and the routes dot rb file. From this file, we can map URLs to actions in a controller. Resources create all the routes we would need for a basic CRUD feature automatically. It's kind of magical, but What it's actually doing is setting up a mapping between URLs in the browser and controller actions. Now, when the user visits a URL, it will trigger one of these actions on the server. That action might go and retrieve some data from your database. The logic for that data is contained in the model, but before we can use the data in the database, we need to run a migration, which will take the code in the model and sync it up with the actual database, and all the data is managed with an object relational mapper called active record. And then finally, you have a Vue, which is an HTML dot ERP file. ERP stands for embedded Ruby, and it allows you to render your data dynamically inside an HTML file. Overall, this provides a very nice separation of concerns and Rails is very opinionated, which means you can achieve a lot of functionality with very little code. The Scaffold not only retrieves items from the database, but it also that provides UI to create and update that data as well. But too much magic can also be a bad thing depending on who you ask. And Ruby is not the most popular language in the world, but Python is. What if there is a way we could build web apps like this with Python? And that's where Django comes in. It's also extremely popular and has been used to Old massive sites like Spotify and Bitbucket. When you generate a new Django app, you'll notice the file structure is far less overwhelming than rails, but at the same time it's still very much a batteries included framework. In addition, your code tends to be a lot more explicit. For example, we have this manage py file that contains the code for the actual command line interface to generate things in the project. We could use it to serve the app locally or generate an app to represent a feature of the website. It also follows the MVC architecture with routes being defined in the urls.py file, and controllers are represented as Python functions and in the views dot py file. A route points to one of these functions, which itself might want to access data from one of our models. A model is a Python Class represents the structure of data in an SQL database, a k a the object relational mapper. And, finally, we have our HTML templates that allow you to embed Python directly into the code. That's pretty cool, but one extra superpower of Django is that it has an admin feature built into it directly. As you define models in your application, you can register them with the admin app to easily manage all of your data in the browser. This is really useful and not something that you'd want to roll out on your own. Python's great and all, but the original server side language of the web was PHP. There have been countless PHP frameworks over the years and high level tools like WordPress, but the most popular one today is Laravel, the PHP framework for web artisans. To use it, you'll first want to install PHP and a tool called Composer. When I generated my initial app, it took a long time and downloaded a lot of packages. And as you can see, the initial project has a lot of batteries included, even more so than rails. If we look at routes, You can see it not only handles web routes, but also API routes and channels for real time communication with WebSockets. Now, if we We go into the app code, you'll notice it's already been configured with things like user authentication via providers. A provider is like a shared service that you can use anywhere in the application. In the HTTP directory, we will find our controllers, and just like Rails, we have a class that contains a bunch of different methods that can access data and render a specific template. Now, our database models use a tool called Eloquent ORM, which is based on the same active record pattern as Rails. Now, when it comes to views, PHP is a language that's designed to work with HTML out of the box. Laravel makes it even easier by building on top of PHP with blade templates. Another cool point about the ecosystem is that they put a lot of thought into how to integrate front end frameworks like React and Vue. It has an adjacent tool called inertia that can bridge the gap between front end and back end frameworks. The next framework we'll look at is Next. Js, which allows us to build a full Stack application entirely with JavaScript. Now, in the JavaScript world, there's a million different options we could have chosen here like Nuxt. Js, Angular Universal, builtkit, nestjs, adonis, and many others. Maybe I'll make a top ten video just for those. To get started with Next, we run npx create Next App, and that will generate a starter project. Now the one thing you'll notice about Next right off the bat is that it doesn't provide any integration for your database. There are a 1000000 different solutions to choose from, but one of my personal favorites is Prisma. So I'm going to add Prisma to this project. The fact that Next. Js doesn't have a database out of the box is a good thing in my opinion. The JavaScript ecosystem is just way too crazy. It's nice to start with a very good minimal framework and then add whatever database integration you want on top of it. Now that we have a database integrated, let's take a look at the page's directory. One thing that's different about Next is that routing is handled with the file system. Each file defined in the page's directory defines a different URL and the browser. Dynamic routes can be created by wrapping the file name in brackets. Now, each one of these files exports a React component to define the UI or view. This is actually really convenient because many other frameworks will ultimately want to have some kind of front end framework. Having React fundamentally integrated into the framework or can streamline your productivity big time. Now, things get more complex when you think about data fetching. Normally, in a React app, you're thinking about client side code, but in Next. Js, you can also run server side code with functions like get server side props. This function will run on the server with Node. Js, and as you can see inside of it, we're using Prisma to fetch some items from the database. These items can then be delivered as props to the React component where they're rendered in the UI. Both your server side and client side code is tightly coupled together, which may feel like a bad separation of concerns, but generally speaking it actually works very well. Overall, Next. Js feels very minimal compared to other frameworks in this list, but it does a ton of stuff behind the scenes to simplify the annoying parts of web development. Now, speaking of simple, we're going to do the polar opposite and see what Java has to offer. Even though Java is a boilerplate driven language for writing instant legacy code, the Spring framework actually makes it very enjoyable to work with. The first thing you'll Notice when building with it is that it's kind of like a create your own adventure story. It has a generator that allows you to start with a framework and you can even use Kotlin or Groovy if you'd like, then you choose all the different dependencies that you want to add to this project. Now, even though Java does have a lot of boilerplate, the code pretty much writes itself, and in my opinion, it feels a lot more robust compared to the dynamic languages that we've looked at so far. You'll find the source code way down in this deeply nested folder and it also follows the MVC pattern. The controller is a class and a route is defined using a decorator on each one of its methods. Spring relies on a lot of metaprogramming to keep your code nice and simple. It feels very much like Angular in the JavaScript world. The database models are based on code with the Java persistence API, AI, then we can use that data in templates using Thymeleaf, where you add these attributes to your HTML to define where your data should go. To be honest though, I didn't have a very good time using Thymeleaf. I believe. And that brings me to Java's arch nemesis, c sharp and the dot net framework or asp.net. It's an open source project maintained by Microsoft and obviously feels very Microsofty, but is extremely popular and reliable. It's evolved very nicely over the years and has modern supporting libraries like Blazor that allow you to build client side apps using WebAssembly and in c sharp. To use it, install the dot net SDK, then generate a new MBC application. I really like the initial project structure. Everything is clearly named and it's Not too overwhelming. And you get all the awesome tooling and static typing like you do in Java. When it comes to routing, the URLs are inferred from the class names in your controllers. Here, we have an animals controller, which gives us the animals URL, then we have methods in that class that then represent the next URL segment. The method can take an argument meant to create a dynamic URL. To represent our data, we have a model that is managed by an ORM called the entity core framework. And then finally, we have our used, which are written in cshtml. At the top of one of these files, you'll notice a model where we can access our data, and we can also declare additional data here in c sharp like a title. It's More verbose than other templating languages, but you get full IntelliSense inside of it, which is really helpful. Overall, dot net is really impressive. The only real Drawback is that you have to sell your soul to the big giant tech corporation. If you wanna take the righteous path, another awesome framework to check out is Phoenix, which is based on the or programming language. It's a functional language that feels much different than most of the object oriented languages that we've looked at throughout the video. Don't worry, a 100 second video is coming soon. Install Call it, then generate a new project. Like Ruby on Rails, it has a very powerful CLI that can automatically scaffold an entire CRUD application for you. Routing is also very similar to Rails where we have resources that map all the necessary CRUD URLs to the controller. In the controller, we have functions name spaced under a module that access data and render the appropriate template. The model uses an object relational mapper called Ecto, and templates use embedded Elixir, which again feels very similar to Rails. However, Phoenix has a huge advantage in performance because Elixir is a compiled language. As an added bonus, every app has a built in live dashboard to closely monitor performance. And that brings us to another high performance framework worth checking out, gin, which is powered by the Go language. It Easily wins the best logo award. To get started, we're not going to use a fancy CLI, but instead create a Go project from scratch. Gin is a minimal HTTP framework, and is not concerned with the model view controller architecture. We'll have to figure that out on our own. It also doesn't contain an ORM for the database, so for That will bring in another package called Gorm. The nice thing about this approach is that we don't really need to follow the MVC conventions of a framework, which is probably overkill for many applications. Instead, we can write some very focused functions, and do things in a way that makes sense for our exact business needs. Like in this app, we just have 2 routes that need to retrieve some data from a database, which itself as modeled with a struct using the ORM. Then Go has its own built in templating language, so we can simply create a couple of template files here in the project and interpolate the values that we you retrieve from the database. The end result is a much smaller code base with a lot more low level control. However, as this application grows bigger, it's going to and harder and harder. So you really kinda have to know what you're doing. And that brings us to our next language, Rust, and the web framework Rocket. As far as I know, the Rust ecosystem doesn't have a full blown MVC a framework like Rails. And to be honest, I found it very difficult to build a basic application. My approach was to use Rocket for HTTP and routing, then combine it with Diesel, which is a Rust based ORM, and then finally, a templating language to use the data in HTML called AskComma. I think this is a reasonable approach, but I didn't quite get to a full working demo with It's a systems language that gives you low level control over memory, which the average web application developer doesn't really need. I quickly realized that it would take more time and dedication than I'm willing to give for the tail end of a silly YouTube video. However, there is one Rust based library that I want to bring to your attention called U. It's a component based framework for building web apps with WebAssembly, and it's coming to a Fireshift tutorial near you soon. And that brings us to the final framework in this list, Vapor, which is based on the Swift programming language. This is the only app that I built on my Mac because I found that Anything with Swift just works better on a Mac. It provides you with a project structure that looks like this. It's well organized with controllers, models, and routes. Routes point to methods in the controller, which can access data from a model. It uses an ORM called fluent, which uses classes along with decorators to model your data. Swift is a very well designed language and I found it very enjoyable to work with for stuff like this. The code is concise and readable yet statically typed with awesome tooling like you would get in Java or c sharp. I also like how it embraces asyncawait when fetching data from your models. For templating, it has an engine called Leaf, which also felt very modern and practical. Now that we look at Vapor, I want to also mention Ktor, which is a Kotlin based web application framework. It's a lot more minimal than something like Spring, but also something worth checking out. And with that, we've looked at 10 full stack frameworks. Now I'm ready to show you the best full stack framework in the world. You're looking at your own reflection in the mirror. Yes, it was you all along. Without you, the framework would be nothing. Actually, no. No. That's that's just dumb. Ruby on Rails is by far the best framework. Nothing else even comes close. It's like the magic Jordan of web frameworks. Thanks for watching and I will see you in the next one.
The speakers discuss various framework and frameworks for building web apps, including the use of framework Ruby on Gladstone and the use of a minimal framework called Ktor for building websites. They also recommend using a framework called Vapor and a framework called Ktor for building minimal apps. The speakers highlight the benefits of using these frameworks for creating a minimal app and emphasize the importance of selecting the right framework and running a migration before building a full app. They also mention the use of Prisma and Hospital for web apps, and the use of the Gorm framework for creating a project. Finally, they recommend using a framework called Ktor for building web apps and thank the audience for watching.

        [INST]
        You are youtuber called Fireship you make engaging high-intensity and entertaining coding tutorials and tech news. 
        you covers a wide range of topics relevant to programmers, aiming to help them learn and improve their skills quickly.
        
        Given the title of the video : I built 10 web apps... with 10 different languages 
        and a small summary : The speakers discuss various framework and frameworks for building web apps, including the use of framework Ruby on Gladstone and the use of a minimal framework called Ktor for building websites. They also recommend using a framework called Vapor and a framework called Ktor for building minimal apps. The speakers highlight the benefits of using these frameworks for creating a minimal app and emphasize the importance of selecting the right framework and running a migration before building a full app. They also mention the use of Prisma and Hospital for web apps, and the use of the Gorm framework for creating a project. Finally, they recommend using a framework called Ktor for building web apps and thank the audience for watching.
        [/INST]
        
        Generate the video : This is a web app. This is a web app. This thing here also a web app. Dude, why am I doing this again? I built the same app 10 times with 10 different frameworks using 10 different programming languages. It was a horrible experience, but I learned a lot, and I figured out which full stack framework is the greatest of all time, which will be revealed in dramatic fashion at the end of this video to to maximize the watch time. On this journey, you will meet 10 different server side frameworks, like Rails, Django, Laravel, Spring dot net, Next. Js, Phoenix, Rocket, gin, vapor, and ktor. I realize that's 11, but you don't need to be good at math to be a programmer. This video was insanely difficult because each one of these Frameworks uses a different programming language. For each one of them, we will look at the overall developer experience, including things like setup, routing, database integration, and the overall architecture. Now before we get started, here's a warning. The framework you choose by the end of this video is going to dictate your life for the next 10 years as you grow your startup into a decade unicorn. If your startup fails, it's 100% because you didn't choose the right framework. Reminds me of when my dad made me Choose which of my pet calves to slaughter with my own hands for my 6th birthday. Now before we look at the code, let's first answer the question of what does a web framework actually do. There are 3 main things you should know. 1st, they provide an abstraction over your relational database. They typically have a built in object relational mapper that can migrate code from your preferred programming language into SQL code that can be used by the database. 2nd, they provide routing that can map a URL in the browser to code that you want to run on the server. And 3rd, They provide a way to dynamically insert data from your database directly into HTML for the UI. Together, these three elements make up the model view controller architecture or MVC, which is by far the most common approach when building a full stack web app. The first framework we'll look at is Ruby on Rails, made famous for building some of the biggest companies in the world, like Shopify, Airbnb, and GitHub. Rails was revolutionary when it came out because it dramatically simplified web development compared to or approaches of the day. It's still very popular in 2022, and is kind of a rebel in the web development space. It has adjacent libraries like Hotwire, Stimulus, in Turbo that take an HTML centric approach to building web apps, which goes against the approach you might see in front end frameworks like React, Angular, and at Vue. To get started with Rails, you'll first need to have Ruby installed, then install the rails gem and run rails new. I'm developing this app on a fresh install of wm Linux and I did run-in Some issues with the initial setup. These were errors that could easily be solved with a Google search, but the initial setup was a little more error prone than other frameworks. Once you get the project set up though, the Rails CLI is extremely powerful. Not only does it do things like serve the application with Rails Server, but it can also generate a ton of code for you automatically with commands like scaffold. Now, if we look in the file explorer, you'll notice a bunch of different folders here and that's because Rails is a batteries included framework. It handles your relational database, testing, logging, and a bunch of other stuff. It might look pretty overwhelming at first. Your main application code is contained in the app directory where you'll find folders for models, views, and controllers. The first thing we'll look at is routing and the routes dot rb file. From this file, we can map URLs to actions in a controller. Resources create all the routes we would need for a basic CRUD feature automatically. It's kind of magical, but What it's actually doing is setting up a mapping between URLs in the browser and controller actions. Now, when the user visits a URL, it will trigger one of these actions on the server. That action might go and retrieve some data from your database. The logic for that data is contained in the model, but before we can use the data in the database, we need to run a migration, which will take the code in the model and sync it up with the actual database, and all the data is managed with an object relational mapper called active record. And then finally, you have a Vue, which is an HTML dot ERP file. ERP stands for embedded Ruby, and it allows you to render your data dynamically inside an HTML file. Overall, this provides a very nice separation of concerns and Rails is very opinionated, which means you can achieve a lot of functionality with very little code. The Scaffold not only retrieves items from the database, but it also that provides UI to create and update that data as well. But too much magic can also be a bad thing depending on who you ask. And Ruby is not the most popular language in the world, but Python is. What if there is a way we could build web apps like this with Python? And that's where Django comes in. It's also extremely popular and has been used to Old massive sites like Spotify and Bitbucket. When you generate a new Django app, you'll notice the file structure is far less overwhelming than rails, but at the same time it's still very much a batteries included framework. In addition, your code tends to be a lot more explicit. For example, we have this manage py file that contains the code for the actual command line interface to generate things in the project. We could use it to serve the app locally or generate an app to represent a feature of the website. It also follows the MVC architecture with routes being defined in the urls.py file, and controllers are represented as Python functions and in the views dot py file. A route points to one of these functions, which itself might want to access data from one of our models. A model is a Python Class represents the structure of data in an SQL database, a k a the object relational mapper. And, finally, we have our HTML templates that allow you to embed Python directly into the code. That's pretty cool, but one extra superpower of Django is that it has an admin feature built into it directly. As you define models in your application, you can register them with the admin app to easily manage all of your data in the browser. This is really useful and not something that you'd want to roll out on your own. Python's great and all, but the original server side language of the web was PHP. There have been countless PHP frameworks over the years and high level tools like WordPress, but the most popular one today is Laravel, the PHP framework for web artisans. To use it, you'll first want to install PHP and a tool called Composer. When I generated my initial app, it took a long time and downloaded a lot of packages. And as you can see, the initial project has a lot of batteries included, even more so than rails. If we look at routes, You can see it not only handles web routes, but also API routes and channels for real time communication with WebSockets. Now, if we We go into the app code, you'll notice it's already been configured with things like user authentication via providers. A provider is like a shared service that you can use anywhere in the application. In the HTTP directory, we will find our controllers, and just like Rails, we have a class that contains a bunch of different methods that can access data and render a specific template. Now, our database models use a tool called Eloquent ORM, which is based on the same active record pattern as Rails. Now, when it comes to views, PHP is a language that's designed to work with HTML out of the box. Laravel makes it even easier by building on top of PHP with blade templates. Another cool point about the ecosystem is that they put a lot of thought into how to integrate front end frameworks like React and Vue. It has an adjacent tool called inertia that can bridge the gap between front end and back end frameworks. The next framework we'll look at is Next. Js, which allows us to build a full Stack application entirely with JavaScript. Now, in the JavaScript world, there's a million different options we could have chosen here like Nuxt. Js, Angular Universal, builtkit, nestjs, adonis, and many others. Maybe I'll make a top ten video just for those. To get started with Next, we run npx create Next App, and that will generate a starter project. Now the one thing you'll notice about Next right off the bat is that it doesn't provide any integration for your database. There are a 1000000 different solutions to choose from, but one of my personal favorites is Prisma. So I'm going to add Prisma to this project. The fact that Next. Js doesn't have a database out of the box is a good thing in my opinion. The JavaScript ecosystem is just way too crazy. It's nice to start with a very good minimal framework and then add whatever database integration you want on top of it. Now that we have a database integrated, let's take a look at the page's directory. One thing that's different about Next is that routing is handled with the file system. Each file defined in the page's directory defines a different URL and the browser. Dynamic routes can be created by wrapping the file name in brackets. Now, each one of these files exports a React component to define the UI or view. This is actually really convenient because many other frameworks will ultimately want to have some kind of front end framework. Having React fundamentally integrated into the framework or can streamline your productivity big time. Now, things get more complex when you think about data fetching. Normally, in a React app, you're thinking about client side code, but in Next. Js, you can also run server side code with functions like get server side props. This function will run on the server with Node. Js, and as you can see inside of it, we're using Prisma to fetch some items from the database. These items can then be delivered as props to the React component where they're rendered in the UI. Both your server side and client side code is tightly coupled together, which may feel like a bad separation of concerns, but generally speaking it actually works very well. Overall, Next. Js feels very minimal compared to other frameworks in this list, but it does a ton of stuff behind the scenes to simplify the annoying parts of web development. Now, speaking of simple, we're going to do the polar opposite and see what Java has to offer. Even though Java is a boilerplate driven language for writing instant legacy code, the Spring framework actually makes it very enjoyable to work with. The first thing you'll Notice when building with it is that it's kind of like a create your own adventure story. It has a generator that allows you to start with a framework and you can even use Kotlin or Groovy if you'd like, then you choose all the different dependencies that you want to add to this project. Now, even though Java does have a lot of boilerplate, the code pretty much writes itself, and in my opinion, it feels a lot more robust compared to the dynamic languages that we've looked at so far. You'll find the source code way down in this deeply nested folder and it also follows the MVC pattern. The controller is a class and a route is defined using a decorator on each one of its methods. Spring relies on a lot of metaprogramming to keep your code nice and simple. It feels very much like Angular in the JavaScript world. The database models are based on code with the Java persistence API, AI, then we can use that data in templates using Thymeleaf, where you add these attributes to your HTML to define where your data should go. To be honest though, I didn't have a very good time using Thymeleaf. I believe. And that brings me to Java's arch nemesis, c sharp and the dot net framework or asp.net. It's an open source project maintained by Microsoft and obviously feels very Microsofty, but is extremely popular and reliable. It's evolved very nicely over the years and has modern supporting libraries like Blazor that allow you to build client side apps using WebAssembly and in c sharp. To use it, install the dot net SDK, then generate a new MBC application. I really like the initial project structure. Everything is clearly named and it's Not too overwhelming. And you get all the awesome tooling and static typing like you do in Java. When it comes to routing, the URLs are inferred from the class names in your controllers. Here, we have an animals controller, which gives us the animals URL, then we have methods in that class that then represent the next URL segment. The method can take an argument meant to create a dynamic URL. To represent our data, we have a model that is managed by an ORM called the entity core framework. And then finally, we have our used, which are written in cshtml. At the top of one of these files, you'll notice a model where we can access our data, and we can also declare additional data here in c sharp like a title. It's More verbose than other templating languages, but you get full IntelliSense inside of it, which is really helpful. Overall, dot net is really impressive. The only real Drawback is that you have to sell your soul to the big giant tech corporation. If you wanna take the righteous path, another awesome framework to check out is Phoenix, which is based on the or programming language. It's a functional language that feels much different than most of the object oriented languages that we've looked at throughout the video. Don't worry, a 100 second video is coming soon. Install Call it, then generate a new project. Like Ruby on Rails, it has a very powerful CLI that can automatically scaffold an entire CRUD application for you. Routing is also very similar to Rails where we have resources that map all the necessary CRUD URLs to the controller. In the controller, we have functions name spaced under a module that access data and render the appropriate template. The model uses an object relational mapper called Ecto, and templates use embedded Elixir, which again feels very similar to Rails. However, Phoenix has a huge advantage in performance because Elixir is a compiled language. As an added bonus, every app has a built in live dashboard to closely monitor performance. And that brings us to another high performance framework worth checking out, gin, which is powered by the Go language. It Easily wins the best logo award. To get started, we're not going to use a fancy CLI, but instead create a Go project from scratch. Gin is a minimal HTTP framework, and is not concerned with the model view controller architecture. We'll have to figure that out on our own. It also doesn't contain an ORM for the database, so for That will bring in another package called Gorm. The nice thing about this approach is that we don't really need to follow the MVC conventions of a framework, which is probably overkill for many applications. Instead, we can write some very focused functions, and do things in a way that makes sense for our exact business needs. Like in this app, we just have 2 routes that need to retrieve some data from a database, which itself as modeled with a struct using the ORM. Then Go has its own built in templating language, so we can simply create a couple of template files here in the project and interpolate the values that we you retrieve from the database. The end result is a much smaller code base with a lot more low level control. However, as this application grows bigger, it's going to and harder and harder. So you really kinda have to know what you're doing. And that brings us to our next language, Rust, and the web framework Rocket. As far as I know, the Rust ecosystem doesn't have a full blown MVC a framework like Rails. And to be honest, I found it very difficult to build a basic application. My approach was to use Rocket for HTTP and routing, then combine it with Diesel, which is a Rust based ORM, and then finally, a templating language to use the data in HTML called AskComma. I think this is a reasonable approach, but I didn't quite get to a full working demo with It's a systems language that gives you low level control over memory, which the average web application developer doesn't really need. I quickly realized that it would take more time and dedication than I'm willing to give for the tail end of a silly YouTube video. However, there is one Rust based library that I want to bring to your attention called U. It's a component based framework for building web apps with WebAssembly, and it's coming to a Fireshift tutorial near you soon. And that brings us to the final framework in this list, Vapor, which is based on the Swift programming language. This is the only app that I built on my Mac because I found that Anything with Swift just works better on a Mac. It provides you with a project structure that looks like this. It's well organized with controllers, models, and routes. Routes point to methods in the controller, which can access data from a model. It uses an ORM called fluent, which uses classes along with decorators to model your data. Swift is a very well designed language and I found it very enjoyable to work with for stuff like this. The code is concise and readable yet statically typed with awesome tooling like you would get in Java or c sharp. I also like how it embraces asyncawait when fetching data from your models. For templating, it has an engine called Leaf, which also felt very modern and practical. Now that we look at Vapor, I want to also mention Ktor, which is a Kotlin based web application framework. It's a lot more minimal than something like Spring, but also something worth checking out. And with that, we've looked at 10 full stack frameworks. Now I'm ready to show you the best full stack framework in the world. You're looking at your own reflection in the mirror. Yes, it was you all along. Without you, the framework would be nothing. Actually, no. No. That's that's just dumb. Ruby on Rails is by far the best framework. Nothing else even comes close. It's like the magic Jordan of web frameworks. Thanks for watching and I will see you in the next one.
        