Building high-quality and well-crafted software is not an impossible ideal, regardless of how much experience your team possesses, or how tight a deadline might be you can ensure that quality is part of your process. Without the right process or tools, then trying to maintain a high standard within a team can often feel like pushing a bolder uphill, which is why a lot of teams cut corners and start hacking away. When you think about the state of your current codebase, if frustration/shame/embarrassment is your first thought and you want to try a new approach that might make your life a lot easier, then NDepends might be the tool you have been looking for.
Why Do Some Teams Struggle Writing Quality Code?
Over the years, I've worked with clients, both big and small and from this experience I've come to the conclusion that there are two types of teams, the high-performers and the fire-fighters. The high-performance teams always seem to deliver business functionality quickly and the fire-fighters move at a fraction of the pace. You might think, some teams just have better developers, and skill does matter, however, the biggest differentiating factor is usually down to the importance a team places on doing things the 'right way' and then figuring out how they can automate quality checks into their process. For example, are you using Stylecop? If so have you got it to fail your local build on any warnings? These small things may sound trivial, but it helps prevent technical debt, which in the long run allows teams to move quicker.
The fire-fighters who 'hack' their way through a project, might seem like they make quicker progress in the first few weeks, but, fast forward a few months and the time it takes to deliver new features start to increase. The amount of time spent firefighting and figuring out what all the random hacks are meant to do decreases productivity and soon the dominant task that everyone on the team ends up performing is trying to figure out what the hell is going on.
Defining what good quality software means is hard. My definition of what good quality well-crafted software is will be different than yours. Quality is a subjective matter and the definition will change depending on the people in the team. Agreeing within a team what is 'good' design and how a feature should be designed is subjective and can lead to frustrations.
On a lot of projects, it's usually down to the lead developer to manually enforce that the team follows good design. Like anything in software, the more manual a process is the more likely that it will be given up when the going gets tough. Every developer should understand that the more you can automate your workflow the quicker you will be able to ship your software. When you can use a tool to replace a manual process, the chances of manual errors occurring drop significantly. This is where NDepends fits in.
What Is NDepends?
NDepend is a code quaity static analyzer that simplifies managing a complex .NET codebases and provides a tool to help standardise your code quality process. NDepends is 100% integrated within VS so you can use it within VS while you code. Some of the things you can with NDepend include:
- Interactive tooling that is 100% integrated into VS (http://www.ndepend.com/Features.aspx )
- VSTS extension https://marketplace.visualstudio.com/items?itemName=ndepend.ndependextension
- Smart Technical Debt Estimation live in VS
- Rules and code analysis through LINQ queries ( http://www.ndepend.com/DefaultRules/webframe.html )
- CI reporting ( http://www.ndepend.com/SampleReports.aspx )
Why Use NDepends?
Ndepends can be used to provide a consistent measurement of how good your code is, reviewed against industry standard and agreed upon rules. When you use NDepends in your team, gone are the excuses of not having enough time. Gone are the days of squabbling over who is right and who is wrong. Gone of the days of someone having to continually ensure the team is doing code-reviews in a consistent manner.
When you can convert a manual step (agreeing within your team if every commit passes a quality inspection) into an automated one, your release process will be quicker and your codebase will contain fewer bugs.
This might sound like some fancy sales pitch but it's basic maths. Running a code analysis tool against your code base on a consistent basis (like every commit) and then refactoring it based on the advice, leads to better-crafted software. You can integrate NDepends into your build, so you can even prevent people committing code that contains code smells.