Engineering Excellence: Declan Whelan on Technical Health, Agile Practices, and Team Culture
14 Sep 2024 (27 days ago)
Technical Debt and Technical Health
- Ward Cunningham invented the term "technical debt" in the late 1990s to describe the trade-off between short-term benefits and long-term consequences of taking shortcuts in software development. (2m20s)
- The term "technical health" is presented as an alternative to "technical debt" to promote a more positive perspective and emphasize the ongoing nature of maintaining software systems. (3m37s)
Measuring Technical Health
- Measuring the effectiveness of technical practices should be customer-focused, with metrics like those used in the DevOps movement, which emphasize delivery to customers. (5m50s)
- Four key metrics that can be used to measure technical health are deployment frequency, lead time for change, change failure rate, and meantime to recovery. (6m27s)
- Value streams and overall flow metrics, such as the six flow metrics used in SAFe, can provide a broader view of technical health than DORA metrics alone. (7m34s)
Organizational Barriers to Collaboration
- Organizational barriers, such as separate reporting structures and repositories for QA and development teams, can hinder the shift-left movement towards collaborative development practices. (11m6s)
Evolution of Software Development Methodologies
- Extreme Programming (XP), developed by Kent Beck around 1999-2000, initially gained popularity as the definitive method for software development but later declined. (12m13s)
- While Scrum doesn't address technical practices, frameworks like SAFe, often incorporating XP, frequently prioritize other aspects over technical practices. (12m48s)
Core Technical Practices of XP
- Four core technical practices of XP include pair programming (now potentially encompassing ensemble or mob programming), test-driven development, refactoring, and simple design. (16m9s)
Architectural Shifts and Service-Oriented Approaches
- Architectural shifts often swing between large monoliths and microservices, with many companies adopting service-oriented approaches. (18m3s)
- A common issue with service-oriented architectures is the early design of service boundaries, which can create friction when changes are needed. (18m24s)
- Architectures that allow deferring or encapsulating service boundaries within a monolith are seen as beneficial. (18m54s)
- Technologies like Elixir and Erlang facilitate easier changes across multiple system parts due to their design of cooperating services. (19m9s)
- Monorepos, where multiple services are managed within a single repository, are becoming a trend to simplify changes and deployments. (19m31s)
Effective Team Culture
- Effective team culture involves collective ownership and stewardship of code, emphasizing high-quality work and future maintenance. (20m42s)
- Continuous learning and collaboration are crucial, with practices like pair programming and ensemble programming promoting shared knowledge and skills. (21m47s)
- True collaboration, rather than mere coordination or cooperation, is essential for solving problems effectively within teams. (22m22s)
Pair Programming and Mob Programming
- Pair programming is shown to produce higher quality work with fewer defects, although it may not significantly increase productivity. (23m19s)
- To determine if pair programming is beneficial, experimentation is recommended. If it proves successful, it should be continued; if not, alternative approaches should be explored. (23m59s)
- Mob programming presents a greater challenge as it necessitates the participation of an entire team. A suggestion for implementation is to dedicate an hour every Friday to collaborative coding exercises, potentially using a "toy" problem, to enhance skills. (24m28s)