Overview
Modern professional software development organizations must adopt multiple disciplines to stay competitive and adapt to change at scale. Knowing what skills are required is essential for any development manager but attempting to tackle everything at once can be both daunting for team-members and disruptive to a development workflow.
The software development skills roadmap shown in Figure 1 is a proven path for roll-out of technical skills in your organization. This roadmap provides a straightforward, effective path to follow which allows teams to focus on adopting one skill at a time and considers management concerns, like how long it will take for each investment to pay off.
The first step is to create alignment in the organization using acceptance test-driven development (ATDD). Next, teams should focus on improving design skills with a focus on fundamental quality by using design patterns and underlying theories to guide technical conversations. Third, teams should bridge high-fidelity domain understanding and strong design skills by creating fast, actionable feedback using sustainable test-driven development (sustainable TDD).
These disciplines provide the foundation. From here, teams can move on to a deep understanding of design principles and software professionalism with advanced software design. Finally, teams can create direct connections between business and production code and maximize reuse of analysis artifacts with strong acceptance test automation.
Figure 1. Software Development Skills Roadmap
Start With Alignment
One of the biggest challenges that large software-development organizations face is a lack of alignment on what is going to get done. All too often, a team finishes some work only to find out that they did not do what was requested. Perhaps these misunderstandings cannot be eliminated completely, but it is possible to reduce their incidence dramatically.
Acceptance test-driven development, using behavior-driven development offers powerful analytical techniques, well-timed conversations, and a rigorous-but-readable language that reduces the number of errors caused by misunderstandings and handoffs.
BDD turns requirements into a specification for behaviors. ATDD turns the set of behaviors into an executable specification (a test). This offers immediate payback. It creates better communication between stakeholders. It can be easy to start simply by making changes to the order of steps in the workflow.
Summary of Benefits
Here are some benefits you will see:
- Quick, almost immediate return on effort
- Fewer defects
- Fewer misunderstandings and low-fidelity handoffs
- Better communication throughout the product-development organization
- Better understanding of the domain by the software development organization
Lay a Foundation of Design and Quality
Change is part of business. To endure, software products must be able to change. Design and quality are what make software flexible enough to change when the need arises. In fact, certain critical change-enabling disciplines such as test-driven development absolutely depend on the developer’s understanding of, and ability to change, design.
A deep understanding of design patterns and some practical experience using them to identify and address problems builds a foundation atop which all other technical skills rest. Design patterns change how a team communicates and how its team-members think about design. A rich understanding of code qualities changes how developers look at code. Some intensive practice at the beginning cements this knowledge and accelerates a team’s ability to adopt the required skills.
Like ATDD, investing in a team’s design skills quickly pays off: in days or weeks. The combination of ATDD and design patterns can be used to get some quick technical wins that can then be used to pay for the bigger investments.
Summary of Benefits
Here are some benefits you will see:
- Benefits begin very quickly.
- A sure foundation for all other technical skills.
- Bringing technical analysis into the process at the right time and in the right amount.
Build Quality into Process
Adapting to change works better when you know that modifications do not carry any unintended side-effects. Unforeseen side-effects can come from many sources. For example, a developer might:
- Doing something other than what they intend to do.
- Not having a clean place to make a change.
- Not understanding what they are changing.
- Making a simple “bone-headed” mistake.
Sustainable TDD is a single discipline that addresses these problems by fundamentally rewiring the development workflow. Starting by defining what the software is supposed to do crystallizes understanding of the change you intend to make and focuses your intent. Attempting to connect a test to software tells you if the software in question has a design that will support the change and triggers refactoring if it won’t. Tests already written serve as technical documentation of what something does and help a developer understand that thing before they change it. As executable specifications of behavior, tests warn someone if they have made a simple error that causes their software to violate an existing expectation.
However, TDD must be conducted in such a way that the suite of tests itself does not become an undue/unsupportable maintenance burden. Developers must learn how to conduct this discipline sustainably. This must include the issue of legacy code, and how to incorporate changes to existing, often untested code into the process.
The investment cost of Sustainable TDD can be substantial but the dividends are enormous: If done properly, it drives out much of the wasted effort in a team’s daily workflow. Some teams have reported a 25% increase in velocity after becoming competent in Sustainable TDD.
Summary of Benefits
Here are some benefits you will see:
- Bridging domain analysis and design analysis.
- An executable specification that is always up-to-date and defines what the software should do.
- Continuous protection against the most-common sources of defects.
- A persistent, verifiable record of the knowledge used to create the system.
Amplify Gains with Advanced Design
The profession of software development is founded on skills that run very deep. Basic patterns thinking and communication will greatly improve the quality of code but learning about software design is a lifelong journey. BDD and STDD help to specify what you are going to build and to automate tests for it. All of this is good, but you can realize even more improvement when you begin to think deeply about the relationship between specifications and tests.
Advanced Software Design introduces developers to additional design forces, exposes them to more design patterns, and shows how different design patterns can interact. More time spent on larger exercises gives developers an opportunity to practice the analytical part of the software design process in an intensive way. It cements the idea that software development is a profession that needs the same care and attention that any other profession would require.
Summary of Benefits
Here are some benefits you will see:
- Cementing the idea of software as a profession.
- Exposure to complete set of design forces.
- Maximizing reuse of ATDD specifications.
- Deep, business-readable visibility into health and functionality of a software product.
May 2023