Agile Development Practices

The problem:

You're never quite sure that the software you're building actually works. Your software routinely has a lot of defects that are expensive to find, because that requires a lot of manual work from the testers. Even after you find the defects, fixing them is also very expensive, because the system's design continuously gets in the way of developers as they fix it. Some defects even come back some time after being fixed.

What is Test-Driven-Develpment:

TDD is a technique where the programmers write low-level code tests before writing the code itself. It’s considered one of the essential modern techniques, but it’s not easy to master without guidance.

With our help you will:

• • • Spot most defects as soon as they happen, when they're orders of magnitude cheaper to fix.
    • Run your tests all the time at zero cost, to find problems before they impact on customers.
    • Have “executable documentation” that is very detailed and always in synch with the code.
    • Make it easier to bring new developers up to speed while minimizing rookie mistakes.
    • Build a system that’s easier to change extremely fast, because the tests provide a great safety net to developers.
    • Build a better-designed system, because the developers are guided by the tests in designing code.

What you will accomplish:

People on the team know how to do TDD properly, and they have a basic suite of automated tests to expand in the future. You have questions? Please contact us!

The problem:

Manual testing is very expensive. Worse, if you find a bug during manual testing, you have to fix it and then re-do the testing, doubling the cost. Also, it's common for customers (even customers inside your Company) to be dissatisfied with the end result, even if you spend a lot of time and money gathering detailed requirements.

What is Automated Acceptance Testing?

Automated Acceptance Testing allows you to specify without ambiguity what the customer is expecting, and to verify those requirements automatically as you build the system.

We help you with:

• • • Reduce expensive manual testing in favor of cheap automated testing.
    • Run tests all the time to spot problems in development *and* in production.
    • Develop the system that your customers expect and reduce communication problems.

What you will accomplish:

The team and the customers know how to specify, write and run automated acceptance tests. They already have a few tests that check the basic functionality in the system. You have questions? Please contact us!

The problem

As long as every developer in your team is working on his/her computer, they all tell you that things are fine. Then it comes the time to put everybody's work together, and all kinds of problems suddenly come up. The team takes forever to integrate and deliver the software. You’re nearing a deadline, so this is the worse possible time for this to happen. The project seemed on track until a few days ago, and suddenly now it's overtime and over budget, and the customers are getting impatient.

What is Continious Integration?

CI is a technique where everybody on the team integrates their work every few hours, and a “build machine” continuously monitors the current state of the software. For example, the build machine tests the system and notifies everybody if it spots a problem. This way, you'll know immediately when trouble strikes.

We help you with:

• • • Spot integration problems as they happen, when they’re still cheap to fix.
    • Get a report on the state of the project that you can actually trust.
    • Collect detailed project metrics, so you’ll always know what’s happening.
    • Lower development costs with minimal investment.
    • Improve developers’ morale by letting them trust that the system works.
    • Open the road to automated testing and other more advanced techniques.

What you will accomplish:

A working Continuous Integration server that checks the project and notifies everybody if the software doesn't integrate well. The team can keep adding features to the build machine (reporting, metrics, testing …). You have questions? Please contact us!

The problem

Your team is working with modern technologies, but they still seem to have all the problems of the old technologies. The system is brittle and difficult to change. When the requirements change, the team has real trouble adapting the software to the new requirements.

What it Object Oriented Design?

The design approach supported by modern languages. Although it’s supported, it’s not mandated, so you need good training/mentoring to be able to untap its potential.

We help you with:

• • • The system gets cheaper to grow and change even in the face of changing requirements.
    • The team finds it easier to learn and communicate the internals of the system.

What you will accomplish:

The team knows how to make the most of the programming language they’re using, and they have a good idea of the direction that their current design should take in the future. You have questions? Please contact us!

Refactoring

The problem:

Your development seems to slow down as time passes. The developers are complaining that they have a lot of “legacy” code that’s difficult to work with. They’re always asking the impossible: to stop developing new features and “do it right”, maybe by rewriting the entire system. This cannot be afforded, but things are deteriorating: every change seems to introduce more bugs and to take more time than the previous change. This is called "technical debt" - just like financial debt, it sinks money into “interests” on previous investments. At one point, adding new features will end up costing more that the features are worth, and you’ll have to dump the old system and start again from scratch, at an extremely high cost.

What it Refactoring:

Refactoring is a set of development techniques that help to keep old code in good shape. By continuously reducing technical debt at no additional cost, refactoring allows developers to make the system better and better with time, rather than worse and worse.

We support your with:

• • • Keep the cost of new features flat as the system evolves and requirements change.
    • Radically reduce the cost of fixing bugs over time.
    • Improve developer morale and stop them from asking for time to “fix the system”.
    • Never have to dump large parts of the system and rewrite them from scratch.

What you will accomplish:

The teams knows refactoring techniques, and they've already begun to pay back "technical debt". When we leave, the software is cheaper to maintain and change then it was when we started, and it keeps getting cheaper and cheaper after that. You have questions? Please contact us!