The following are assumed as general practices:
The team follows the Ground Rules
The team knows how to use the Calendar (notifications, invitations, out-of-office settings), Camera, Microphone, Video Conferencing, Screen Sharing
The team knows how to use Ticketing (e.g., JIRA) & Documentation (e.g., Confluence)
The team knows how to use version control - committing, merging, etc.
The following are assumed to be practiced as part of the regular developer work:
Learn how to use your IDE productively. This is a big time saver in general and helps you be more productive.
Practice and memorize IDE shortcuts. It is much more productive to use the keyboard rather than move your mouse.
Resolve any Compiler Information or Warning messages. This will reduce the possibility of some bugs occurring and help improve your code.
Use Code Cleanup tools in your IDE (or other extensions). This minimizes debates about code formatting and helps ensure coding style consistency.
Use SonarLint in your IDE (and/or any other equivalent tool). This will help you solve any code smells or potential bugs. We recommend at least SonarLint, but you may also consider tools such as ReSharper to help with refactoring.
Reduce your commit size and commit at least daily. We recommend committing code at least once a day. With smaller commits, you can move safely, and revert the last commit if you have problems.
The following are prerequisites for our Technical Coaching sessions:
Learn how to run Code Coverage. You may see tutorials how to do this.
Learn how to run Mutation Testing (e.g. Pitest for Java, Stryker for .NET and JavaScript, Mutmut for Python). You may see tutorials how to do this.
The following are assumed to be practised as part of regular developer work:
Setup a Deployment Pipeline (build-test-deployment automation). This ensures that Build-Test-Deployment can be executed automatically, so that we can be sure our build is passing all the time. The Deployment Pipeline should fail on compilation error, fail on test error, fails on deployment error. Whenever there is a failure in the Pipeline, it should be a top-level priority for the team to resolve it before going forward.
Include SonarQube as part of the Deployment Pipeline, so that static code analysis can be executed after passing tests. SonarQube is useful for metrics about quality, and it can catch problems not caught through SonarLint. SonarQube helps reduce code review time.
Enforce stricter constraints such as: zero compiler warnings, zero TODO comments, SonarQube thresholds (these can be done either through reporting from the Deployment Pipeline or making the pipeline fail)
The following are recommended for the purposes of Technical Coaching:
Include Code Coverage thresholds as part of the Deployment Pipeline, including minimums:
Include Mutation Testing in a separate pipeline, because we will occasionally be running it (it catches coverage problems not caught by Code Coverage, such as missing assertions)
It is assumed that the Engineering Leader and Team Lead have taken any steps required to ensure their team has familiarized themselves with their tech stack. This is important for productivity, because it reduces the developer time in getting to a working solution:
Ensure your team has basic knowledge of their programming language, libraries, and frameworks (e.g., through courses and tutorials). Many courses provide basic skillsets to developers on how to use a certain programming language, how to use the framework, how to write a REST API, how to use the ORM, and how to use messaging queues. These courses are much more time-effective compared to starting from zero with tutorials.
You may consider building a sandbox or knowledge base regarding those practices. Your team may create a simple sandbox project which they use for technological learning - for example, building a simple CRUD REST API and practicing using the ORM, building a microservice sandbox project where they practice messaging communication. The benefit of these projects is they have low business complexity but are great examples of how to do something in a framework. Furthermore, the team may also write a knowledge base of how-to do something within their language or framework and accumulate knowledge from courses and tutorials. This means just one person finds out how to do one-to-many relationships in the ORM, documents it once, and the whole team uses it.
The Team Lead should be mentoring the team in their tech stack. The team lead should identify any knowledge gaps, and help the team build the sandbox, the knowledge base and also provide mentoring in cases where they couldn't find the answers through courses and tutorials.
The following are required for Technical Coaching:
It is the responsibility of the company has arranged any necessary training or courses for their developers in their tech stack skillsets, the skillsets to be able to program out a working solution for features/bugs in the team's tech stack; that way we minimize spending time during Coaching sessions in debugging why something isn't working in the REST API, why something is not working with the Message Queues, etc.
In our Technical Coaching, we assume the team has a working solution, and our coaching focus is to improve the source code and test code through refactoring.
The Technical Coach is not a replacement for the Team Lead, nor will the Technical Coach overtake any of the responsibilities of the Team Lead.
The Team Lead is responsible for the following, as part of the regular development practices:
Ensuring that the Deployment Pipeline has been setup, which at minimum contains Build-Test-Deployment automation, SonarQube
Ensuring that the team is productive in their usage of IDE (including IDE shortcuts), usage of Code Cleanup and SonarLint tools; and that any internal training has been provided to the team to help them accomplish those skillsets
Ensuring that the team has basic proficiency in their programming language, frameworks and languages; and that any courses or training has been provided to the team, as well as mentoring, to help them accomplish those skillsets
Furthermore, for Technical Coaching, where Test Automation is a key part of the improvements we introduce, we require that the Team Lead has:
Ensuring that the team can run Code Coverage and Mutation Testing in their IDE; this can be accomplished through tutorials
Ensuring that Code Coverage is included in the Deployment Pipeline, ensure that Code Coverage thresholds have been activated; if the team already didn't have tests, this can be set to an arbitrarily low number, as we will increase this threshold over time
Ensure that Mutation Testing has been included in the Deployment Pipeline (preferably a separate Deployment Pipeline because Mutation Tests are slower-running and will be run less frequently)
The Technical Coach will assume:
The team has already resolved any compiler errors, compiler warnings, SonarLint/SonarQube warnings
The team is comfortable in using their technology stack to get to a "working solution" (we assume only a "working solution", we do not have assumptions about code quality)
The team knows how to run Code Coverage and Mutation Testing locally (we only assume that the team has used tutorials to find out how to run it, but not that they are using it)
Based on these assumptions, the Technical Coach will be able to focus on the following:
Coaching the team in Test Automation & Test Driven Development
Coaching the team in refactoring Working Code towards Clean Code