In this course section here,
we are going to combine basically all the things
and concepts we learned about over the last sections
and in this course as a whole,
but we're then going to see that as soon as our project
develops into a little bit of a bigger project,
managing the code can get difficult
and there are certain issues with our code base
as our code grows.
Because in this course section,
we're going to take a look at how we can write
maintainable code, so how we can write website code
with the front-end and the backend code
that is maintainable, not just today for us,
but also in a couple of weeks or months
if we should take a pause and then come back to the code
or for colleagues with whom we might work together.
We are also going to look at a pattern
called the MVC Pattern,
and you will learn how that can also help you
with keeping your code organized and maintainable.
Because in this course section,
we are going to start with a demo project,
which you can build as a practice,
more on that in the next lecture,
and we'll see which issues we can find in that demo project.
Not necessarily issues with our code itself,
not necessarily bugs in our code,
but instead simple issues that can make
working with that code unnecessarily cumbersome
as you will see.
We are then going to explore a concept called refactoring,
which is a concept that you will use
all the time as a developer, hence you will have to know it,
because you do refactor your code all the time
to split complex code into multiple easier code snippets
and to therefore keep your code maintainable
as you will learn in this course section.
And last but not least,
as part of keeping our code organized
and making it more maintainable,
we will explore this MVC Pattern,
which I already mentioned a couple of seconds ago.
And you will learn what that pattern is
and how you can use it in your web projects
no matter which programming language you might be using.
Again, plenty of content to cover.
Let's dive right in.