Adam will be presenting the following sessions
Adam Tornhill - A Crystal Ball to Prioritize Technical Debt
The technical debt metaphor has taken the software world with storm. No wonder, since software projects have their fair share of challenges. Most organizations find it hard to prioritize and repay their technical debt. The main reason is due to the scale of modern systems with million lines of code and multiple development teams; No one has a holistic overview. So what if we could mine the collective intelligence of all contributing programmers and start to make decisions based on data from how the organization actually works with the code? This session introduces one such approach with the potential to change how we view software systems.
In this session, you'll get an introduction to techniques that help us uncover both problematic code as well as the social dimension of the teams that build your software. The techniques are based on software evolution and findings from various fields within psychology. This combination lets you prioritize the parts of your system that benefit the most from improvements, detect organizational issues and make practical decisions guided by data. Each point is illustrated with a case study from a real-world codebase.
Adam Tornhill - Meet The Social Side of Your Architecture
Software projects often mistake organizational problems for technical issues and treat the symptoms instead of the root cause. The main reason is that the organization that builds the system is invisible in our code. From code alone, we cannot tell if a module is a productivity bottleneck for five different teams, or whether our microservice boundaries support the way our codebase evolves or not. This session closes that gap by taking a behavioral view of code combined with insights from social psychology to measure aspects of software development that we haven't been able to capture before. You learn how this information lets you detect modules with excess coordination needs, measure how well your architecture supports your organization, as well as why Conway's law is an oversimplification. To make it specific, each point is illustrated with a case study from a real-world codebase.
Adam Tornhill - Manage Technical Debt in Microservices and Monoliths
Many codebases contain code that is overly complicated, hard to understand, and hence expensive to change and evolve. Prioritizing the technical debt to pay down is a hard problem since there's always a trade-off between improving existing code versus adding new features. In this masterclass, you learn how easily accessible development data let us uncover the technical debt with the highest business impact. The techniques cover both technical and organizational decisions around your codebase, and we cover both traditional architectures as well as microservice architectures where you learn to measure non-code properties like team coupling, system mastery, and detect implicit dependencies between services.
- Identify the code that's most expensive to maintain amongst millions of lines of code.
- Put costs on technical debt and assess its delivery impact.
- Detect architectural decay and learn to control it.
- Perform architectural analyses of layers and microservices to uncover team coupling and implicit dependencies.
- Learn refactoring patterns to address technical- and architectural debt.
- Measure how organizational patterns influence code quality and the link to software architecture.
- Uncover the social side of your codebase and use data to mitigate off-boarding risks.
Participants are encouraged to take this opportunity and analyze their own codebases. As part of the workshop, you also get access to CodeScene – a tool that automates the analyses – which we use for the practical exercises. We also look at open-source alternatives, and see how we can use Git itself for data mining; the workshop is not about tools, but rather about the techniques and their applications. This is a new perspective on software development that will change how you view code.
DateTime: This workshop is scheduled on Oct 19th and 20th from 2 PM to 6 PM IST
1. What do you think is the biggest challenge faced by the Agile community today?
The biggest challenge to me is a lack of situational awareness on how the code and system evolves. Not only does software lack a physics; it's also a moving target. This means it becomes very hard to balance short and long term goals, like when to invest in improvements versus when we can live with specific code quality issues and focus more on new features. It's a trade-off and balance that is likely to shift over time in any project.
2. Tell us about the session(s) you will be presenting at the conference and why did you choose those topics?
I'm covering two main topics: the first is how we can prioritize technical debt and improvements based on how we actually work with the code. My second topic is to show how we can measure and visualize organizational factors like team coupling, key personnel dependencies, and how it impacts the evolvability of the software system.
3. What are some of the key takeaways from your session(s) at Agile India?
- Prioritize technical debt in large-scale systems.
- Balance the trade-off between improving existing code versus adding new features.
- Learn to measure long time trends in technical debt.
- Measure the social side of code and use it as a decision basis.