When you develop software, it's a good idea to make sure it works by testing it. Test-Driven Development (TDD) can help you understand your code and decrease bugs. https://fireship.io/tags/testing/

#software #tech #100SecondsOfCode

🔗 Resources

Testing overview https://en.wikipedia.org/wiki/Software_testing
Jasmine https://jasmine.github.io/
Software testing study https://www.researchgate.net/publication/256991987_A_survey_of_software_testing_practices_in_Canada

 🤓 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

🔥 Watch more with Fireship PRO

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

🎨 My Editor Settings

- Atom One Dark 
- vscode-icons
- Fira Code Font
2024-02-04T05:52:12.501Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
43a63e98-ae7d-4cff-bad7-3f355d7a7007
9b93222443c255e4013015b1c18c309e39ab7d0d298eeaaa7e373484b4ad985b
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
Software.
It's not like engineering something easy like a bridge, where you start with a blueprint, build it to spec, then forget about it.
Software is dynamic with a lot of moving moving parts and requirements that evolve over time.
Developers build apps on top of a mountain of abstractions, and nobody fully understands how every layer works.
That's okay because we just need to make sure that our code matches the requirements of the product.
Test driven development is scientifically proven to reduce defects and improve the maintainability of a code base, but it does require some additional effort.
One option is manual testing where a human being clicks on every button and fills out every form, then assigns a bunch of Jira tickets so they can be backlogged by the developers, but that's not very efficient for a large scale product.
A better approach is to use automated testing tools that allow developers to write code for the sole purpose of testing the main application code.
In a code base, you'll often find files that end in dot test to or dot spec.
Inside, you'll first find a line of code that describes the feature or thing that's being tested.
That's known as a test suite and it contains 1 or more individual tests.
An individual test usually starts with it followed by a description of what is being tested.
The idea is to describe the behavior of the code and human readable terms.
Inside the test, the code will be executed, then 1 or more expectations or assertions are used to check that the code produces the expected result.
If the expectation returns false, then the test fails.
If it's true, it passes.
Test runners like Jest or Karma can run all your tests automatically in the background or on a continuous integration server before you deploy.
Now there are many different move made testing strategies that you should be aware of.
At the most granular level, we have unit testing, which is designed to test individual functions or methods.
Like, does this function return the proper value when given the arguments of a and b.
Then we have integration testing to determine how well different components or modules work together, like is the component able to use the database service to to get data from the server.
At the highest level, we have end to end testing, which usually happens in a mock browser or device and simulates actual user behaviors like clicking on buttons and filling out forms.
It's like having a robot to do all your manual testing for you.
And that's not all.
There are many other types like performance and smoke testing, which I'll explain in my upcoming test driven development breakdown.
Hit the like button if you wanna see more short videos like this.
Thanks for watching, and I will see you in the next one.

Speaker 0: Software. It's not like engineering something easy like a bridge, where you start with a blueprint, build it to spec, then forget about it. Software is dynamic with a lot of moving moving parts and requirements that evolve over time. Developers build apps on top of a mountain of abstractions, and nobody fully understands how every layer works. That's okay because we just need to make sure that our code matches the requirements of the product.

Test driven development is scientifically proven to reduce defects and improve the maintainability of a code base, but it does require some additional effort. One option is manual testing where a human being clicks on every button and fills out every form, then assigns a bunch of Jira tickets so they can be backlogged by the developers, but that's not very efficient for a large scale product. A better approach is to use automated testing tools that allow developers to write code for the sole purpose of testing the main application code. In a code base, you'll often find files that end in dot test to or dot spec. Inside, you'll first find a line of code that describes the feature or thing that's being tested.

That's known as a test suite and it contains 1 or more individual tests. An individual test usually starts with it followed by a description of what is being tested. The idea is to describe the behavior of the code and human readable terms. Inside the test, the code will be executed, then 1 or more expectations or assertions are used to check that the code produces the expected result. If the expectation returns false, then the test fails.

If it's true, it passes. Test runners like Jest or Karma can run all your tests automatically in the background or on a continuous integration server before you deploy. Now there are many different move made testing strategies that you should be aware of. At the most granular level, we have unit testing, which is designed to test individual functions or methods. Like, does this function return the proper value when given the arguments of a and b.

Then we have integration testing to determine how well different components or modules work together, like is the component able to use the database service to to get data from the server. At the highest level, we have end to end testing, which usually happens in a mock browser or device and simulates actual user behaviors like clicking on buttons and filling out forms. It's like having a robot to do all your manual testing for you. And that's not all. There are many other types like performance and smoke testing, which I'll explain in my upcoming test driven development breakdown.

Hit the like button if you wanna see more short videos like this. Thanks for watching, and I will see you in the next one.
Software. It's not like engineering something easy like a bridge, where you start with a blueprint, build it to spec, then forget about it. Software is dynamic with a lot of moving moving parts and requirements that evolve over time. Developers build apps on top of a mountain of abstractions, and nobody fully understands how every layer works. That's okay because we just need to make sure that our code matches the requirements of the product. Test driven development is scientifically proven to reduce defects and improve the maintainability of a code base, but it does require some additional effort. One option is manual testing where a human being clicks on every button and fills out every form, then assigns a bunch of Jira tickets so they can be backlogged by the developers, but that's not very efficient for a large scale product. A better approach is to use automated testing tools that allow developers to write code for the sole purpose of testing the main application code. In a code base, you'll often find files that end in dot test to or dot spec. Inside, you'll first find a line of code that describes the feature or thing that's being tested.
software development
software
architecture
machine learning
engineering
infrastructure
That's known as a test suite and it contains 1 or more individual tests. An individual test usually starts with it followed by a description of what is being tested. The idea is to describe the behavior of the code and human readable terms. Inside the test, the code will be executed, then 1 or more expectations or assertions are used to check that the code produces the expected result. If the expectation returns false, then the test fails. If it's true, it passes.
logic
logical reasoning
programming
modeling
measurement
Test runners like Jest or Karma can run all your tests automatically in the background or on a continuous integration server before you deploy.
Now there are many different move made testing strategies that you should be aware of. At the most granular level, we have unit testing, which is designed to test individual functions or methods. Like, does this function return the proper value when given the arguments of a and b. Then we have integration testing to determine how well different components or modules work together, like is the component able to use the database service to to get data from the server. At the highest level, we have end to end testing, which usually happens in a mock browser or device and simulates actual user behaviors like clicking on buttons and filling out forms.
databases
operations
programming
It's like having a robot to do all your manual testing for you. And that's not all. There are many other types like performance and smoke testing, which I'll explain in my upcoming test driven development breakdown. Hit the like button if you wanna see more short videos like this. Thanks for watching, and I will see you in the next one.
youtube
robotics
Software. It's not like engineering something easy like a bridge, where you start with a blueprint, build it to spec, then forget about it. Software is dynamic with a lot of moving moving parts and requirements that evolve over time. Developers build apps on top of a mountain of abstractions, and nobody fully understands how every layer works. That's okay because we just need to make sure that our code matches the requirements of the product. Test driven development is scientifically proven to reduce defects and improve the maintainability of a code base, but it does require some additional effort. One option is manual testing where a human being clicks on every button and fills out every form, then assigns a bunch of Jira tickets so they can be backlogged by the developers, but that's not very efficient for a large scale product. A better approach is to use automated testing tools that allow developers to write code for the sole purpose of testing the main application code. In a code base, you'll often find files that end in dot test to or dot spec. Inside, you'll first find a line of code that describes the feature or thing that's being tested. That's known as a test suite and it contains 1 or more individual tests. An individual test usually starts with it followed by a description of what is being tested. The idea is to describe the behavior of the code and human readable terms. Inside the test, the code will be executed, then 1 or more expectations or assertions are used to check that the code produces the expected result. If the expectation returns false, then the test fails. If it's true, it passes. Test runners like Jest or Karma can run all your tests automatically in the background or on a continuous integration server before you deploy. Now there are many different move made testing strategies that you should be aware of. At the most granular level, we have unit testing, which is designed to test individual functions or methods. Like, does this function return the proper value when given the arguments of a and b. Then we have integration testing to determine how well different components or modules work together, like is the component able to use the database service to to get data from the server. At the highest level, we have end to end testing, which usually happens in a mock browser or device and simulates actual user behaviors like clicking on buttons and filling out forms. It's like having a robot to do all your manual testing for you. And that's not all. There are many other types like performance and smoke testing, which I'll explain in my upcoming test driven development breakdown. Hit the like button if you wanna see more short videos like this. Thanks for watching, and I will see you in the next one.
Software.
software
It's
it's
not
not
like
like
engineering
engineering
something
something
easy
easy
like
like
a
a
bridge,
bridge
where
where
you
you
start
start
with
with
a
a
blueprint,
blueprint
build
build
it
it
to
to
spec,
spec
then
then
forget
forget
about
about
it.
it
Software
software
is
is
dynamic
dynamic
with
with
a
a
lot
lot
of
of
moving
moving
moving
moving
parts
parts
and
and
requirements
requirements
that
that
evolve
evolve
over
over
time.
time
Developers
developers
build
build
apps
apps
on
on
top
top
of
of
a
a
mountain
mountain
of
of
abstractions,
abstractions
and
and
nobody
nobody
fully
fully
understands
understands
how
how
every
every
layer
layer
works.
works
That's
that's
okay
okay
because
because
we
we
just
just
need
need
to
to
make
make
sure
sure
that
that
our
our
code
code
matches
matches
the
the
requirements
requirements
of
of
the
the
product.
product
Test
test
driven
driven
development
development
is
is
scientifically
scientifically
proven
proven
to
to
reduce
reduce
defects
defects
and
and
improve
improve
the
the
maintainability
maintainability
of
of
a
a
code
code
base,
base
but
but
it
it
does
does
require
require
some
some
additional
additional
effort.
effort
One
one
option
option
is
is
manual
manual
testing
testing
where
where
a
a
human
human
being
being
clicks
clicks
on
on
every
every
button
button
and
and
fills
fills
out
out
every
every
form,
form
then
then
assigns
assigns
a
a
bunch
bunch
of
of
Jira
jira
tickets
tickets
so
so
they
they
can
can
be
be
backlogged
backlogged
by
by
the
the
developers,
developers
but
but
that's
that's
not
not
very
very
efficient
efficient
for
for
a
a
large
large
scale
scale
product.
product
A
a
better
better
approach
approach
is
is
to
to
use
use
automated
automated
testing
testing
tools
tools
that
that
allow
allow
developers
developers
to
to
write
write
code
code
for
for
the
the
sole
sole
purpose
purpose
of
of
testing
testing
the
the
main
main
application
application
code.
code
In
in
a
a
code
code
base,
base
you'll
you'll
often
often
find
find
files
files
that
that
end
end
in
in
dot
dot
test
test
to
to
or
or
dot
dot
spec.
spec
Inside,
inside
you'll
you'll
first
first
find
find
a
a
line
line
of
of
code
code
that
that
describes
describes
the
the
feature
feature
or
or
thing
thing
that's
that's
being
being
tested.
tested
That's
that's
known
known
as
as
a
a
test
test
suite
suite
and
and
it
it
contains
contains
1
1
or
or
more
more
individual
individual
tests.
tests
An
an
individual
individual
test
test
usually
usually
starts
starts
with
with
it
it
followed
followed
by
by
a
a
description
description
of
of
what
what
is
is
being
being
tested.
tested
The
the
idea
idea
is
is
to
to
describe
describe
the
the
behavior
behavior
of
of
the
the
code
code
and
and
human
human
readable
readable
terms.
terms
Inside
inside
the
the
test,
test
the
the
code
code
will
will
be
be
executed,
executed
then
then
1
1
or
or
more
more
expectations
expectations
or
or
assertions
assertions
are
are
used
used
to
to
check
check
that
that
the
the
code
code
produces
produces
the
the
expected
expected
result.
result
If
if
the
the
expectation
expectation
returns
returns
false,
false
then
then
the
the
test
test
fails.
fails
If
if
it's
it's
true,
true
it
it
passes.
passes
Test
test
runners
runners
like
like
Jest
jest
or
or
Karma
karma
can
can
run
run
all
all
your
your
tests
tests
automatically
automatically
in
in
the
the
background
background
or
or
on
on
a
a
continuous
continuous
integration
integration
server
server
before
before
you
you
deploy.
deploy
Now
now
there
there
are
are
many
many
different
different
move
move
made
made
testing
testing
strategies
strategies
that
that
you
you
should
should
be
be
aware
aware
of.
of
At
at
the
the
most
most
granular
granular
level,
level
we
we
have
have
unit
unit
testing,
testing
which
which
is
is
designed
designed
to
to
test
test
individual
individual
functions
functions
or
or
methods.
methods
Like,
like
does
does
this
this
function
function
return
return
the
the
proper
proper
value
value
when
when
given
given
the
the
arguments
arguments
of
of
a
a
and
and
b.
b
Then
then
we
we
have
have
integration
integration
testing
testing
to
to
determine
determine
how
how
well
well
different
different
components
components
or
or
modules
modules
work
work
together,
together
like
like
is
is
the
the
component
component
able
able
to
to
use
use
the
the
database
database
service
service
to
to
to
to
get
get
data
data
from
from
the
the
server.
server
At
at
the
the
highest
highest
level,
level
we
we
have
have
end
end
to
to
end
end
testing,
testing
which
which
usually
usually
happens
happens
in
in
a
a
mock
mock
browser
browser
or
or
device
device
and
and
simulates
simulates
actual
actual
user
user
behaviors
behaviors
like
like
clicking
clicking
on
on
buttons
buttons
and
and
filling
filling
out
out
forms.
forms
It's
it's
like
like
having
having
a
a
robot
robot
to
to
do
do
all
all
your
your
manual
manual
testing
testing
for
for
you.
you
And
and
that's
that's
not
not
all.
all
There
there
are
are
many
many
other
other
types
types
like
like
performance
performance
and
and
smoke
smoke
testing,
testing
which
which
I'll
i'll
explain
explain
in
in
my
my
upcoming
upcoming
test
test
driven
driven
development
development
breakdown.
breakdown
Hit
hit
the
the
like
like
button
button
if
if
you
you
wanna
wanna
see
see
more
more
short
short
videos
videos
like
like
this.
this
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 explains that software development is like building a bridge, where the developers build apps based on a maturation of technical requirements. The process involves manual testing, automation, and end-to-end testing, including performance and smoke testing. Different tests can be conducted, including unit testing, integration testing, and end-to-end testing, and there are many different ways to test.
Software Testing Explained in 100 Seconds
Software. It's not like engineering something easy like a bridge, where you start with a blueprint, build it to spec, then forget about it. Software is dynamic with a lot of moving moving parts and requirements that evolve over time. Developers build apps on top of a mountain of abstractions, and nobody fully understands how every layer works. That's okay because we just need to make sure that our code matches the requirements of the product. Test driven development is scientifically proven to reduce defects and improve the maintainability of a code base, but it does require some additional effort. One option is manual testing where a human being clicks on every button and fills out every form, then assigns a bunch of Jira tickets so they can be backlogged by the developers, but that's not very efficient for a large scale product. A better approach is to use automated testing tools that allow developers to write code for the sole purpose of testing the main application code. In a code base, you'll often find files that end in dot test to or dot spec. Inside, you'll first find a line of code that describes the feature or thing that's being tested. That's known as a test suite and it contains 1 or more individual tests. An individual test usually starts with it followed by a description of what is being tested. The idea is to describe the behavior of the code and human readable terms. Inside the test, the code will be executed, then 1 or more expectations or assertions are used to check that the code produces the expected result. If the expectation returns false, then the test fails. If it's true, it passes. Test runners like Jest or Karma can run all your tests automatically in the background or on a continuous integration server before you deploy. Now there are many different move made testing strategies that you should be aware of. At the most granular level, we have unit testing, which is designed to test individual functions or methods. Like, does this function return the proper value when given the arguments of a and b. Then we have integration testing to determine how well different components or modules work together, like is the component able to use the database service to to get data from the server. At the highest level, we have end to end testing, which usually happens in a mock browser or device and simulates actual user behaviors like clicking on buttons and filling out forms. It's like having a robot to do all your manual testing for you. And that's not all. There are many other types like performance and smoke testing, which I'll explain in my upcoming test driven development breakdown. Hit the like button if you wanna see more short videos like this. Thanks for watching, and I will see you in the next one.
The speaker explains that software development is like building a bridge, where the developers build apps based on a maturation of technical requirements. The process involves manual testing, automation, and end-to-end testing, including performance and smoke testing. Different tests can be conducted, including unit testing, integration testing, and end-to-end testing, and there are many different ways to test.

        [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 : Software Testing Explained in 100 Seconds 
        and a small summary : The speaker explains that software development is like building a bridge, where the developers build apps based on a maturation of technical requirements. The process involves manual testing, automation, and end-to-end testing, including performance and smoke testing. Different tests can be conducted, including unit testing, integration testing, and end-to-end testing, and there are many different ways to test.
        [/INST]
        
        Generate the video : Software. It's not like engineering something easy like a bridge, where you start with a blueprint, build it to spec, then forget about it. Software is dynamic with a lot of moving moving parts and requirements that evolve over time. Developers build apps on top of a mountain of abstractions, and nobody fully understands how every layer works. That's okay because we just need to make sure that our code matches the requirements of the product. Test driven development is scientifically proven to reduce defects and improve the maintainability of a code base, but it does require some additional effort. One option is manual testing where a human being clicks on every button and fills out every form, then assigns a bunch of Jira tickets so they can be backlogged by the developers, but that's not very efficient for a large scale product. A better approach is to use automated testing tools that allow developers to write code for the sole purpose of testing the main application code. In a code base, you'll often find files that end in dot test to or dot spec. Inside, you'll first find a line of code that describes the feature or thing that's being tested. That's known as a test suite and it contains 1 or more individual tests. An individual test usually starts with it followed by a description of what is being tested. The idea is to describe the behavior of the code and human readable terms. Inside the test, the code will be executed, then 1 or more expectations or assertions are used to check that the code produces the expected result. If the expectation returns false, then the test fails. If it's true, it passes. Test runners like Jest or Karma can run all your tests automatically in the background or on a continuous integration server before you deploy. Now there are many different move made testing strategies that you should be aware of. At the most granular level, we have unit testing, which is designed to test individual functions or methods. Like, does this function return the proper value when given the arguments of a and b. Then we have integration testing to determine how well different components or modules work together, like is the component able to use the database service to to get data from the server. At the highest level, we have end to end testing, which usually happens in a mock browser or device and simulates actual user behaviors like clicking on buttons and filling out forms. It's like having a robot to do all your manual testing for you. And that's not all. There are many other types like performance and smoke testing, which I'll explain in my upcoming test driven development breakdown. Hit the like button if you wanna see more short videos like this. Thanks for watching, and I will see you in the next one.
        