Illustrator: Now, when it comes to writing that essay,
that good story, there are a couple of key pain points,
a couple of key areas on what you wanna focus
and which will be the sections in this course
where we will go through all the core concepts
in great detail.
It all starts with the naming of things.
With the names we assign to variables, functions,
and classes.
We can already mess up code with that
as you saw with the initial example,
I showed you a couple of minutes ago.
It continues with the general code structure
and any comments we might have in the code.
As you will learn in this course,
code formatting matters,
and there are various aspects that come into play
when we talk about code formatting.
And we also can differentiate between good and bad comments,
and we can see how that matters and how comments
and too many comments could actually lead
to dirty code instead of improving.
Another key pain point,
another important area,
which we'll have an entire section on in this course
will be functions.
There it's about the length of the functions,
so the amount of code in the functions
and the kind of code inside of a single function,
and the number of parameters a function takes.
As you will learn in this course,
functions are also one of the key things
that leads to bad and dirty code.
And therefore knowing how to write good functions
is a key skill and you will get it in this course.
We also will have a look at conditionals
and error handling
because nesting conditionals
and controlled structures in general too deeply
and not using error handling appropriately,
these are also two common mistakes
a lot of developers make,
and they also lead to dirty or bad code
and doing it right on the other hand,
will improve our code a lot
and will be one core building block of writing clean code.
Last but not least, working with classes, objects,
and data structures.
That's another key area where it's easy to mess up code.
It's easy to have no distinction,
no separation between data structures
and real objects.
And we will learn what the difference is
in this course, of course.
And it's also easy to end up with bloated classes,
which are doing too many things,
hence making it difficult for our developers
to understand them.
In this course, we're going to have a look at
all these areas at all these pain points,
and we'll not just learn about the problems
and the challenges there,
but of course, we're going to dive into the various
solutions you can apply to write cleaner code.
We'll dive into important rules and concepts, patterns,
and principles you should be aware of.
And we're also going to have a look
in the functions module.
We're also going to have a look at test-driven development
or how testing can help you write clean code as well.
Though, I also wanna make it clear,
this is not a test-driven development course,
not at all.
So by the end of the course,
once we went through all these sections,
we'll definitely not write code like this anymore.
Instead you will know how to write clean code
right from the start,
but also how you can derive clean code over time
as you're working on a project.