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.

 
 

Target Audience

Architects, Tech Leads, Senior Developers, and Technical Managers

Prerequisites for Attendees

The target audience is architects, senior developers, and technical managers. While we won't write any code during the class, the participants need to be comfortable with reading code. If you plan to analyze your own code -- which we encourage -- you need to have it in one or more Git repositories.

Style: Hands-on -- you will analyze real-world codebases -- so bring your laptop. The masterclass is based on the books Your Code As A Crime Scene (2015) and Software Design X-Rays (2018) by the instructor. The techniques are based on software evolution research and findings from various fields within psychology.

schedule Submitted 1 month ago

Public Feedback

comment Suggest improvements to the Speaker

  • Liked Adam Tornhill
    keyboard_arrow_down

    Adam Tornhill - Meet The Social Side of Your Architecture

    Adam Tornhill
    Adam Tornhill
    Author
    Software Design X-Rays
    schedule 1 month ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    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.

  • Liked Adam Tornhill
    keyboard_arrow_down

    Adam Tornhill - A Crystal Ball to Prioritize Technical Debt

    Adam Tornhill
    Adam Tornhill
    Author
    Software Design X-Rays
    schedule 1 month ago
    Sold Out!
    45 Mins
    Talk
    Intermediate

    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.