How has JavaScript and web development changed in 2023? Learn about the top 10 updates to Next.js, React, Angular, Vue, and Node.js. 

#webdevelopment #programming #top10 

💬 Chat with Me on Discord

https://discord.gg/fireship

🔗 Resources

JS groupBy method https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/groupBy
Next.js Criticism https://pilcrow.vercel.app/blog/nextjs-why?s
HTMX in 100 Seconds https://youtu.be/r-GSGH2RxJs?si=jQR6TVNzaJ8dEobC

🔥 Get More Content - Upgrade to PRO

Upgrade at https://fireship.io/pro
Use code YT25 for 25% off PRO access 

🎨 My Editor Settings

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

🔖 Topics Covered

- JavaScript framework of the year award
- New features in JS language
- HTML dialog element
- Next.js App Directory
- What is UnJS?
- Major changes to Angular 17
- Bun JavaScript Runtime vs Node.js
2024-02-04T04:59:49.716Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
95598650-0108-48e4-b108-ce64cbb64040
bc818b8d80cfaa73368f0747702bf8f44a9a357d1b0e27bc21fc89d9f510c430
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
2023 has been a wild year.
My bank collapsed, Elon bought Twitter, almost all my friends got laid off, all my favorite crypto bros are going to jail.
Tesla successfully made it the DeLorean with a Pontiac Aztek, bringing us the Cybertruck, and ChatGPT made me obsolete.
But all this good news pales in comparison to the changes web developers have seen in JavaScript land over the last year, where almost every framework decided to reinvent itself in 2023.
In today's video, we'll look at 10 recent changes to JavaScript that you may have missed.
Every year, new language features get standardized in ECMAScript, at which point they're implemented in browsers.
One of my favorite new features this year is object group by.
Imagine you have an array of objects where the objects share a similar schema.
These might be records from a database where every object has a field of age.
You can use group by to separate the children from the adults by defining a function that groups anyone under 21 into children and anyone over that into old.
The end result is an object organized into groups.
That's a nice little utility, but one I find myself using even more often is array 2 sorted, along with 2 spliced and 2 reversed.
JavaScript already had methods for sort and reversed, but the problem is that they mutate the original array in place.
And that's confusing because other methods like map and filter don't do that.
Instead, they copy the array and return a new one.
With these methods, you can now sort, reverse, and splice an array by tree be in the original as an immutable value, which tends to be the more sane way to write your code.
Web developers also got some cool updates in the form of brand new HTML elements.
Like, the search tag is a more semantic way to define a search box on a website, which can replace the more generic form tag.
That's nice, but the element is way more powerful, which allows you to create actual modal dialogues and then control them with JavaScript using built in methods like show modal and close.
Another nice utility, but that brings us to index 3.
After years of begging and pleading with Apple, iOS finally allows push notifications to come from web apps, and that's a huge win for the point 0 0 0 1 percent of website users who actually allow websites to send them push notifications, which is most likely your grandpa who accidentally click the allow button, and now it has no idea how to turn it off.
But now it's time to talk about the fun stuff, frameworks.
The world's most popular JavaScript framework, Next.
Js, is an entirely a different framework than it was last year, thanks to the app directory, which became stable in May with version 13.4.
The most notable difference is that you can now fetch data directly inside React components, thanks to server components, which are React components that can run on the server.
The reception to the app directory has been somewhat mixed.
On one hand, it has a lot of awesome new features and can simplify your code, but many have complained about it feeling rushed and half baked, kind of like the way they launch video games nowadays where they just get something out the door, then patch it up over the next few years.
People have complained about having to use the use client directive everywhere due to breaking existing React libraries.
People have complained about the slow dev server, which is powered by Rust, which is weird because anything powered by Rust is supposed to be fast, and people have compared its new server actions feature to PHP, one of the most offensive slurs you can make against a JavaScript framework.
But the biggest issue is that running Next.
Js is fairly hard to do correctly outside of Vercel, and that's led to projects like OpenNext that take on the tedious job of getting it to run anywhere.
Next to still the dominant meta framework, but Nuxt.
Js and the Vue ecosystem also had a lot of cool updates in 2023 like its dev tools.
These tools run directly in the browser and make it much here to understand the structure of a complex application.
But one thing you may not know about Nuxt is that many of its components are available through the unified JavaScript to rep tools ecosystem.
Like, if you don't care about Vue.
Js and just want a web server, you can use Nitro to build a fast server with plain JavaScript.
What's funny is I think the Vue.
Js ecosystem has changed the least in 2023, and as a consequence, it feels like the most stable and predictable ecosystem.
Svelte, on the other hand, got ruined in 2023.
In a shocking announcement a couple months ago, Svelte announced a new feature called runes that will dramatically change the developer experience in version 5.
Instead of defining reactive variables with at.
There's now this thing called a rune, which is essentially a compiler macro that tells the Svelte compiler this value is reactive.
Svelte is to getting rid of the dollar sign colon syntax and stores with runes like derived and effect.
The initial response to these changes were somewhat mixed with some users there's feeling like these changes make Svelte look a lot more like React, which is the type of developer experience they're trying to get away from.
But on the other hand, a lot of people love these changes and see them as necessary to evolve framework in the right direction.
As a hardcore user of Svelte myself, I'm waiting for the final release of version 5 before I form an opinion.
The award for the most changed to framework in 2023 though goes to Angular.
It has a long list of new features, but the most notable changes for Angular haters out there would be the new template syntax, which provides a cleaner way a to handle conditionals and loops, replacing things like n g f and n g four.
In addition, Angular has also adopted signals, much like all the other frameworks out there, and brings a new feature called deferrable views, which enables declarative lazy loading directly in a template.
But most importantly, Angular has a brand new logo, which was really the only thing holding it back from being the world's most popular framework in the past.
A lot of crazy changes on the front end, but on the back end, Node.
Js has been quietly getting better.
With Node.
Js version 20, to release a new permissions model, which improves security by controlling which features a script has access to, very much similar to what Deno released a few years ago.
And with the release of Node 21.
It introduced its own WebSocket client, which is based on the WebSocket API in the browser.
The biggest disruptor with back in JavaScript to 2023, though, is BUN.
It's a new JavaScript runtime written in Zig that came out with an awesome developer experience and some wild claims about performance.
And quite a few bugs were discovered after the initial release, but it still remains a promising new way to do back end JavaScript in the future.
And with that, we've looked at 10 different ways with script changed in 2023.
But I almost forgot the biggest one of all, h t m x, the framework that showed us that anyone can capture the imagination of the JavaScript ecosystem if you shitpost and meme hard enough on Twitter.
But, most importantly, as I've shown here with science, h t m x can actually eliminate a ton of JavaScript compared to to status quo approach taken by all the major frameworks.
It's the ideal JavaScript framework for the JavaScript haters.
And that's why today, I'm thrilled and honored to present the h t m x team with the JavaScript framework of the year award which is basically the Nobel Prize of JavaScript.
Thanks for watching and I will see you in the next one.

Speaker 0: 2023 has been a wild year. My bank collapsed, Elon bought Twitter, almost all my friends got laid off, all my favorite crypto bros are going to jail. Tesla successfully made it the DeLorean with a Pontiac Aztek, bringing us the Cybertruck, and ChatGPT made me obsolete. But all this good news pales in comparison to the changes web developers have seen in JavaScript land over the last year, where almost every framework decided to reinvent itself in 2023. In today's video, we'll look at 10 recent changes to JavaScript that you may have missed.

Every year, new language features get standardized in ECMAScript, at which point they're implemented in browsers. One of my favorite new features this year is object group by. Imagine you have an array of objects where the objects share a similar schema. These might be records from a database where every object has a field of age. You can use group by to separate the children from the adults by defining a function that groups anyone under 21 into children and anyone over that into old.

The end result is an object organized into groups. That's a nice little utility, but one I find myself using even more often is array 2 sorted, along with 2 spliced and 2 reversed. JavaScript already had methods for sort and reversed, but the problem is that they mutate the original array in place. And that's confusing because other methods like map and filter don't do that. Instead, they copy the array and return a new one.

With these methods, you can now sort, reverse, and splice an array by tree be in the original as an immutable value, which tends to be the more sane way to write your code. Web developers also got some cool updates in the form of brand new HTML elements. Like, the search tag is a more semantic way to define a search box on a website, which can replace the more generic form tag. That's nice, but the element is way more powerful, which allows you to create actual modal dialogues and then control them with JavaScript using built in methods like show modal and close. Another nice utility, but that brings us to index 3.

After years of begging and pleading with Apple, iOS finally allows push notifications to come from web apps, and that's a huge win for the point 0 0 0 1 percent of website users who actually allow websites to send them push notifications, which is most likely your grandpa who accidentally click the allow button, and now it has no idea how to turn it off. But now it's time to talk about the fun stuff, frameworks. The world's most popular JavaScript framework, Next. Js, is an entirely a different framework than it was last year, thanks to the app directory, which became stable in May with version 13.4. The most notable difference is that you can now fetch data directly inside React components, thanks to server components, which are React components that can run on the server.

The reception to the app directory has been somewhat mixed. On one hand, it has a lot of awesome new features and can simplify your code, but many have complained about it feeling rushed and half baked, kind of like the way they launch video games nowadays where they just get something out the door, then patch it up over the next few years. People have complained about having to use the use client directive everywhere due to breaking existing React libraries. People have complained about the slow dev server, which is powered by Rust, which is weird because anything powered by Rust is supposed to be fast, and people have compared its new server actions feature to PHP, one of the most offensive slurs you can make against a JavaScript framework. But the biggest issue is that running Next.

Js is fairly hard to do correctly outside of Vercel, and that's led to projects like OpenNext that take on the tedious job of getting it to run anywhere. Next to still the dominant meta framework, but Nuxt. Js and the Vue ecosystem also had a lot of cool updates in 2023 like its dev tools. These tools run directly in the browser and make it much here to understand the structure of a complex application. But one thing you may not know about Nuxt is that many of its components are available through the unified JavaScript to rep tools ecosystem.

Like, if you don't care about Vue. Js and just want a web server, you can use Nitro to build a fast server with plain JavaScript. What's funny is I think the Vue. Js ecosystem has changed the least in 2023, and as a consequence, it feels like the most stable and predictable ecosystem. Svelte, on the other hand, got ruined in 2023.

In a shocking announcement a couple months ago, Svelte announced a new feature called runes that will dramatically change the developer experience in version 5. Instead of defining reactive variables with at. There's now this thing called a rune, which is essentially a compiler macro that tells the Svelte compiler this value is reactive. Svelte is to getting rid of the dollar sign colon syntax and stores with runes like derived and effect. The initial response to these changes were somewhat mixed with some users there's feeling like these changes make Svelte look a lot more like React, which is the type of developer experience they're trying to get away from.

But on the other hand, a lot of people love these changes and see them as necessary to evolve framework in the right direction. As a hardcore user of Svelte myself, I'm waiting for the final release of version 5 before I form an opinion. The award for the most changed to framework in 2023 though goes to Angular. It has a long list of new features, but the most notable changes for Angular haters out there would be the new template syntax, which provides a cleaner way a to handle conditionals and loops, replacing things like n g f and n g four. In addition, Angular has also adopted signals, much like all the other frameworks out there, and brings a new feature called deferrable views, which enables declarative lazy loading directly in a template.

But most importantly, Angular has a brand new logo, which was really the only thing holding it back from being the world's most popular framework in the past. A lot of crazy changes on the front end, but on the back end, Node. Js has been quietly getting better. With Node. Js version 20, to release a new permissions model, which improves security by controlling which features a script has access to, very much similar to what Deno released a few years ago.

And with the release of Node 21. It introduced its own WebSocket client, which is based on the WebSocket API in the browser. The biggest disruptor with back in JavaScript to 2023, though, is BUN. It's a new JavaScript runtime written in Zig that came out with an awesome developer experience and some wild claims about performance. And quite a few bugs were discovered after the initial release, but it still remains a promising new way to do back end JavaScript in the future.

And with that, we've looked at 10 different ways with script changed in 2023. But I almost forgot the biggest one of all, h t m x, the framework that showed us that anyone can capture the imagination of the JavaScript ecosystem if you shitpost and meme hard enough on Twitter. But, most importantly, as I've shown here with science, h t m x can actually eliminate a ton of JavaScript compared to to status quo approach taken by all the major frameworks. It's the ideal JavaScript framework for the JavaScript haters. And that's why today, I'm thrilled and honored to present the h t m x team with the JavaScript framework of the year award which is basically the Nobel Prize of JavaScript.

Thanks for watching and I will see you in the next one.
2023 has been a wild year. My bank collapsed, Elon bought Twitter, almost all my friends got laid off, all my favorite crypto bros are going to jail. Tesla successfully made it the DeLorean with a Pontiac Aztek, bringing us the Cybertruck, and ChatGPT made me obsolete. But all this good news pales in comparison to the changes web developers have seen in JavaScript land over the last year, where almost every framework decided to reinvent itself in 2023.
cryptocurrency
In today's video, we'll look at 10 recent changes to JavaScript that you may have missed. Every year, new language features get standardized in ECMAScript, at which point they're implemented in browsers.
One of my favorite new features this year is object group by. Imagine you have an array of objects where the objects share a similar schema. These might be records from a database where every object has a field of age. You can use group by to separate the children from the adults by defining a function that groups anyone under 21 into children and anyone over that into old. The end result is an object organized into groups.
data
toys
databases
visualization
children
That's a nice little utility, but one I find myself using even more often is array 2 sorted, along with 2 spliced and 2 reversed. JavaScript already had methods for sort and reversed, but the problem is that they mutate the original array in place. And that's confusing because other methods like map and filter don't do that. Instead, they copy the array and return a new one. With these methods, you can now sort, reverse, and splice an array by tree be in the original as an immutable value, which tends to be the more sane way to write your code. Web developers also got some cool updates in the form of brand new HTML elements. Like, the search tag is a more semantic way to define a search box on a website, which can replace the more generic form tag. That's nice, but the element is way more powerful, which allows you to create actual modal dialogues and then control them with JavaScript using built in methods like show modal and close.
Another nice utility, but that brings us to index 3. After years of begging and pleading with Apple, iOS finally allows push notifications to come from web apps, and that's a huge win for the point 0 0 0 1 percent of website users who actually allow websites to send them push notifications, which is most likely your grandpa who accidentally click the allow button, and now it has no idea how to turn it off.
apple
But now it's time to talk about the fun stuff, frameworks. The world's most popular JavaScript framework, Next. Js, is an entirely a different framework than it was last year, thanks to the app directory, which became stable in May with version 13.4. The most notable difference is that you can now fetch data directly inside React components, thanks to server components, which are React components that can run on the server. The reception to the app directory has been somewhat mixed. On one hand, it has a lot of awesome new features and can simplify your code, but many have complained about it feeling rushed and half baked, kind of like the way they launch video games nowadays where they just get something out the door, then patch it up over the next few years. People have complained about having to use the use client directive everywhere due to breaking existing React libraries. People have complained about the slow dev server, which is powered by Rust, which is weird because anything powered by Rust is supposed to be fast, and people have compared its new server actions feature to PHP, one of the most offensive slurs you can make against a JavaScript framework. But the biggest issue is that running Next. Js is fairly hard to do correctly outside of Vercel, and that's led to projects like OpenNext that take on the tedious job of getting it to run anywhere. Next to still the dominant meta framework, but Nuxt. Js and the Vue ecosystem also had a lot of cool updates in 2023 like its dev tools.
These tools run directly in the browser and make it much here to understand the structure of a complex application. But one thing you may not know about Nuxt is that many of its components are available through the unified JavaScript to rep tools ecosystem. Like, if you don't care about Vue.
software
software development
Js and just want a web server, you can use Nitro to build a fast server with plain JavaScript.
What's funny is I think the Vue. Js ecosystem has changed the least in 2023, and as a consequence, it feels like the most stable and predictable ecosystem. Svelte, on the other hand, got ruined in 2023. In a shocking announcement a couple months ago, Svelte announced a new feature called runes that will dramatically change the developer experience in version 5.
evolution
Instead of defining reactive variables with at. There's now this thing called a rune, which is essentially a compiler macro that tells the Svelte compiler this value is reactive. Svelte is to getting rid of the dollar sign colon syntax and stores with runes like derived and effect. The initial response to these changes were somewhat mixed with some users there's feeling like these changes make Svelte look a lot more like React, which is the type of developer experience they're trying to get away from. But on the other hand, a lot of people love these changes and see them as necessary to evolve framework in the right direction. As a hardcore user of Svelte myself, I'm waiting for the final release of version 5 before I form an opinion. The award for the most changed to framework in 2023 though goes to Angular. It has a long list of new features, but the most notable changes for Angular haters out there would be the new template syntax, which provides a cleaner way a to handle conditionals and loops, replacing things like n g f and n g four. In addition, Angular has also adopted signals, much like all the other frameworks out there, and brings a new feature called deferrable views, which enables declarative lazy loading directly in a template. But most importantly, Angular has a brand new logo, which was really the only thing holding it back from being the world's most popular framework in the past. A lot of crazy changes on the front end, but on the back end, Node. Js has been quietly getting better. With Node. Js version 20, to release a new permissions model, which improves security by controlling which features a script has access to, very much similar to what Deno released a few years ago. And with the release of Node 21. It introduced its own WebSocket client, which is based on the WebSocket API in the browser. The biggest disruptor with back in JavaScript to 2023, though, is BUN. It's a new JavaScript runtime written in Zig that came out with an awesome developer experience and some wild claims about performance. And quite a few bugs were discovered after the initial release, but it still remains a promising new way to do back end JavaScript in the future. And with that, we've looked at 10 different ways with script changed in 2023. But I almost forgot the biggest one of all, h t m x, the framework that showed us that anyone can capture the imagination of the JavaScript ecosystem if you shitpost and meme hard enough on Twitter. But, most importantly, as I've shown here with science, h t m x can actually eliminate a ton of JavaScript compared to to status quo approach taken by all the major frameworks. It's the ideal JavaScript framework for the JavaScript haters. And that's why today, I'm thrilled and honored to present the h t m x team with the JavaScript framework of the year award which is basically the Nobel Prize of JavaScript. Thanks for watching and I will see you in the next one.
2023 has been a wild year. My bank collapsed, Elon bought Twitter, almost all my friends got laid off, all my favorite crypto bros are going to jail. Tesla successfully made it the DeLorean with a Pontiac Aztek, bringing us the Cybertruck, and ChatGPT made me obsolete. But all this good news pales in comparison to the changes web developers have seen in JavaScript land over the last year, where almost every framework decided to reinvent itself in 2023. In today's video, we'll look at 10 recent changes to JavaScript that you may have missed. Every year, new language features get standardized in ECMAScript, at which point they're implemented in browsers. One of my favorite new features this year is object group by. Imagine you have an array of objects where the objects share a similar schema. These might be records from a database where every object has a field of age. You can use group by to separate the children from the adults by defining a function that groups anyone under 21 into children and anyone over that into old. The end result is an object organized into groups. That's a nice little utility, but one I find myself using even more often is array 2 sorted, along with 2 spliced and 2 reversed. JavaScript already had methods for sort and reversed, but the problem is that they mutate the original array in place. And that's confusing because other methods like map and filter don't do that. Instead, they copy the array and return a new one. With these methods, you can now sort, reverse, and splice an array by tree be in the original as an immutable value, which tends to be the more sane way to write your code. Web developers also got some cool updates in the form of brand new HTML elements. Like, the search tag is a more semantic way to define a search box on a website, which can replace the more generic form tag. That's nice, but the element is way more powerful, which allows you to create actual modal dialogues and then control them with JavaScript using built in methods like show modal and close. Another nice utility, but that brings us to index 3. After years of begging and pleading with Apple, iOS finally allows push notifications to come from web apps, and that's a huge win for the point 0 0 0 1 percent of website users who actually allow websites to send them push notifications, which is most likely your grandpa who accidentally click the allow button, and now it has no idea how to turn it off. But now it's time to talk about the fun stuff, frameworks. The world's most popular JavaScript framework, Next. Js, is an entirely a different framework than it was last year, thanks to the app directory, which became stable in May with version 13.4. The most notable difference is that you can now fetch data directly inside React components, thanks to server components, which are React components that can run on the server. The reception to the app directory has been somewhat mixed. On one hand, it has a lot of awesome new features and can simplify your code, but many have complained about it feeling rushed and half baked, kind of like the way they launch video games nowadays where they just get something out the door, then patch it up over the next few years. People have complained about having to use the use client directive everywhere due to breaking existing React libraries. People have complained about the slow dev server, which is powered by Rust, which is weird because anything powered by Rust is supposed to be fast, and people have compared its new server actions feature to PHP, one of the most offensive slurs you can make against a JavaScript framework. But the biggest issue is that running Next. Js is fairly hard to do correctly outside of Vercel, and that's led to projects like OpenNext that take on the tedious job of getting it to run anywhere. Next to still the dominant meta framework, but Nuxt. Js and the Vue ecosystem also had a lot of cool updates in 2023 like its dev tools. These tools run directly in the browser and make it much here to understand the structure of a complex application. But one thing you may not know about Nuxt is that many of its components are available through the unified JavaScript to rep tools ecosystem. Like, if you don't care about Vue. Js and just want a web server, you can use Nitro to build a fast server with plain JavaScript. What's funny is I think the Vue. Js ecosystem has changed the least in 2023, and as a consequence, it feels like the most stable and predictable ecosystem. Svelte, on the other hand, got ruined in 2023. In a shocking announcement a couple months ago, Svelte announced a new feature called runes that will dramatically change the developer experience in version 5. Instead of defining reactive variables with at. There's now this thing called a rune, which is essentially a compiler macro that tells the Svelte compiler this value is reactive. Svelte is to getting rid of the dollar sign colon syntax and stores with runes like derived and effect. The initial response to these changes were somewhat mixed with some users there's feeling like these changes make Svelte look a lot more like React, which is the type of developer experience they're trying to get away from. But on the other hand, a lot of people love these changes and see them as necessary to evolve framework in the right direction. As a hardcore user of Svelte myself, I'm waiting for the final release of version 5 before I form an opinion. The award for the most changed to framework in 2023 though goes to Angular. It has a long list of new features, but the most notable changes for Angular haters out there would be the new template syntax, which provides a cleaner way a to handle conditionals and loops, replacing things like n g f and n g four. In addition, Angular has also adopted signals, much like all the other frameworks out there, and brings a new feature called deferrable views, which enables declarative lazy loading directly in a template. But most importantly, Angular has a brand new logo, which was really the only thing holding it back from being the world's most popular framework in the past. A lot of crazy changes on the front end, but on the back end, Node. Js has been quietly getting better. With Node. Js version 20, to release a new permissions model, which improves security by controlling which features a script has access to, very much similar to what Deno released a few years ago. And with the release of Node 21. It introduced its own WebSocket client, which is based on the WebSocket API in the browser. The biggest disruptor with back in JavaScript to 2023, though, is BUN. It's a new JavaScript runtime written in Zig that came out with an awesome developer experience and some wild claims about performance. And quite a few bugs were discovered after the initial release, but it still remains a promising new way to do back end JavaScript in the future. And with that, we've looked at 10 different ways with script changed in 2023. But I almost forgot the biggest one of all, h t m x, the framework that showed us that anyone can capture the imagination of the JavaScript ecosystem if you shitpost and meme hard enough on Twitter. But, most importantly, as I've shown here with science, h t m x can actually eliminate a ton of JavaScript compared to to status quo approach taken by all the major frameworks. It's the ideal JavaScript framework for the JavaScript haters. And that's why today, I'm thrilled and honored to present the h t m x team with the JavaScript framework of the year award which is basically the Nobel Prize of JavaScript. Thanks for watching and I will see you in the next one.
2023
2023
has
has
been
been
a
a
wild
wild
year.
year
My
my
bank
bank
collapsed,
collapsed
Elon
elon
bought
bought
Twitter,
twitter
almost
almost
all
all
my
my
friends
friends
got
got
laid
laid
off,
off
all
all
my
my
favorite
favorite
crypto
crypto
bros
bros
are
are
going
going
to
to
jail.
jail
Tesla
tesla
successfully
successfully
made
made
it
it
the
the
DeLorean
delorean
with
with
a
a
Pontiac
pontiac
Aztek,
aztek
bringing
bringing
us
us
the
the
Cybertruck,
cybertruck
and
and
ChatGPT
chatgpt
made
made
me
me
obsolete.
obsolete
But
but
all
all
this
this
good
good
news
news
pales
pales
in
in
comparison
comparison
to
to
the
the
changes
changes
web
web
developers
developers
have
have
seen
seen
in
in
JavaScript
javascript
land
land
over
over
the
the
last
last
year,
year
where
where
almost
almost
every
every
framework
framework
decided
decided
to
to
reinvent
reinvent
itself
itself
in
in
2023.
2023
In
in
today's
today's
video,
video
we'll
we'll
look
look
at
at
10
10
recent
recent
changes
changes
to
to
JavaScript
javascript
that
that
you
you
may
may
have
have
missed.
missed
Every
every
year,
year
new
new
language
language
features
features
get
get
standardized
standardized
in
in
ECMAScript,
ecmascript
at
at
which
which
point
point
they're
they're
implemented
implemented
in
in
browsers.
browsers
One
one
of
of
my
my
favorite
favorite
new
new
features
features
this
this
year
year
is
is
object
object
group
group
by.
by
Imagine
imagine
you
you
have
have
an
an
array
array
of
of
objects
objects
where
where
the
the
objects
objects
share
share
a
a
similar
similar
schema.
schema
These
these
might
might
be
be
records
records
from
from
a
a
database
database
where
where
every
every
object
object
has
has
a
a
field
field
of
of
age.
age
You
you
can
can
use
use
group
group
by
by
to
to
separate
separate
the
the
children
children
from
from
the
the
adults
adults
by
by
defining
defining
a
a
function
function
that
that
groups
groups
anyone
anyone
under
under
21
21
into
into
children
children
and
and
anyone
anyone
over
over
that
that
into
into
old.
old
The
the
end
end
result
result
is
is
an
an
object
object
organized
organized
into
into
groups.
groups
That's
that's
a
a
nice
nice
little
little
utility,
utility
but
but
one
one
I
i
find
find
myself
myself
using
using
even
even
more
more
often
often
is
is
array
array
2
2
sorted,
sorted
along
along
with
with
2
2
spliced
spliced
and
and
2
2
reversed.
reversed
JavaScript
javascript
already
already
had
had
methods
methods
for
for
sort
sort
and
and
reversed,
reversed
but
but
the
the
problem
problem
is
is
that
that
they
they
mutate
mutate
the
the
original
original
array
array
in
in
place.
place
And
and
that's
that's
confusing
confusing
because
because
other
other
methods
methods
like
like
map
map
and
and
filter
filter
don't
don't
do
do
that.
that
Instead,
instead
they
they
copy
copy
the
the
array
array
and
and
return
return
a
a
new
new
one.
one
With
with
these
these
methods,
methods
you
you
can
can
now
now
sort,
sort
reverse,
reverse
and
and
splice
splice
an
an
array
array
by
by
tree
tree
be
be
in
in
the
the
original
original
as
as
an
an
immutable
immutable
value,
value
which
which
tends
tends
to
to
be
be
the
the
more
more
sane
sane
way
way
to
to
write
write
your
your
code.
code
Web
web
developers
developers
also
also
got
got
some
some
cool
cool
updates
updates
in
in
the
the
form
form
of
of
brand
brand
new
new
HTML
html
elements.
elements
Like,
like
the
the
search
search
tag
tag
is
is
a
a
more
more
semantic
semantic
way
way
to
to
define
define
a
a
search
search
box
box
on
on
a
a
website,
website
which
which
can
can
replace
replace
the
the
more
more
generic
generic
form
form
tag.
tag
That's
that's
nice,
nice
but
but
the
the
element
element
is
is
way
way
more
more
powerful,
powerful
which
which
allows
allows
you
you
to
to
create
create
actual
actual
modal
modal
dialogues
dialogues
and
and
then
then
control
control
them
them
with
with
JavaScript
javascript
using
using
built
built
in
in
methods
methods
like
like
show
show
modal
modal
and
and
close.
close
Another
another
nice
nice
utility,
utility
but
but
that
that
brings
brings
us
us
to
to
index
index
3.
3
After
after
years
years
of
of
begging
begging
and
and
pleading
pleading
with
with
Apple,
apple
iOS
ios
finally
finally
allows
allows
push
push
notifications
notifications
to
to
come
come
from
from
web
web
apps,
apps
and
and
that's
that's
a
a
huge
huge
win
win
for
for
the
the
point
point
0
0
0
0
0
0
1
1
percent
percent
of
of
website
website
users
users
who
who
actually
actually
allow
allow
websites
websites
to
to
send
send
them
them
push
push
notifications,
notifications
which
which
is
is
most
most
likely
likely
your
your
grandpa
grandpa
who
who
accidentally
accidentally
click
click
the
the
allow
allow
button,
button
and
and
now
now
it
it
has
has
no
no
idea
idea
how
how
to
to
turn
turn
it
it
off.
off
But
but
now
now
it's
it's
time
time
to
to
talk
talk
about
about
the
the
fun
fun
stuff,
stuff
frameworks.
frameworks
The
the
world's
world's
most
most
popular
popular
JavaScript
javascript
framework,
framework
Next.
next
Js,
js
is
is
an
an
entirely
entirely
a
a
different
different
framework
framework
than
than
it
it
was
was
last
last
year,
year
thanks
thanks
to
to
the
the
app
app
directory,
directory
which
which
became
became
stable
stable
in
in
May
may
with
with
version
version
13.4.
13.4
The
the
most
most
notable
notable
difference
difference
is
is
that
that
you
you
can
can
now
now
fetch
fetch
data
data
directly
directly
inside
inside
React
react
components,
components
thanks
thanks
to
to
server
server
components,
components
which
which
are
are
React
react
components
components
that
that
can
can
run
run
on
on
the
the
server.
server
The
the
reception
reception
to
to
the
the
app
app
directory
directory
has
has
been
been
somewhat
somewhat
mixed.
mixed
On
on
one
one
hand,
hand
it
it
has
has
a
a
lot
lot
of
of
awesome
awesome
new
new
features
features
and
and
can
can
simplify
simplify
your
your
code,
code
but
but
many
many
have
have
complained
complained
about
about
it
it
feeling
feeling
rushed
rushed
and
and
half
half
baked,
baked
kind
kind
of
of
like
like
the
the
way
way
they
they
launch
launch
video
video
games
games
nowadays
nowadays
where
where
they
they
just
just
get
get
something
something
out
out
the
the
door,
door
then
then
patch
patch
it
it
up
up
over
over
the
the
next
next
few
few
years.
years
People
people
have
have
complained
complained
about
about
having
having
to
to
use
use
the
the
use
use
client
client
directive
directive
everywhere
everywhere
due
due
to
to
breaking
breaking
existing
existing
React
react
libraries.
libraries
People
people
have
have
complained
complained
about
about
the
the
slow
slow
dev
dev
server,
server
which
which
is
is
powered
powered
by
by
Rust,
rust
which
which
is
is
weird
weird
because
because
anything
anything
powered
powered
by
by
Rust
rust
is
is
supposed
supposed
to
to
be
be
fast,
fast
and
and
people
people
have
have
compared
compared
its
its
new
new
server
server
actions
actions
feature
feature
to
to
PHP,
php
one
one
of
of
the
the
most
most
offensive
offensive
slurs
slurs
you
you
can
can
make
make
against
against
a
a
JavaScript
javascript
framework.
framework
But
but
the
the
biggest
biggest
issue
issue
is
is
that
that
running
running
Next.
next
Js
js
is
is
fairly
fairly
hard
hard
to
to
do
do
correctly
correctly
outside
outside
of
of
Vercel,
vercel
and
and
that's
that's
led
led
to
to
projects
projects
like
like
OpenNext
opennext
that
that
take
take
on
on
the
the
tedious
tedious
job
job
of
of
getting
getting
it
it
to
to
run
run
anywhere.
anywhere
Next
next
to
to
still
still
the
the
dominant
dominant
meta
meta
framework,
framework
but
but
Nuxt.
nuxt
Js
js
and
and
the
the
Vue
vue
ecosystem
ecosystem
also
also
had
had
a
a
lot
lot
of
of
cool
cool
updates
updates
in
in
2023
2023
like
like
its
its
dev
dev
tools.
tools
These
these
tools
tools
run
run
directly
directly
in
in
the
the
browser
browser
and
and
make
make
it
it
much
much
here
here
to
to
understand
understand
the
the
structure
structure
of
of
a
a
complex
complex
application.
application
But
but
one
one
thing
thing
you
you
may
may
not
not
know
know
about
about
Nuxt
nuxt
is
is
that
that
many
many
of
of
its
its
components
components
are
are
available
available
through
through
the
the
unified
unified
JavaScript
javascript
to
to
rep
rep
tools
tools
ecosystem.
ecosystem
Like,
like
if
if
you
you
don't
don't
care
care
about
about
Vue.
vue
Js
js
and
and
just
just
want
want
a
a
web
web
server,
server
you
you
can
can
use
use
Nitro
nitro
to
to
build
build
a
a
fast
fast
server
server
with
with
plain
plain
JavaScript.
javascript
What's
what's
funny
funny
is
is
I
i
think
think
the
the
Vue.
vue
Js
js
ecosystem
ecosystem
has
has
changed
changed
the
the
least
least
in
in
2023,
2023
and
and
as
as
a
a
consequence,
consequence
it
it
feels
feels
like
like
the
the
most
most
stable
stable
and
and
predictable
predictable
ecosystem.
ecosystem
Svelte,
svelte
on
on
the
the
other
other
hand,
hand
got
got
ruined
ruined
in
in
2023.
2023
In
in
a
a
shocking
shocking
announcement
announcement
a
a
couple
couple
months
months
ago,
ago
Svelte
svelte
announced
announced
a
a
new
new
feature
feature
called
called
runes
runes
that
that
will
will
dramatically
dramatically
change
change
the
the
developer
developer
experience
experience
in
in
version
version
5.
5
Instead
instead
of
of
defining
defining
reactive
reactive
variables
variables
with
with
at.
at
There's
there's
now
now
this
this
thing
thing
called
called
a
a
rune,
rune
which
which
is
is
essentially
essentially
a
a
compiler
compiler
macro
macro
that
that
tells
tells
the
the
Svelte
svelte
compiler
compiler
this
this
value
value
is
is
reactive.
reactive
Svelte
svelte
is
is
to
to
getting
getting
rid
rid
of
of
the
the
dollar
dollar
sign
sign
colon
colon
syntax
syntax
and
and
stores
stores
with
with
runes
runes
like
like
derived
derived
and
and
effect.
effect
The
the
initial
initial
response
response
to
to
these
these
changes
changes
were
were
somewhat
somewhat
mixed
mixed
with
with
some
some
users
users
there's
there's
feeling
feeling
like
like
these
these
changes
changes
make
make
Svelte
svelte
look
look
a
a
lot
lot
more
more
like
like
React,
react
which
which
is
is
the
the
type
type
of
of
developer
developer
experience
experience
they're
they're
trying
trying
to
to
get
get
away
away
from.
from
But
but
on
on
the
the
other
other
hand,
hand
a
a
lot
lot
of
of
people
people
love
love
these
these
changes
changes
and
and
see
see
them
them
as
as
necessary
necessary
to
to
evolve
evolve
framework
framework
in
in
the
the
right
right
direction.
direction
As
as
a
a
hardcore
hardcore
user
user
of
of
Svelte
svelte
myself,
myself
I'm
i'm
waiting
waiting
for
for
the
the
final
final
release
release
of
of
version
version
5
5
before
before
I
i
form
form
an
an
opinion.
opinion
The
the
award
award
for
for
the
the
most
most
changed
changed
to
to
framework
framework
in
in
2023
2023
though
though
goes
goes
to
to
Angular.
angular
It
it
has
has
a
a
long
long
list
list
of
of
new
new
features,
features
but
but
the
the
most
most
notable
notable
changes
changes
for
for
Angular
angular
haters
haters
out
out
there
there
would
would
be
be
the
the
new
new
template
template
syntax,
syntax
which
which
provides
provides
a
a
cleaner
cleaner
way
way
a
a
to
to
handle
handle
conditionals
conditionals
and
and
loops,
loops
replacing
replacing
things
things
like
like
n
n
g
g
f
f
and
and
n
n
g
g
four.
four
In
in
addition,
addition
Angular
angular
has
has
also
also
adopted
adopted
signals,
signals
much
much
like
like
all
all
the
the
other
other
frameworks
frameworks
out
out
there,
there
and
and
brings
brings
a
a
new
new
feature
feature
called
called
deferrable
deferrable
views,
views
which
which
enables
enables
declarative
declarative
lazy
lazy
loading
loading
directly
directly
in
in
a
a
template.
template
But
but
most
most
importantly,
importantly
Angular
angular
has
has
a
a
brand
brand
new
new
logo,
logo
which
which
was
was
really
really
the
the
only
only
thing
thing
holding
holding
it
it
back
back
from
from
being
being
the
the
world's
world's
most
most
popular
popular
framework
framework
in
in
the
the
past.
past
A
a
lot
lot
of
of
crazy
crazy
changes
changes
on
on
the
the
front
front
end,
end
but
but
on
on
the
the
back
back
end,
end
Node.
node
Js
js
has
has
been
been
quietly
quietly
getting
getting
better.
better
With
with
Node.
node
Js
js
version
version
20,
20
to
to
release
release
a
a
new
new
permissions
permissions
model,
model
which
which
improves
improves
security
security
by
by
controlling
controlling
which
which
features
features
a
a
script
script
has
has
access
access
to,
to
very
very
much
much
similar
similar
to
to
what
what
Deno
deno
released
released
a
a
few
few
years
years
ago.
ago
And
and
with
with
the
the
release
release
of
of
Node
node
21.
21
It
it
introduced
introduced
its
its
own
own
WebSocket
websocket
client,
client
which
which
is
is
based
based
on
on
the
the
WebSocket
websocket
API
api
in
in
the
the
browser.
browser
The
the
biggest
biggest
disruptor
disruptor
with
with
back
back
in
in
JavaScript
javascript
to
to
2023,
2023
though,
though
is
is
BUN.
bun
It's
it's
a
a
new
new
JavaScript
javascript
runtime
runtime
written
written
in
in
Zig
zig
that
that
came
came
out
out
with
with
an
an
awesome
awesome
developer
developer
experience
experience
and
and
some
some
wild
wild
claims
claims
about
about
performance.
performance
And
and
quite
quite
a
a
few
few
bugs
bugs
were
were
discovered
discovered
after
after
the
the
initial
initial
release,
release
but
but
it
it
still
still
remains
remains
a
a
promising
promising
new
new
way
way
to
to
do
do
back
back
end
end
JavaScript
javascript
in
in
the
the
future.
future
And
and
with
with
that,
that
we've
we've
looked
looked
at
at
10
10
different
different
ways
ways
with
with
script
script
changed
changed
in
in
2023.
2023
But
but
I
i
almost
almost
forgot
forgot
the
the
biggest
biggest
one
one
of
of
all,
all
h
h
t
t
m
m
x,
x
the
the
framework
framework
that
that
showed
showed
us
us
that
that
anyone
anyone
can
can
capture
capture
the
the
imagination
imagination
of
of
the
the
JavaScript
javascript
ecosystem
ecosystem
if
if
you
you
shitpost
shitpost
and
and
meme
meme
hard
hard
enough
enough
on
on
Twitter.
twitter
But,
but
most
most
importantly,
importantly
as
as
I've
i've
shown
shown
here
here
with
with
science,
science
h
h
t
t
m
m
x
x
can
can
actually
actually
eliminate
eliminate
a
a
ton
ton
of
of
JavaScript
javascript
compared
compared
to
to
to
to
status
status
quo
quo
approach
approach
taken
taken
by
by
all
all
the
the
major
major
frameworks.
frameworks
It's
it's
the
the
ideal
ideal
JavaScript
javascript
framework
framework
for
for
the
the
JavaScript
javascript
haters.
haters
And
and
that's
that's
why
why
today,
today
I'm
i'm
thrilled
thrilled
and
and
honored
honored
to
to
present
present
the
the
h
h
t
t
m
m
x
x
team
team
with
with
the
the
JavaScript
javascript
framework
framework
of
of
the
the
year
year
award
award
which
which
is
is
basically
basically
the
the
Nobel
nobel
Prize
prize
of
of
JavaScript.
javascript
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 speaker discusses 10 recent changes to JavaScript, including the implementation of new features in browsers and the development of a new framework called 2021. They also mention updates to the front-end and back-end JavaScript, including a new version of the h t m x framework and a new version of 2021. The speaker concludes by expressing excitement for the h t m x team and their upcoming releases.
10 JavaScript changes you missed in 2023
2023 has been a wild year. My bank collapsed, Elon bought Twitter, almost all my friends got laid off, all my favorite crypto bros are going to jail. Tesla successfully made it the DeLorean with a Pontiac Aztek, bringing us the Cybertruck, and ChatGPT made me obsolete. But all this good news pales in comparison to the changes web developers have seen in JavaScript land over the last year, where almost every framework decided to reinvent itself in 2023. In today's video, we'll look at 10 recent changes to JavaScript that you may have missed. Every year, new language features get standardized in ECMAScript, at which point they're implemented in browsers. One of my favorite new features this year is object group by. Imagine you have an array of objects where the objects share a similar schema. These might be records from a database where every object has a field of age. You can use group by to separate the children from the adults by defining a function that groups anyone under 21 into children and anyone over that into old. The end result is an object organized into groups. That's a nice little utility, but one I find myself using even more often is array 2 sorted, along with 2 spliced and 2 reversed. JavaScript already had methods for sort and reversed, but the problem is that they mutate the original array in place. And that's confusing because other methods like map and filter don't do that. Instead, they copy the array and return a new one. With these methods, you can now sort, reverse, and splice an array by tree be in the original as an immutable value, which tends to be the more sane way to write your code. Web developers also got some cool updates in the form of brand new HTML elements. Like, the search tag is a more semantic way to define a search box on a website, which can replace the more generic form tag. That's nice, but the element is way more powerful, which allows you to create actual modal dialogues and then control them with JavaScript using built in methods like show modal and close. Another nice utility, but that brings us to index 3. After years of begging and pleading with Apple, iOS finally allows push notifications to come from web apps, and that's a huge win for the point 0 0 0 1 percent of website users who actually allow websites to send them push notifications, which is most likely your grandpa who accidentally click the allow button, and now it has no idea how to turn it off. But now it's time to talk about the fun stuff, frameworks. The world's most popular JavaScript framework, Next. Js, is an entirely a different framework than it was last year, thanks to the app directory, which became stable in May with version 13.4. The most notable difference is that you can now fetch data directly inside React components, thanks to server components, which are React components that can run on the server. The reception to the app directory has been somewhat mixed. On one hand, it has a lot of awesome new features and can simplify your code, but many have complained about it feeling rushed and half baked, kind of like the way they launch video games nowadays where they just get something out the door, then patch it up over the next few years. People have complained about having to use the use client directive everywhere due to breaking existing React libraries. People have complained about the slow dev server, which is powered by Rust, which is weird because anything powered by Rust is supposed to be fast, and people have compared its new server actions feature to PHP, one of the most offensive slurs you can make against a JavaScript framework. But the biggest issue is that running Next. Js is fairly hard to do correctly outside of Vercel, and that's led to projects like OpenNext that take on the tedious job of getting it to run anywhere. Next to still the dominant meta framework, but Nuxt. Js and the Vue ecosystem also had a lot of cool updates in 2023 like its dev tools. These tools run directly in the browser and make it much here to understand the structure of a complex application. But one thing you may not know about Nuxt is that many of its components are available through the unified JavaScript to rep tools ecosystem. Like, if you don't care about Vue. Js and just want a web server, you can use Nitro to build a fast server with plain JavaScript. What's funny is I think the Vue. Js ecosystem has changed the least in 2023, and as a consequence, it feels like the most stable and predictable ecosystem. Svelte, on the other hand, got ruined in 2023. In a shocking announcement a couple months ago, Svelte announced a new feature called runes that will dramatically change the developer experience in version 5. Instead of defining reactive variables with at. There's now this thing called a rune, which is essentially a compiler macro that tells the Svelte compiler this value is reactive. Svelte is to getting rid of the dollar sign colon syntax and stores with runes like derived and effect. The initial response to these changes were somewhat mixed with some users there's feeling like these changes make Svelte look a lot more like React, which is the type of developer experience they're trying to get away from. But on the other hand, a lot of people love these changes and see them as necessary to evolve framework in the right direction. As a hardcore user of Svelte myself, I'm waiting for the final release of version 5 before I form an opinion. The award for the most changed to framework in 2023 though goes to Angular. It has a long list of new features, but the most notable changes for Angular haters out there would be the new template syntax, which provides a cleaner way a to handle conditionals and loops, replacing things like n g f and n g four. In addition, Angular has also adopted signals, much like all the other frameworks out there, and brings a new feature called deferrable views, which enables declarative lazy loading directly in a template. But most importantly, Angular has a brand new logo, which was really the only thing holding it back from being the world's most popular framework in the past. A lot of crazy changes on the front end, but on the back end, Node. Js has been quietly getting better. With Node. Js version 20, to release a new permissions model, which improves security by controlling which features a script has access to, very much similar to what Deno released a few years ago. And with the release of Node 21. It introduced its own WebSocket client, which is based on the WebSocket API in the browser. The biggest disruptor with back in JavaScript to 2023, though, is BUN. It's a new JavaScript runtime written in Zig that came out with an awesome developer experience and some wild claims about performance. And quite a few bugs were discovered after the initial release, but it still remains a promising new way to do back end JavaScript in the future. And with that, we've looked at 10 different ways with script changed in 2023. But I almost forgot the biggest one of all, h t m x, the framework that showed us that anyone can capture the imagination of the JavaScript ecosystem if you shitpost and meme hard enough on Twitter. But, most importantly, as I've shown here with science, h t m x can actually eliminate a ton of JavaScript compared to to status quo approach taken by all the major frameworks. It's the ideal JavaScript framework for the JavaScript haters. And that's why today, I'm thrilled and honored to present the h t m x team with the JavaScript framework of the year award which is basically the Nobel Prize of JavaScript. Thanks for watching and I will see you in the next one.
The speaker discusses 10 recent changes to JavaScript, including the implementation of new features in browsers and the development of a new framework called 2021. They also mention updates to the front-end and back-end JavaScript, including a new version of the h t m x framework and a new version of 2021. The speaker concludes by expressing excitement for the h t m x team and their upcoming releases.

        [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 : 10 JavaScript changes you missed in 2023 
        and a small summary : The speaker discusses 10 recent changes to JavaScript, including the implementation of new features in browsers and the development of a new framework called 2021. They also mention updates to the front-end and back-end JavaScript, including a new version of the h t m x framework and a new version of 2021. The speaker concludes by expressing excitement for the h t m x team and their upcoming releases.
        [/INST]
        
        Generate the video : 2023 has been a wild year. My bank collapsed, Elon bought Twitter, almost all my friends got laid off, all my favorite crypto bros are going to jail. Tesla successfully made it the DeLorean with a Pontiac Aztek, bringing us the Cybertruck, and ChatGPT made me obsolete. But all this good news pales in comparison to the changes web developers have seen in JavaScript land over the last year, where almost every framework decided to reinvent itself in 2023. In today's video, we'll look at 10 recent changes to JavaScript that you may have missed. Every year, new language features get standardized in ECMAScript, at which point they're implemented in browsers. One of my favorite new features this year is object group by. Imagine you have an array of objects where the objects share a similar schema. These might be records from a database where every object has a field of age. You can use group by to separate the children from the adults by defining a function that groups anyone under 21 into children and anyone over that into old. The end result is an object organized into groups. That's a nice little utility, but one I find myself using even more often is array 2 sorted, along with 2 spliced and 2 reversed. JavaScript already had methods for sort and reversed, but the problem is that they mutate the original array in place. And that's confusing because other methods like map and filter don't do that. Instead, they copy the array and return a new one. With these methods, you can now sort, reverse, and splice an array by tree be in the original as an immutable value, which tends to be the more sane way to write your code. Web developers also got some cool updates in the form of brand new HTML elements. Like, the search tag is a more semantic way to define a search box on a website, which can replace the more generic form tag. That's nice, but the element is way more powerful, which allows you to create actual modal dialogues and then control them with JavaScript using built in methods like show modal and close. Another nice utility, but that brings us to index 3. After years of begging and pleading with Apple, iOS finally allows push notifications to come from web apps, and that's a huge win for the point 0 0 0 1 percent of website users who actually allow websites to send them push notifications, which is most likely your grandpa who accidentally click the allow button, and now it has no idea how to turn it off. But now it's time to talk about the fun stuff, frameworks. The world's most popular JavaScript framework, Next. Js, is an entirely a different framework than it was last year, thanks to the app directory, which became stable in May with version 13.4. The most notable difference is that you can now fetch data directly inside React components, thanks to server components, which are React components that can run on the server. The reception to the app directory has been somewhat mixed. On one hand, it has a lot of awesome new features and can simplify your code, but many have complained about it feeling rushed and half baked, kind of like the way they launch video games nowadays where they just get something out the door, then patch it up over the next few years. People have complained about having to use the use client directive everywhere due to breaking existing React libraries. People have complained about the slow dev server, which is powered by Rust, which is weird because anything powered by Rust is supposed to be fast, and people have compared its new server actions feature to PHP, one of the most offensive slurs you can make against a JavaScript framework. But the biggest issue is that running Next. Js is fairly hard to do correctly outside of Vercel, and that's led to projects like OpenNext that take on the tedious job of getting it to run anywhere. Next to still the dominant meta framework, but Nuxt. Js and the Vue ecosystem also had a lot of cool updates in 2023 like its dev tools. These tools run directly in the browser and make it much here to understand the structure of a complex application. But one thing you may not know about Nuxt is that many of its components are available through the unified JavaScript to rep tools ecosystem. Like, if you don't care about Vue. Js and just want a web server, you can use Nitro to build a fast server with plain JavaScript. What's funny is I think the Vue. Js ecosystem has changed the least in 2023, and as a consequence, it feels like the most stable and predictable ecosystem. Svelte, on the other hand, got ruined in 2023. In a shocking announcement a couple months ago, Svelte announced a new feature called runes that will dramatically change the developer experience in version 5. Instead of defining reactive variables with at. There's now this thing called a rune, which is essentially a compiler macro that tells the Svelte compiler this value is reactive. Svelte is to getting rid of the dollar sign colon syntax and stores with runes like derived and effect. The initial response to these changes were somewhat mixed with some users there's feeling like these changes make Svelte look a lot more like React, which is the type of developer experience they're trying to get away from. But on the other hand, a lot of people love these changes and see them as necessary to evolve framework in the right direction. As a hardcore user of Svelte myself, I'm waiting for the final release of version 5 before I form an opinion. The award for the most changed to framework in 2023 though goes to Angular. It has a long list of new features, but the most notable changes for Angular haters out there would be the new template syntax, which provides a cleaner way a to handle conditionals and loops, replacing things like n g f and n g four. In addition, Angular has also adopted signals, much like all the other frameworks out there, and brings a new feature called deferrable views, which enables declarative lazy loading directly in a template. But most importantly, Angular has a brand new logo, which was really the only thing holding it back from being the world's most popular framework in the past. A lot of crazy changes on the front end, but on the back end, Node. Js has been quietly getting better. With Node. Js version 20, to release a new permissions model, which improves security by controlling which features a script has access to, very much similar to what Deno released a few years ago. And with the release of Node 21. It introduced its own WebSocket client, which is based on the WebSocket API in the browser. The biggest disruptor with back in JavaScript to 2023, though, is BUN. It's a new JavaScript runtime written in Zig that came out with an awesome developer experience and some wild claims about performance. And quite a few bugs were discovered after the initial release, but it still remains a promising new way to do back end JavaScript in the future. And with that, we've looked at 10 different ways with script changed in 2023. But I almost forgot the biggest one of all, h t m x, the framework that showed us that anyone can capture the imagination of the JavaScript ecosystem if you shitpost and meme hard enough on Twitter. But, most importantly, as I've shown here with science, h t m x can actually eliminate a ton of JavaScript compared to to status quo approach taken by all the major frameworks. It's the ideal JavaScript framework for the JavaScript haters. And that's why today, I'm thrilled and honored to present the h t m x team with the JavaScript framework of the year award which is basically the Nobel Prize of JavaScript. Thanks for watching and I will see you in the next one.
        