![](https://hackernoon.com/hn-images/1*gP88S0PeVHdQVqdHujWqaA.png)

In most projects, the amount of work is so large that one person alone cannot handle. Thus, we form _teams_ to handle the workload. A team is more than just a group of people. It is an _organization_. The team members are the components of this organization and usually affect how good the team functions but it is important for a team to be seen as a unit by an external observer. The key elements of a team are communication, vision, and trust. These elements form the team _culture_ and act as the glue that keeps the members together.

In software development, we deal with code. We write code, we refactor code, and at the end of the day, we deliver code. _Note: the code is the product of the intellectual work that the developers do, it is not the actual work (more on a future post)_. The code _belongs_ to the team thus the team _owns_ it and is _responsible_ for it. Being responsible for the code our team writes is something that every professional developer should do. Apart from this professional obligation, it is also a prerequisite for a great outcome. Behind every success, there is a team of highly motivated and engaged people who are responsible for what they do, not because they _have_ to but because they _want_ to.

### Communication & Conway’s Law

Nowadays, we deal with microservices where every team has (usually) the responsibility of the full stack for its services (backend, frontend, and even dev-ops related stuff). The communication within the team as well as across teams is crucial to the success of the team as the [Conway’s Law](https://en.wikipedia.org/wiki/Conway%27s_law) applies. Thus, it is essential to share the responsibilities in the team in a way that _a)_ improves the team’s performance, _b)_ makes the communication more efficient and _c)_ reduces the cost of changing the formation of the team. By giving the responsibilities of a particular area to one or two members of the team, the team can suffer if these members leave the team (see [bus factor](https://en.wikipedia.org/wiki/Bus_factor)). Also, the other members will not feel they _own_ the code of this area as they do not maintain it and it will be difficult for them to be responsible for this code they will probably avoid maintaining it. In that way, the team will eventually be fragmented into sub-teams without clear structure and then will be dysfunctional, since communication will be limited, and the initial common goal of the team will be transformed into, possibly conflicting, goals of each sub-team. Note that this is entirely different from having well-defined sub-teams split by technological or functional area. In this case, a sub-team is considered as a team. The problems start when some specific members of the team deal only with specific areas of the code where other members could also work on these areas, as we will see in the next section. A great post on the problems of individual members owning the code instead of the team owning the code is [this one](https://medium.freecodecamp.org/why-code-ownership-sucks-and-you-should-never-work-somewhere-that-practices-it-b8fc1c694074).

### Team culture

Having a solid team culture with strong foundations is crucial. The team culture defines the team. Team culture is everything that new member notice when they join the team. The communication structures, the processes, the way that the code is designed and written, the mission and the vision of the team, etc., are elements of the team culture. In this post, we will focus on the culture regarding the code and the processes.

First of all, the team members have to believe that the processes they choose are going to help the team and themselves grow and perform better. Regarding the code, they need to have a common understanding of the standards they have. All the members should be sure on how the outcome (code) should look like, even if the less experienced ones might need some help to achieve it. This is important for the conflicts to be reduced since all the members will know what is the right thing to do. The ultimate test is for someone outside the team not to be able to tell who wrote the code by just looking at it. The code should look like it is written by the team and not by individuals with different coding standards or worse, code formatting. _Consistency matters!_ As soon as they agree on that, they need to decide on ways (processes) to ensure it. Code reviews and pair programming are the most effective process to ensure the quality of the code.

Code reviews work asynchronously. A developer creates a pull request and asks for one or more team members to review it. The reviewers check that the code follows the coding standards of the team and works appropriately and submit some comments that need to be addressed for the pull request to be approved. A technique that I have found useful for code reviews is described in [this post](https://hackernoon.com/test-driven-code-review-3f05f6cee400).

Pair programming, on the other hand, is synchronous. Two or more developers write code together, so the feedback loop is practically zero as the in-person discussion replaces the code review comments. Out of all the processes I have dealt with so far, I found pair programming to be the most efficient in many ways, especially for new team members. Except for the instant feedback loop, it also helps the new team members get familiar with the other members and the processes and builds up the teamwork. I find it more efficient for myself to pair with someone and learn how the code should be written and what patterns we should follow in the code instead of reading a wiki page. The discussion during the pair programming helps on building the culture of the team.

Another process that helps the new members be and feel part of the team is to have them do something productive that helps them learn. Instead of spending the first few weeks reading wikis and browsing the code it is better to do some hands-on work. Since she might not be able to produce code that meets the quality standards of the team and not be familiar enough with the codebase to make changes in it, it is better for them to start writing tests. Tests are quite useful because they have a limited scope so even if the new member is not experienced, she can follow and also, they are a good way for a developer to get familiar with the code. Moreover, having someone else to write tests for you might not be compliant with TDD but helps in identifying more corner cases, since the author of the tests is testing on the specification, completely unbiased on the implementation. So, it is a win-win situation!

Obviously, for code review and pair programming to work all the members of the team should work on almost all the code. Team spirit, good communication, and collaboration are prerequisites for all these processes.

### The trap!

There is a trap that the team should avoid when applying these processes. Less experienced members might feel overwhelmed or less important if the level of the quality is set very high from the beginning. In that case, the team gets exactly the opposite results as it is split into experienced and less experienced members and have the problems mentioned earlier. In order to overcome this issue, the level of the quality should be set around the average level the team can handle and, as the time goes by, be increased. By doing so, the level of the team is increased, and the members are comfortable with the quality standards. The speed of this increment requires careful planning. This is where the more experienced members, along with the tech lead, can help more. They can be the accelerators of the process by mentoring the others, advising on new techniques and push for higher quality. For example, if a team has no experience on TDD it is not easy to start practicing it. The team should start by practicing testing, then move on to refactoring the code and eventually reach to the point of writing the tests up front and refactoring the code in each TDD cycle. Before moving to the next step, the members should feel comfortable on the current one. A great talk on how the tech lead (and experienced members) can help the team achieve its goals and the members be improved is “[_Why Technical Leadership Matters_](https://youtu.be/_6BKK1SPAVI)_”_.

The incremental improvement of the quality does not mean that we should compromise the quality of the deliverable or create huge tech debt but instead have better quality and a team that performs better in the long term. It might be more difficult than it sounds as there could be deadlines that move the team in the opposite direction, but as in every good practice, the long-term results are almost always better. Consider TDD or testing in general, one might argue that writing tests slows the development process, but we know that it is not true!

> “The whole is greater than the sum of its parts.”

> Aristotle

### Further Reading

1.  [Conway’s Law](https://en.wikipedia.org/wiki/Conway%27s_law)
2.  [Bus factor](https://en.wikipedia.org/wiki/Bus_factor)
3.  [Test-Driven Code Review](https://hackernoon.com/test-driven-code-review-3f05f6cee400)
4.  [Why code ownership sucks and you should never work somewhere that practices it](https://medium.freecodecamp.org/why-code-ownership-sucks-and-you-should-never-work-somewhere-that-practices-it-b8fc1c694074)
5.  [“Why Technical Leadership Matters”](https://youtu.be/_6BKK1SPAVI) by Patrick Kua

Glue

Too Long; Didn't Read

Cassandra Forward a free Cassandra-focused community event

The importance of team culture

Too Long; Didn't Read

Company Mentioned

@the-code-gang

RELATED STORIES