Dev 2
Dev 2
How can we make sure we wind up behind the right door when the going
gets
tough? The answer is: craftsmanship.
There are two parts to learning craftsmanship: knowledge and work. You must gain
the knowledge of principles, patterns, practices, and heuristics that a craftsman
knows, and
you must also grind that knowledge into your fingers, eyes, and gut by working hard
and
practicing.
I can teach you the physics of riding a bicycle. Indeed, the classical mathematics
is
relatively straightforward. Gravity, friction, angular momentum, center of mass,
and so
forth, can be demonstrated with less than a page full of equations. Given those
formulae I
could prove to you that bicycle riding is practical and give you all the knowledge
you
needed to make it work. And you’d still fall down the first time you climbed on
that bike.
Coding is no different. We could write down all the “feel good” principles of clean
code and then trust you to do the work (in other words, let you fall down when you
get on
the bike), but then what kind of teachers would that make us, and what kind of
student
would that make you?
No. That’s not the way this book is going to work.
Learning to write clean code is hard work. It requires more than just the knowledge
of
principles and patterns. You must sweat over it. You must practice it yourself, and
watch
yourself fail. You must watch others practice it and fail. You must see them
stumble and
retrace their steps. You must see them agonize over decisions and see the price
they pay for
making those decisions the wrong way.
Be prepared to work hard while reading this book. This is not a “feel good” book
that
you can read on an airplane and finish before you land. This book will make you
work, and
work hard. What kind of work will you be doing? You’ll be reading code—lots of
code.
And you will be challenged to think about what’s right about that code and what’s
wrong
with it. You’ll be asked to follow along as we take modules apart and put them back
together again. This will take time and effort; but we think it will be worth it.
We have divided this book into three parts. The first several chapters describe the
prin#ciples, patterns, and practices of writing clean code. There is quite a bit of
code in these
chapters, and they will be challenging to read. They’ll prepare you for the second
section
to come. If you put the book down after reading the first section, good luck to
you!
The second part of the book is the harder work. It consists of several case studies
of
ever-increasing complexity. Each case study is an exercise in cleaning up some code
—of
transforming code that has some problems into code that has fewer problems. The
detail in
this section is intense. You will have to flip back and forth between the narrative
and the
code listings. You will have to analyze and understand the code we are working with
and
walk through our reasoning for making each change we make. Set aside some time
beca