- [Instructor] One of the greatest advantages
of Agile software development is its focus on iteration.
That being said, because the code base
will be updated so frequently,
it needs to be able to handle heavy iteration
without architecture overhauls every sprint.
This isn't to say that there isn't a place for refactoring.
In fact, it's the opposite,
but we'll get to that in a later video.
For now, let's just talk about some of the considerations
we need to keep in mind as far as project architecture goes.
Keep things as modular as possible.
This is something a lot of projects set out to do anyway,
and us being the good programmers that we are,
we do our best to make good use of design patterns
and principles from the beginning.
Then come deadlines, changing requirements,
bugs, client feedback.
This can transform an orderly project design
into spaghetti code in a matter of weeks,
and pretty soon you'll be a couple sprints in
and your code base will be a mess.
Avoiding these pitfalls is easier said than done.
It starts with a constant awareness of what's being built,
and more importantly, how it's getting built.
With Agile, the goal is to always deliver working software,
which means writing code that's necessary
and leaving out the garnish.
When your hands touch the keyboard,
you need to consider not only
how you're going to write good, clean code,
but how you can make it as flexible as possible
for later expansion.
Let's take a for instance.
If you were starting out with a specific color palette
for an application, it's a good idea to store them globally
and create accessible wrappers to use.
However you choose to do that isn't really important here.
The key is that changes to the designs later on
can be done in minutes instead of hours.
The same can be said of almost anything
that will be used across your product, including classes,
data structures and debug helpers.
This is not only good software development practice,
it's good Agile development.
It's not surprising that a lot of the same traits
that make a good Agile developer are also the same ones
that make a good software developer.
Thinking this way, even when there's a time crunch
or deadline over your head, will oftentimes define
the project's future success.
If you're interested in exploring this topic further,
get your hands on "Clean Code:
Agile Principles, Patterns, and Practices"
by Robert C. Martin.