Ever notice how software development projects seem to slow down when you add more people?
Books have been written about how difficult it can be to manage a large software project. It’s probably one of the only manufacturing disciplines where adding people and layers of project management makes it more difficult to estimate the timeline and quality of the final output.
In fact, that’s why the Agile Methodology has become so popular. Many organizations find that smaller teams are far more productive than larger teams, and Agile practices provide ways to reasonably scale your organization, so you can leverage a large group of testers and coders to build something significant.
At some point in any successful project you are going to be faced with the exciting (and terrifying?) prospect of growing your test organization, and you’ll have to figure out better ways to communicate, share information, coordinate activities, and deliver predictable, high-quality product. Whether you are a small team in the throes of scaling, or a larger team looking to overhaul your development process, there are a number of low-hanging fruit improvements you can make in how you work that will really help.
Get In The Right Frame Of Mind
Before we go into specific recommendations, here are a few general rules of thumb about how to approach improvements to your software development and QA practice.
- Don’t do everything at once: Take things one step at a time, so people can get used to changes in the way they work. Otherwise, everything will suffer.
- Put “good habits” in place sooner: Habits – good or bad – are hard to break. Don’t wait until its too late to establish helpful habits.
- Automation tools early, collaboration tools later: People often jump to implementing tools as soon as possible, but focus on those tools that will help most. Automation can speed you up, but other types of tools may slow you down if you put them in place too soon.
- Don’t over-engineer: Put the right degree of process in place for the team on staff and the task at hand. You don’t need to boil the ocean – just the pot of water you are standing in.
If you want to assess the quality of your team quickly, check out the Joel Test – 12 Steps to Better Code by Joel on Software. Continue to read on for a few improvements you can make to your development and testing process that will give you the most bang for your buck.
1. Test-Oriented Coding and Practice Standards
As soon as you have more than one person, you are going to want to put in place some defined practices that cover how you code and how you test. A good set of standards will cover everything from file organization and naming conventions to code formatting and test plan structure. You should also document rules of thumb to follow – like how to handle comments and documentation. Some of these may seem like nits, but you want to start creating these good, consistent habits from day one so that everyone is on the same page and can work with each other’s code when necessary.
Make sure to also think about standards related to performance, optimization, and security at this point. It may feel early to think about those things, but again, you are setting up habits that will be with you for a long time. If you’d like some help getting started, check out this great list of standards and practices on Wikipedia.
2. Version Control for Code and Test Cases
Some of the most spectacular development fails have to do with a lack of version control, or poor practices at the least. Have you heard the one about the disgruntled employee who deleted an entire codebase after getting fired? Or how about the guy who checked all his code into source code control as a single, large zip-file with the comment, “updated from last time.”
Version control systems like GitHub make sure that your source code and assets are protected from accidental or malicious deletions, mistakes, errors, and catastrophes. If a bug is introduced to the code, your version control lets you roll back to a previous version. If your hard drive fails, your source code control system lets you restore the latest version.
Version control is a must-have. Be sure to store both source code and test cases in the repository – in fact, you may consider a completely separate repository just for the QA environment to cover test plans and automation. And if your team is capable of fixing small bugs, give your testers the access they need to check those fixes back into the system.
3. A Build & Deploy System
One of the most useful things you can have in your development environment is a “clean copy” of your code. In fact, even better is the ability to create a clean copy on any environment, any time you need it. This can be very easy after you have a version control system in place. Your build & deploy system will automatically extract the latest version of your code from version control, assemble it, and install it.
What’s compelling about a good build & deploy system is:
- You have an environment that anyone can access, test, and use
- It’s not a developer’s local machine and therefore much more controlled
- You can easily replicate the process onto different machines, browsers, and devices using an array of configuration options
- You have much more confidence that what works on your deploy system will work on your production system
With your build & deploy system, automation is key. Set it up early and start building your product daily. Some companies automate a build after every check-in. The more often you build, the easier it will be to find, contain, and fix bugs and other problems.
4. Code Reviews
Ewe mite ewes a spell Czech. Its good, butt knot enough.
Like a spell checker that doesn’t understand the improper use of properly spelled words, your code may be functional without being correct. The discipline of code reviews helps ensure high-quality code and tests by bringing another pair of eyes into the code with a slightly different perspective. Having a partner review what you are writing is an incredibly easy and effective way to identify problems in function, performance, security, and user experience.
There are many different ways of conducting code reviews. You can focus on some of your code, or all of it. Code reviews can be conducted over-the-shoulder or through email. Some companies go so far as to implement Pair Programming, with two developers working at a single workstation. A popular technique, especially in agile teams, has been to include testers in the review process to help identify bugs, write test cases, and improve testability.
Code reviews also have the benefit of fostering teamwork, collaboration, and continuous learning. They help your team members communicate, and reinforce the coding standards and practices you’ve put in place. For a tester’s perspective on code reviews, check out this document.
5. Automated Testing
As much as possible, have computers find your bugs for you. Automated testing is one of the most important investments you can make in quality assurance. And while it can be a big commitment if you let it, there are many ways to make small investments in test automation that will drastically improve your overall process.
When you start with automated testing, focus on a set of test cases that are very common and currently take significant time. For example, a smoke-test could be set up to run after every automated deployment, producing a report that indicates how functional the current codebase is. As your processes mature, you’ll add more test cases and richer tools.
It’s also important to include load & performance testing early on with your automated functional tests. Performance problems can point to issues deep in the code, and so the sooner you identify them, the safer you will be. Remember, there is a difference between testing and quality assurance – read more about that here.
Good Habits + Automation = Light Speed
If you want a process that doesn’t slow you down – but actually helps you move faster – don’t over-complicate things. Focus on putting good habits in place with your team, supported by automation to speed up those tasks that are executed frequently and by many people. The biggest headaches with a development process come when errors are introduced that are left unnoticed for long periods of time. These tips should help you avoid that and grow an amazing organization – and a high-quality product.