Hi, welcome to this new lesson. We're going to start
talking a little bit about modularity in programming. If you imagine that you could actually write a complex
piece of software, just the way we've been writing variables and some
arithmetic operators. You'll probably soon
realize this is not a very productive
way of working. For that actually
in programming, we introduced the
notion of modularity, which will take us into
the notion of functions. If we think of a program
or a piece of software, it's worth thinking of
it in different modules. Modules are very arbitrary, something that you would start conceiving of as you
kind of know more, and you might think, well, maybe this is the part of
the software that deals with reading and writing
information into a database. Maybe another part of the
program has to do with the graphic representation
of the data within a screen. Like that, you might
have a series of modules which are
higher order concepts, and those are arbitrary, they're your design to really start conceiving
of those modules. Later in a more pragmatic form, those modules will be further broken into objects
or functions. We will cover objects, which is a big topic in second
specialization in number 2 because it's like a very important concept that is a little
bit more advanced. But for now, let's
talk about functions. Functions, it is a
very good way to write a piece of code
that you can reuse. Imagine that you're creating your own summation calculation. The way you would add two numbers on
addition calculation. Well, you can specify,
maybe I want to print, while I do that, I want to print the results in a
specific format. Or maybe I would like
to do a series of other operations or validate
the data as it comes in. You can package all that into
a function so that every time that you perform an
operation calling this function, a series of lines of
code will be executed. You don't have to rewrite those lines of
code over and over again. You can reuse a function, you basically write it once and you can execute it as
many times as you want. Often what you will
see is a series of functions that are defined first and then later software that starts making use
of those functions. That makes it incredibly
easy to maintain, because if you see that there's a bug or a problem with
one of the functions, you're going to
fix the function. You don't have to go and repeat that correction in
the many instances in which you have
been using this code. If you would not write a
function in the first place. We're going to dive
in, let's jump into the next video and
we're going to start seeing how to write these
functions together.