Understanding Shared Understanding
As an individual developer working on a personal project, you tend to have a very clear vision and understanding of what you’re working on but the moment another developer joins, everything changes. You are suddenly faced with the challenge of making sure that this new developer understands as much as you do and that they get the whole picture.
Non-trivial projects are built by teams and the challenge of ensuring that everyone on the team understands the vision and goals of the project is what shared understanding is all about. You can also refer to shared understanding as the “why”, “what” and “how” of a project.
What is Shared Understanding
In a paper title “Shared Understanding within Military Coalitions: A Definition and Review of Research Challenges” Paul R. Smart et al. defines shared understanding as:
“Shared understanding is commonly seen as essential to the success of coalition operations. Anecdotal reports suggest that shared understanding enables coalition forces to coordinate their efforts in respect of mission goals, and shortfalls in shared understanding are frequently cited as the reason for poor coalition performance”
Though the definition above talks about military operations it generally relates to any kind of team operation. Software teams also have “coalition operations” (software development activities), “mission goals” (e.g. release version 1.0), and “shortfalls in shared understanding” that lead to “poor coalition performance” (in other words, frequent re-work, failed projects).
Why Shared Understanding is Important to Software Teams & Barriers to Achieving it
A team is made up of several people that share a common goal. Failure to buy into this common goal, whatever it may be, leads to failure in the achievement of the goal. This is why having a shared understanding across the team is very important to software teams or any type of team for that matter.
Achieving shared understanding across a team may sound simple and straight forward but in practice, it is a lot harder to achieve. Here are some reasons:
Differences in the backgrounds of team members and the level of exposure to the domain for which a problem is being solved significantly influence the shared understanding of the team. Another thing that is closely related to this is the assumptions that people make about certain things when building a mental model of a problem or a solution.
A Constantly Shifting Context
I doubt there is any industry in which the context changes so frequently as with software development. In other engineering practices, the context defined at the start relatively remains unchanged throughout the lifetime of a project. A building project to erect a 3-bedroom duplex hardly ever changes into building a 3 story structure.
In software development though, the context of a project may change as frequently as weekly or even daily. This is the reason why the waterfall approach to software development often fails because unlike other fields of engineering, you may start out building a photo-sharing app but pivot and end up building an artificial-intelligence-based-plant-disease-detecting app. The challenge here is that the shared understanding of the team about the context of the project has to evolve at the same rate for everyone including other stakeholders, which is easier said than done.
When working alone, the lone developer is the client, product owner, architect, business/system analyst, UI/UX designer, scrum master, cross-functional developer, tester, technical writer, and project sponsor all in one. It can literally take seconds from when a new feature is imagined to when the first UI wireframes are created. It could be just a few minutes before the first lines of code are written and less than a day for the feature to hit production.
As a team, a lot of the roles listed above are found in numerous individuals. Whereas it can take a lone developer less than a day to release a single feature, it could take weeks before a team is able to get the first UI wireframes done for the same feature. The main reason this happens is due to the layers of communication (which are unnecessary most times).
Typically a team will appoint someone to relate with the client and understand their needs before relaying that information to the team. As the popular party game of Chinese Whispers (see an interesting video about this here) demonstrates, a lot of vital information gets lost in transit and the understanding the team members get differ from what the client intended. Team members who get the briefing later or are located in a different geographic location get a skewed version of the understanding. In short, the much important shared understanding is not achieved.
Location of Team Members
With co-located teams, it is a little easier to deal with all the issues listed above. Things become harder when you sprinkle remote team members into the mix. Achieving shared understanding becomes much harder mainly because remote teams are almost always informed after the fact or never at all and critical bits of information tend to fall off.
5 Ways to Achieve Shared Understanding
At this point, you may be wondering how does one achieves shared understanding across a software development team. Here are a few suggestions on how to achieve this:
1. Get Everyone in the Room
Try as much as possible to get everyone in for project-related activities such as meetings with the client. The reason why this helps in achieving shared understanding is that it flattens communication channels. When the developers hear what the client needs directly they tend to get a better understanding of what is required and may even see better ways of getting things done. Recording important meetings also help.
2. Consciously Develop a Shared Language/Vocabulary
When communicating about how to solve problems within a team, it is important to eliminate vagueness. To do this, the key things that are repeatedly talked about, entities, and domain concepts need to be defined by a single agreed-upon word or phrase. These words/phrases should be made available to all team members (for example, sticking to the agreed words or phrases in all meetings, gently correcting any misunderstandings or misuse, listed on a physical team board).
3. Meet Regularly
Meeting regularly helps reduce the adverse effect of constant context morphing. Adopting some agility in your software development approach helps with this. For example, daily stand-ups are great ways to ensure everyone on the team is still on the same page. Regular meetings with the client to demonstrate progress also guarantee that “understandings” are still valid.
4. Imbibe an Instant Feedback System
When having one-on-one discussions, there is a feedback system a team can imbibe to ensure that there is shared understanding between the individuals involved. Instead of one of the parties involved in the discussion saying “yes, I understand”, the individual should instead explain what they understand and state how this information will affect their work. Doing this simple thing forces the parties involved in the discussion to get on the same page as more often it will be seen that when one says “yes, I understand” it doesn’t always mean that the individual’s understanding is the same as the other’s. This technique can easily be applied to group meetings as well. You can view this as a summary and conclusion section of any team-related discussion.
5. No Dumb Questions/Suggestions
You can speak from here to Mars but until you get some feedback from your audience (an individual or group) you really can’t tell if they understand what you’re trying to communicate. Environments and team cultures that make it hard for members to express themselves will typically have low levels of shared understanding and high levels of re-work. To improve the levels of shared understanding on your team you need to allow team members to express themselves freely because this gives you an opportunity to gently correct any misunderstandings. You also need to give extra attention to new team members as they are still learning the team culture and are usually under pressure to fit in that they tend to not reveal their misunderstandings in meetings.
Software development is a communication problem. The key to picking up momentum as a team and maintaining it comes down to how well everyone on the team understands why they are doing what they are doing, and how they plan to get it done. Everyone has to be on the same page and this is what shared understanding is all about. Differences in team member’s domain knowledge, a constantly shifting context, communication channels, and geographic location of members are some of the things that make achieving shared understanding harder. Ensuring there are no dumb questions, an instant feedback system is adopted, meetings are held regularly, a shared vocabulary exists and everyone is allowed into the room helps in achieving shared understanding across a team.