Deno is a brand new JavaScript runtime, similar to Node.js. Use it to develop secure server-side apps with built-in TypeScript support, ES modules, and promise-based APIs. 

Learn more at https://deno.land

#javascript #nodejs #100SecondsOfCode

Install the quiz app 🤓

iOS https://itunes.apple.com/us/app/fireship/id1462592372?mt=8
Android https://play.google.com/store/apps/details?id=io.fireship.quizapp

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

My VS Code Theme

- Atom One Dark 
- vscode-icons
- Fira Code Font
2024-02-04T06:13:40.957Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
f532ef8b-a5f0-4995-a4b7-06833addc056
e40111ae4e6b18d84bb85129ad57f99745bf1460030bf3aa6a1720db1ffff97a
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
Deno, a brand new way to write server side JavaScript.
It solves many of the same problems as Node.
Js and was even created by the same guy.
Like Node, it uses the v eight JavaScript engine under the hood, but the rest of the runtime is implemented in Rust and TypeScript.
Our journey into Deno land begins in a single TypeScript file.
In this file, we have access to all the types in the runtime, which means we can write strongly typed code and get documentation and IntelliSense directly in the IDE without ever needing to touch TS config file.
The features in the runtime can be accessed from this Deno namespace.
Let's console log the current working directory of the file system.
We can execute our script with deno run from the command line.
But you'll notice that there's an error and that's because Deno is secure by default.
You, the developer, need to give permission to perform different actions in the runtime.
In this case, we can use the allow read flag to allow this operation.
Security is great, but my favorite thing is how everything asynchronous is promise based.
We can make a network request using the fetch API just like we would in the browser.
And because it supports top level await, we don't even need an async We can start resolving promises without any extra boilerplate code.
Deno attempts to make your code as browser compatible as possible.
It contains a window object with life cycle events that you can Listen to allowing developers to more easily write code that can interop between browsers and servers.
Not to mention, it can also execute web assembly binaries.
But one thing that won't work in Deno are your npm packages.
Instead, you import packages using the modern es module syntax, with remote modules being referenced by their URL.
When you run your script for the first time, it will download this code locally and cache it.
There's no package JSON and code can be referenced from any URL, very similar to how things work in the browser.
Deno provides a set of standard modules to solve common use cases.
For example, we can import serve from the HTTP module.
We can use it to create a server that's treated as an async iterable.
We can then await every request from the server and respond to it accordingly.
And that's an awesome starting point for a server side JavaScript app.
Now, Deno 1.0 just hit release candidate 1.
So if you start using it today, consider yourself an early adopter.
Do you think Deno's the future of server side JavaScript?
Let me know in the comments below.
Thanks for watching.
Hit the like button, and I will see you in the next one.

Speaker 0: Deno, a brand new way to write server side JavaScript. It solves many of the same problems as Node. Js and was even created by the same guy. Like Node, it uses the v eight JavaScript engine under the hood, but the rest of the runtime is implemented in Rust and TypeScript. Our journey into Deno land begins in a single TypeScript file.

In this file, we have access to all the types in the runtime, which means we can write strongly typed code and get documentation and IntelliSense directly in the IDE without ever needing to touch TS config file. The features in the runtime can be accessed from this Deno namespace. Let's console log the current working directory of the file system. We can execute our script with deno run from the command line. But you'll notice that there's an error and that's because Deno is secure by default.

You, the developer, need to give permission to perform different actions in the runtime. In this case, we can use the allow read flag to allow this operation. Security is great, but my favorite thing is how everything asynchronous is promise based. We can make a network request using the fetch API just like we would in the browser. And because it supports top level await, we don't even need an async We can start resolving promises without any extra boilerplate code.

Deno attempts to make your code as browser compatible as possible. It contains a window object with life cycle events that you can Listen to allowing developers to more easily write code that can interop between browsers and servers. Not to mention, it can also execute web assembly binaries. But one thing that won't work in Deno are your npm packages. Instead, you import packages using the modern es module syntax, with remote modules being referenced by their URL.

When you run your script for the first time, it will download this code locally and cache it. There's no package JSON and code can be referenced from any URL, very similar to how things work in the browser. Deno provides a set of standard modules to solve common use cases. For example, we can import serve from the HTTP module. We can use it to create a server that's treated as an async iterable.

We can then await every request from the server and respond to it accordingly. And that's an awesome starting point for a server side JavaScript app. Now, Deno 1.0 just hit release candidate 1. So if you start using it today, consider yourself an early adopter. Do you think Deno's the future of server side JavaScript?

Let me know in the comments below. Thanks for watching. Hit the like button, and I will see you in the next one.
Deno, a brand new way to write server side JavaScript. It solves many of the same problems as Node. Js and was even created by the same guy. Like Node, it uses the v eight JavaScript engine under the hood, but the rest of the runtime is implemented in Rust and TypeScript. Our journey into Deno land begins in a single TypeScript file.
In this file, we have access to all the types in the runtime, which means we can write strongly typed code and get documentation and IntelliSense directly in the IDE without ever needing to touch TS config file. The features in the runtime can be accessed from this Deno namespace.
programming
Let's console log the current working directory of the file system. We can execute our script with deno run from the command line.
But you'll notice that there's an error and that's because Deno is secure by default. You, the developer, need to give permission to perform different actions in the runtime. In this case, we can use the allow read flag to allow this operation. Security is great, but my favorite thing is how everything asynchronous is promise based.
security
We can make a network request using the fetch API just like we would in the browser. And because it supports top level await, we don't even need an async We can start resolving promises without any extra boilerplate code. Deno attempts to make your code as browser compatible as possible. It contains a window object with life cycle events that you can Listen to allowing developers to more easily write code that can interop between browsers and servers. Not to mention, it can also execute web assembly binaries. But one thing that won't work in Deno are your npm packages. Instead, you import packages using the modern es module syntax, with remote modules being referenced by their URL. When you run your script for the first time, it will download this code locally and cache it. There's no package JSON and code can be referenced from any URL, very similar to how things work in the browser. Deno provides a set of standard modules to solve common use cases. For example, we can import serve from the HTTP module. We can use it to create a server that's treated as an async iterable. We can then await every request from the server and respond to it accordingly. And that's an awesome starting point for a server side JavaScript app. Now, Deno 1.0 just hit release candidate 1. So if you start using it today, consider yourself an early adopter. Do you think Deno's the future of server side JavaScript? Let me know in the comments below. Thanks for watching. Hit the like button, and I will see you in the next one.
Deno, a brand new way to write server side JavaScript. It solves many of the same problems as Node. Js and was even created by the same guy. Like Node, it uses the v eight JavaScript engine under the hood, but the rest of the runtime is implemented in Rust and TypeScript. Our journey into Deno land begins in a single TypeScript file. In this file, we have access to all the types in the runtime, which means we can write strongly typed code and get documentation and IntelliSense directly in the IDE without ever needing to touch TS config file. The features in the runtime can be accessed from this Deno namespace. Let's console log the current working directory of the file system. We can execute our script with deno run from the command line. But you'll notice that there's an error and that's because Deno is secure by default. You, the developer, need to give permission to perform different actions in the runtime. In this case, we can use the allow read flag to allow this operation. Security is great, but my favorite thing is how everything asynchronous is promise based. We can make a network request using the fetch API just like we would in the browser. And because it supports top level await, we don't even need an async We can start resolving promises without any extra boilerplate code. Deno attempts to make your code as browser compatible as possible. It contains a window object with life cycle events that you can Listen to allowing developers to more easily write code that can interop between browsers and servers. Not to mention, it can also execute web assembly binaries. But one thing that won't work in Deno are your npm packages. Instead, you import packages using the modern es module syntax, with remote modules being referenced by their URL. When you run your script for the first time, it will download this code locally and cache it. There's no package JSON and code can be referenced from any URL, very similar to how things work in the browser. Deno provides a set of standard modules to solve common use cases. For example, we can import serve from the HTTP module. We can use it to create a server that's treated as an async iterable. We can then await every request from the server and respond to it accordingly. And that's an awesome starting point for a server side JavaScript app. Now, Deno 1.0 just hit release candidate 1. So if you start using it today, consider yourself an early adopter. Do you think Deno's the future of server side JavaScript? Let me know in the comments below. Thanks for watching. Hit the like button, and I will see you in the next one.
Deno,
deno
a
a
brand
brand
new
new
way
way
to
to
write
write
server
server
side
side
JavaScript.
javascript
It
it
solves
solves
many
many
of
of
the
the
same
same
problems
problems
as
as
Node.
node
Js
js
and
and
was
was
even
even
created
created
by
by
the
the
same
same
guy.
guy
Like
like
Node,
node
it
it
uses
uses
the
the
v
v
eight
eight
JavaScript
javascript
engine
engine
under
under
the
the
hood,
hood
but
but
the
the
rest
rest
of
of
the
the
runtime
runtime
is
is
implemented
implemented
in
in
Rust
rust
and
and
TypeScript.
typescript
Our
our
journey
journey
into
into
Deno
deno
land
land
begins
begins
in
in
a
a
single
single
TypeScript
typescript
file.
file
In
in
this
this
file,
file
we
we
have
have
access
access
to
to
all
all
the
the
types
types
in
in
the
the
runtime,
runtime
which
which
means
means
we
we
can
can
write
write
strongly
strongly
typed
typed
code
code
and
and
get
get
documentation
documentation
and
and
IntelliSense
intellisense
directly
directly
in
in
the
the
IDE
ide
without
without
ever
ever
needing
needing
to
to
touch
touch
TS
ts
config
config
file.
file
The
the
features
features
in
in
the
the
runtime
runtime
can
can
be
be
accessed
accessed
from
from
this
this
Deno
deno
namespace.
namespace
Let's
let's
console
console
log
log
the
the
current
current
working
working
directory
directory
of
of
the
the
file
file
system.
system
We
we
can
can
execute
execute
our
our
script
script
with
with
deno
deno
run
run
from
from
the
the
command
command
line.
line
But
but
you'll
you'll
notice
notice
that
that
there's
there's
an
an
error
error
and
and
that's
that's
because
because
Deno
deno
is
is
secure
secure
by
by
default.
default
You,
you
the
the
developer,
developer
need
need
to
to
give
give
permission
permission
to
to
perform
perform
different
different
actions
actions
in
in
the
the
runtime.
runtime
In
in
this
this
case,
case
we
we
can
can
use
use
the
the
allow
allow
read
read
flag
flag
to
to
allow
allow
this
this
operation.
operation
Security
security
is
is
great,
great
but
but
my
my
favorite
favorite
thing
thing
is
is
how
how
everything
everything
asynchronous
asynchronous
is
is
promise
promise
based.
based
We
we
can
can
make
make
a
a
network
network
request
request
using
using
the
the
fetch
fetch
API
api
just
just
like
like
we
we
would
would
in
in
the
the
browser.
browser
And
and
because
because
it
it
supports
supports
top
top
level
level
await,
await
we
we
don't
don't
even
even
need
need
an
an
async
async
We
we
can
can
start
start
resolving
resolving
promises
promises
without
without
any
any
extra
extra
boilerplate
boilerplate
code.
code
Deno
deno
attempts
attempts
to
to
make
make
your
your
code
code
as
as
browser
browser
compatible
compatible
as
as
possible.
possible
It
it
contains
contains
a
a
window
window
object
object
with
with
life
life
cycle
cycle
events
events
that
that
you
you
can
can
Listen
listen
to
to
allowing
allowing
developers
developers
to
to
more
more
easily
easily
write
write
code
code
that
that
can
can
interop
interop
between
between
browsers
browsers
and
and
servers.
servers
Not
not
to
to
mention,
mention
it
it
can
can
also
also
execute
execute
web
web
assembly
assembly
binaries.
binaries
But
but
one
one
thing
thing
that
that
won't
won't
work
work
in
in
Deno
deno
are
are
your
your
npm
npm
packages.
packages
Instead,
instead
you
you
import
import
packages
packages
using
using
the
the
modern
modern
es
es
module
module
syntax,
syntax
with
with
remote
remote
modules
modules
being
being
referenced
referenced
by
by
their
their
URL.
url
When
when
you
you
run
run
your
your
script
script
for
for
the
the
first
first
time,
time
it
it
will
will
download
download
this
this
code
code
locally
locally
and
and
cache
cache
it.
it
There's
there's
no
no
package
package
JSON
json
and
and
code
code
can
can
be
be
referenced
referenced
from
from
any
any
URL,
url
very
very
similar
similar
to
to
how
how
things
things
work
work
in
in
the
the
browser.
browser
Deno
deno
provides
provides
a
a
set
set
of
of
standard
standard
modules
modules
to
to
solve
solve
common
common
use
use
cases.
cases
For
for
example,
example
we
we
can
can
import
import
serve
serve
from
from
the
the
HTTP
http
module.
module
We
we
can
can
use
use
it
it
to
to
create
create
a
a
server
server
that's
that's
treated
treated
as
as
an
an
async
async
iterable.
iterable
We
we
can
can
then
then
await
await
every
every
request
request
from
from
the
the
server
server
and
and
respond
respond
to
to
it
it
accordingly.
accordingly
And
and
that's
that's
an
an
awesome
awesome
starting
starting
point
point
for
for
a
a
server
server
side
side
JavaScript
javascript
app.
app
Now,
now
Deno
deno
1.0
1.0
just
just
hit
hit
release
release
candidate
candidate
1.
1
So
so
if
if
you
you
start
start
using
using
it
it
today,
today
consider
consider
yourself
yourself
an
an
early
early
adopter.
adopter
Do
do
you
you
think
think
Deno's
deno's
the
the
future
future
of
of
server
server
side
side
JavaScript?
javascript
Let
let
me
me
know
know
in
in
the
the
comments
comments
below.
below
Thanks
thanks
for
for
watching.
watching
Hit
hit
the
the
like
like
button,
button
and
and
I
i
will
will
see
see
you
you
in
in
the
the
next
next
one.
one
success
The speaker explains that Deno is a new way to write server side JavaScript, using a single TypeScript file and accessing all the types in the denies. They also discuss the security of the file system and the use of a command line for resolving promises. The speaker recommends using the "any tab" option to import and customize modules, and mentions that Deno is the future of server side JavaScript.
Deno in 100 Seconds
Deno, a brand new way to write server side JavaScript. It solves many of the same problems as Node. Js and was even created by the same guy. Like Node, it uses the v eight JavaScript engine under the hood, but the rest of the runtime is implemented in Rust and TypeScript. Our journey into Deno land begins in a single TypeScript file. In this file, we have access to all the types in the runtime, which means we can write strongly typed code and get documentation and IntelliSense directly in the IDE without ever needing to touch TS config file. The features in the runtime can be accessed from this Deno namespace. Let's console log the current working directory of the file system. We can execute our script with deno run from the command line. But you'll notice that there's an error and that's because Deno is secure by default. You, the developer, need to give permission to perform different actions in the runtime. In this case, we can use the allow read flag to allow this operation. Security is great, but my favorite thing is how everything asynchronous is promise based. We can make a network request using the fetch API just like we would in the browser. And because it supports top level await, we don't even need an async We can start resolving promises without any extra boilerplate code. Deno attempts to make your code as browser compatible as possible. It contains a window object with life cycle events that you can Listen to allowing developers to more easily write code that can interop between browsers and servers. Not to mention, it can also execute web assembly binaries. But one thing that won't work in Deno are your npm packages. Instead, you import packages using the modern es module syntax, with remote modules being referenced by their URL. When you run your script for the first time, it will download this code locally and cache it. There's no package JSON and code can be referenced from any URL, very similar to how things work in the browser. Deno provides a set of standard modules to solve common use cases. For example, we can import serve from the HTTP module. We can use it to create a server that's treated as an async iterable. We can then await every request from the server and respond to it accordingly. And that's an awesome starting point for a server side JavaScript app. Now, Deno 1.0 just hit release candidate 1. So if you start using it today, consider yourself an early adopter. Do you think Deno's the future of server side JavaScript? Let me know in the comments below. Thanks for watching. Hit the like button, and I will see you in the next one.
The speaker explains that Deno is a new way to write server side JavaScript, using a single TypeScript file and accessing all the types in the denies. They also discuss the security of the file system and the use of a command line for resolving promises. The speaker recommends using the "any tab" option to import and customize modules, and mentions that Deno is the future of server side JavaScript.

        [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 : Deno in 100 Seconds 
        and a small summary : The speaker explains that Deno is a new way to write server side JavaScript, using a single TypeScript file and accessing all the types in the denies. They also discuss the security of the file system and the use of a command line for resolving promises. The speaker recommends using the "any tab" option to import and customize modules, and mentions that Deno is the future of server side JavaScript.
        [/INST]
        
        Generate the video : Deno, a brand new way to write server side JavaScript. It solves many of the same problems as Node. Js and was even created by the same guy. Like Node, it uses the v eight JavaScript engine under the hood, but the rest of the runtime is implemented in Rust and TypeScript. Our journey into Deno land begins in a single TypeScript file. In this file, we have access to all the types in the runtime, which means we can write strongly typed code and get documentation and IntelliSense directly in the IDE without ever needing to touch TS config file. The features in the runtime can be accessed from this Deno namespace. Let's console log the current working directory of the file system. We can execute our script with deno run from the command line. But you'll notice that there's an error and that's because Deno is secure by default. You, the developer, need to give permission to perform different actions in the runtime. In this case, we can use the allow read flag to allow this operation. Security is great, but my favorite thing is how everything asynchronous is promise based. We can make a network request using the fetch API just like we would in the browser. And because it supports top level await, we don't even need an async We can start resolving promises without any extra boilerplate code. Deno attempts to make your code as browser compatible as possible. It contains a window object with life cycle events that you can Listen to allowing developers to more easily write code that can interop between browsers and servers. Not to mention, it can also execute web assembly binaries. But one thing that won't work in Deno are your npm packages. Instead, you import packages using the modern es module syntax, with remote modules being referenced by their URL. When you run your script for the first time, it will download this code locally and cache it. There's no package JSON and code can be referenced from any URL, very similar to how things work in the browser. Deno provides a set of standard modules to solve common use cases. For example, we can import serve from the HTTP module. We can use it to create a server that's treated as an async iterable. We can then await every request from the server and respond to it accordingly. And that's an awesome starting point for a server side JavaScript app. Now, Deno 1.0 just hit release candidate 1. So if you start using it today, consider yourself an early adopter. Do you think Deno's the future of server side JavaScript? Let me know in the comments below. Thanks for watching. Hit the like button, and I will see you in the next one.
        