Building software products is a team sport, and there are many positions to play on any team. In software teams, technology leadership positions have evolved over the years from primarily people management to a combination of personnel and technology management. It’s difficult for one person to fulfill these distinct responsibilities successfully; as a result, successful teams have split this role into two: Engineering management is people management, and Staff development is focused on technology production.
The success of the team is dependent on the people involved, and the understanding of the goals they need to achieve. The Engineering manager enables an understanding of these goals, enabling teammates to play their positions more effectively. This develops the person.
The individual contributor isn’t the coach; they are more like the team captain and they show by example how to fulfil the responsibilities of the position. This brings other developers up to a higher level of quality development. The Staff developer moves the technology forward. While the specifics can vary from team to team, at their core, they must fulfill the fundamentals of:
- Technical excellence, by example
- Predictability of delivery for stakeholders
- Ensuring Architecture quality through collaboration on design and review
Technical Excellence, by example
A staff developer must show technical excellence by example and how to move development forward with quality and velocity. This effort is not just building a feature, but engineering the feature so that it has the quality needed for the product to be successful in the market.
Starting with the code and showing guidance and practices for maintainability and portability with pull requests that follow a declared set of quality attributes that guide quality code. What is quality code? Code that follows common conventions that the group has decided on. This is formatting, linting and type safety so the code in the product is something everyone can recognize. Remember that the code isn’t the developer’s code, it is company property and must be maintained responsibly so that any developer can work on it. Working through pull requests by making sure the collaborators can review and push the code to production in a common way. There will be unknowns to figure out, but it’s necessary sometimes to run into the dark room and light it up together.
https://jseller.blogspot.com/2020/03/packaging-code-for-development-and.html
https://jseller.blogspot.com/2023/06/maintainable-and-portable-codebases.html
Staff developer Improves predictability by reducing scope.
Understanding the context to help build features for the user that are valuable. To move the product forward, understanding the impact of the decisions helps the predictability of the process and communication during design implementation
The smaller the better and output an implementation Epic to understand the definition of done for this enhancement. Work that implementation to production. Use feature flags to enable this functionality to the user when releasing to the production environment
https://jseller.blogspot.com/2019/01/software-releases-are-lot-more-than-code.html
Ensures architecture quality and collaboration on the definition of that quality
Operationally the Staff developer ensures a high level of adherence to the quality attributes of the system. The functionality, does it have some understanding of the problem we are solving for the user?
Collaborate on functionality, observability, and the tools and processes that enable easy maintenance of the product in production. Adhering to known standards establishes good practices and processes.
https://jseller.blogspot.com/2019/01/feature-definition-with-quality-model.html
Does the solution have a coherent definition of the functionality and acceptance criteria? Staff developers know they can’t build the whole thing in one change, but able to break down the solution into smaller chunks and gain agreement on the smallest definition of done that shows the value
Evolving the architecture together
To support any functionality there will be changes to the architecture. Develop a strong culture of design through a standardized process of RFC (or ADR) review in the team.
- system requirements map to unit tests so the understanding of the scope is clear.
- build tests from the acceptance criteria for integration testing in the development and staging environment
- build sanity/smoke tests to validate this functionality in the production environment
- build observability, performance, security, and portability from these small changes,
- Working with living specifications enables async collaboration. Keep these documents concise and to the point.
- Good design ‘fits in’ to the system, use diagrams for containers, and components. that are new or changes
- https://jseller.blogspot.com/2023/06/consistent-software-design-enables.html
- https://jseller.blogspot.com/2020/02/communicating-software-architecture.html
Wrap-up
Staff development brings an awareness of the product and company’s goals to technical development. This ensures the teammates can align on the architecture and collaborate at scale to deliver a quality product. This direction, and most importantly, the collaboration with the team members, ensures that the product produced can fulfill the goals of the company’s place in the market.
No comments:
Post a Comment