Fifteen years of Agile Software Development has taught us a few things. We have found that team based, short cycle processes such as Scrum and Extreme Programming can provide high levels of transparency. We did not realize how opaque traditional processes really were until we started working is very short iterations.
The second thing we discovered was that sustaining consistent and predictable progress required us to work in ways much different from the ways in which we previously worked.
This was a hard learned lesson. One that every team that is using Scrum, or XP, or any short cycle technique must learn if they are to succeed.
The Certified Scrum Developer© program was created to bring the XP technical practices into Scrum.
We have found that to succeed with Scrum, you must test your features and your code not just every Sprint, not just every day, but continuously. Every time something changes, you must immediately build and test it.
You need to know how your changes impact your code and your team mates’ code, and how it impacts the features your Product Owner wants.
In our course, you will begin each User Story by building acceptance tests in collaboration with you Product Owner. You will know the story is completed when the tests successfully execute and the Product Owner will know the story is completed when the tests successfully execute.
This is called Acceptance Test Driven Development.
Acceptance tests are not enough. You also need fine grained unit tests.
Within the large cycle of Acceptance Test Driven Development, you need the much shorter cycle of Test Driven Development.
You will learn how to use TDD to guide how you build the code that will deliver the feature in your User Story. These tests will be the first consumer of our code. It will let you experiment with your designs. It will help you communicate those decisions. It will protect those design decisions when new code is added. It will help you and your team mates understand the impact when those design decisions change.
The TDD cycle begins with the creation of a test. It ends with a review of our design decisions. As we add new features, we must keep our design clean. If we don’t, we will end up with a giant ball of mud. And, nobody wants that!
In our course, you will learn to use Refactoring to keep your code clean and evolve your design. We will review how well you are doing this at the end of each Sprint. We will provide feedback and offer advice on how to improve your code.
Once you have these tests, you would be crazy not to run them. In our course, we will practice Continuous Integration. Every time you check in your changes, our automated build server will build your newest product increment and verify it by running all your tests. This will let everyone know how much progress you are making and let you know if you have broken something. We will also review this at the end of each Sprint.
Extreme Programming is a team activity. In our course, you will work with another programmer doing Pair-Programming. We have found that the code we write this way is better. It is easier to understand and it is easier to work with. We go faster and it is much more fun. And what is wrong with having fun?
So, come and have some fun with Ron and Chet.