Instructor: Now that you're familiar
with the fundamentals of the Javascript language,
and before moving on,
we need to quickly talk about Javascript versions.
Okay?
Now I could have probably talked about this
right at the beginning of the course.
But I just wanted to have you writing some code
as fast as possible.
Anyway, it's very important to talk about
Javascript versions, because that's just something
that every modern Javascript developer
should be aware of.
And also because you will see these topics
coming up in the developer community all the time.
So you wanna be able to understand what's going on.
So in order to do that,
let's just very briefly talk about
the history of Javascript.
So, Javascript was first released
and called LiveScript in 1995.
So, a long time ago.
But the name was then very quickly
changed to JavaScript.
The reason for the change was just
to attract developers of another language.
It was very popular at the time,
and that's Java.
So the Java in Javascript was just
for marking reasons, really.
Because the language itself has almost nothing
to do with Java.
Some beginners think that this is the case, but no.
Javascript and Java are actually
two completely different languages.
Now, one year later, the language was submitted
to an organization called Ecma International
in order to create a new standard.
And so EcmaScript One, or ES1,
became the first version of the Javascript language.
In the real world, we usually use the term EcmaScript
to refer to the standard
while Javascript is used when we talk
about the language in practice.
Now, fast forward to 2009.
ES5 was released with a lot of new features.
However, it took many years for browsers
to implement all these changes.
And finally, the much-awaited new version ES6,
was launched in June 2015.
And it was the biggest update to the language ever,
with a ton of new features.
This was, or still is,
a really big dea for Javascript,
and for the whole developer community.
Now you will also see ES6 being called ES2015,
which is actually the official name.
But most people just call it ES6.
So that's what I'm gonna do here as well.
Actually, the reason for ES6 being called ES2015
is that in 2015, we changed to an annual release cycle.
So, a new version of the language
is now released every year,
with just a few new features per year,
instead of shipping a huge new version
every couple of years.
So this way, it's much easier for everyone
to keep up to date.
Okay? So it's much easier for us developers like this.
So in 2016, ES2016, or ES7, was released.
ES2017 in 2017, and, like this,
it will continue into the future.
So what does Javascript look like today,
and which version should and can we use?
So first off, ES5 is, of course,
fully supported in all browsers today.
So that's the one that is safe to be used.
Now about the newer versions, ES6, ES7 and ES8,
as of mid-2018, they are all actually
quite well supported in all modern browsers.
But the problem with this is
that we can't just assume that our users
use these modern browsers,
at least not all of them.
The old browsers will, of course,
not understand the ES6 syntax at all.
And neither ES7 and ES8, and so on and so forth.
So these old browsers are a big problem for us.
Now, the solution to this problem is to
basically convert these modern Javascript versions
back to ES5, using a process called transpiling
and also polyfilling.
I'm gonna teach you how to do that
by the end of the course, okay?
If you wanna stay up-to-date
with what features are currently supported
in which browser, you can just check out
the ES6 compatibility table,
and the link is on my resources page.
Next up, there are the future versions
of the language, like ES9, ES10, and so on.
These future versions, together,
are many times called ESNext.
Now some features of these future versions
are actually already implemented in some browsers.
So you could use them by transpiling
and polyfilling your code today.
But to be honest, I wouldn't really advise
you to do so at this point.
Because I believe that ES6, ES7, and ES8 together
are powerful enough to bring the Javascript
development experience to a whole new level already,
as you will see a bit later in the course.
All right?
So, in this course, we're gonna start by using
ES5 in the first part of the course,
and then move to ES6 Plus,
so ES6, ES7, and ES8, in the second part
of the course.
Okay?
So here's now that's gonna work.
So we already talked about the Javascript fundamentals
using ES5, and we will continue using ES5
to look behind the scenes of Javascript,
do some DOM manipulations,
learn all about updates and functions,
and code up a huge, real project.
From there, we will then start using ES6,
with an overview of what's new in the language.
Then we're gonna talk about asynchronous Javascript,
modern development setups,
and code an even bigger and cooler
real-world app,
all using ES6, ES7, and ES8.
All right?
Now, some people don't understand why I even
bother showing you ES5 in this course at all.
And actually have criticized me for doing so.
So here are a few reasons which I hope
will make sense to you.
So I truly believe that in 2018, and even 2019,
it's still a good idea to learn
the fundamentals of Javascript in ES5,
and then move to newer Javascript versions from there.
Simply due to the fact that you will always
have to understand ES5 in the future.
That is because many tutorials
and example codes that you will find online
are still written in ES5 today.
Plus as a developer, sometimes you'll have to work
on older codebases, which will most certainly
be written in ES5 or even older.
All in all, I just believe that you will be
a better developer if you start understanding
how ES5 works.
And only then move up to ES6 or newer.
Because ES6 has some abstractions,
like classes, that kind of hide
how the language actually works behind the scenes.
All right?
So I hope that this makes a lot of sense to you.
And so let's now move on right to the next section.