Clients often come to us asking how to improve their software engineering. They want to know the best way to deliver better software solutions and help their customers.
In our experience, we’ve found using a few specific software engineering practices have the most bang for your buck. These practices fall into a couple of different buckets: individual practices (i.e., practices performed by an individual developer) and team practices (i.e., practices performed by a development team).
Here are just a few of the practices we find to be effective!
“SOLID” is actually a group of object-oriented design principles used by individual developers when writing code. Each letter in “SOLID” represents one of the principles, which are:
- Single responsibility
- Liskov substitution
- Interface segregation
- Dependency inversion
When applied together, these principles help a developer create code that is easy to maintain and extend over time – in other words, the code is solid (pun intended).
#2: Automated Unit Testing
Have you ever written code and thought to yourself, “Of course this will work,” only to find out later that either it didn’t work like you expected or it broke something else in the system?
Well, automated unit testing addresses those problems. A developer writes unit tests against the code and then executes those tests over and over again throughout the project to make sure the code continues working as expected.
You get all sorts of benefit from using this practice!
First, developers are a lot more confident they haven’t broken anything when making changes to the code so it takes them less time to make those changes. Second, automated unit testing helps you find problems early when it is easier to fix them. You also can use them to perform ongoing regression tests so you don’t introduce new problems down the line. Third, they also provide “living documentation” for the system, which helps a new developer ramp up quickly.
#3: Continuous Integration
We’ve talked to clients who have had major headaches integrating code from different development teams late in a project after each team was supposedly finished. There’s a lot of troubleshooting, rework, late nights, and occasionally even the dreaded missed deadline. The practice of continuous integration does exactly what its name implies: integrate code early and often so you avoid problems trying to integrate code later in the project.
Continuous integration works like this: a developer checking new code into the team’s source code control repository triggers the continuous integration process. The continuous integration process runs other processes, like the build process, tests, and code analysis. Continuous integration detects any problems with the code quickly and provides feedback so the developer can fix them before they become even bigger problems later. Read more about continuous integration here.
These are just a few of the software engineering practices we use, but they are among the most important when it comes to creating great software.
Have you used any of these software engineering practices? Are there others you think are more important?