Arty Starr

The Ultimate Metric

8:30 AM MDT

Since the dawn of software development, we've struggled with a huge disconnect between the management world and the engineering world. We try to explain our problems in terms of “technical debt”, but somehow the message seems to get lost in translation, and we drive our projects into the ground, over and over again.

What if we could detect the earliest indicators of a project going off the rails, and had data to convince management to take action? What if we could bridge this communication gap once and for all?

In this session, we'll focus on a key paradigm shift for how we can measure the human factors in software development, and translate the “friction” we experience into explicit risk models for project decision-making.

Data-Driven Retros in Practice

10:30 AM MDT

How does your team decide what's the most important problem to solve?

When we ask a question like “what's the biggest problem?“, it doesn't mean the biggest problems will come to mind. Instead, we're biased to think about what's bothered us most recently, annoyances, or pet peeves. It's really easy to spend tons of time working on improvements that make little difference.

But what if we had data that pointed us to the biggest problems across the team?

In this session, we'll dig into the data from a 1-month case study tracking Idea Flow Metrics, and discuss the patterns of friction during development, and how to identify the biggest opportunities for improvement with data.

Anatomy of Culture

1:00 PM MDT

What makes software development complex isn't the code, it's the humans. The most effective way to improve our capabilities as an organization is to better understand ourselves.

In this session, we'll breakdown the dynamics of culture into explicit architecture models based on a synthesis of research that spans cognitive science, biology and philosophy. We'll discuss the nature of Identity, communication, relationships, leadership and human motivation by thinking about humans like code!

If you want to better understand the crazy humans around you, you won't want to miss this talk!

Anatomy of Communication

9:00 AM MDT

In it's essence, DDD (Domain-Driven Design) is a philosophy and set of techniques for constructing a shared mental model of a system, and translating it into software. Ideally, we want conversations with other humans, and conversations with our code, to have the highest possible bandwidth. Every major problem in software development boils down to communication.

What if we enabled a dialog around the challenges, by first deconstructing the Anatomy of Communication itself using our same DDD techniques?

First, we'll start with a familiar system metaphor to give us the structure: a Network.

Imagine everyone on your team, and the software itself, are all connected by wires in a Network. Along each of these wires is a Flow of Ideas. Ideas can flow between humans, or between humans and the software. In the context of an Idea Flow Network, software is a medium for ideas.

From here, we can start to describe the dynamics of an Idea Flow Network in terms of Friction and Flow. We can invent new words, extend the models, and have dialogs about the nature of communication pain – all with our newly invented Ubiquitous Language!

In this session, we'll combine our DDD skills with cognitive science research, to bring clarity and insight to this wordless space.

Test Harnessing Legacy Infrastructure

1:30 PM MDT

In the world of legacy code, we often end up inheriting a tangled ball of mess with a lack of automation, and no clear surfaces for testing. Yet still, under these circumstances, we're expected to safely make changes without regressions. Where do we start? How do we tackle this challenge? How do we get a handle on re-architecture?

We'll start this discussion with a first-hand use case and example – tackling the re-architecture of an 800k line JBoss application with near-zero unit tests. Ugh. The only option on the table was Selenium. UGH.

Let's talk about alternative strategies. How have you tackled similar situations? How could we build a data-driven regression framework without going through the UI?

This session will be 70% discussion, focused on the challenges you've faced in test harnessing legacy code. Be ready to share the story of a challenge your facing, or help out your fellow attendees with advice.

We'll discuss the strategies used to conquer the challenge in this case study, and how you could apply the same pattern to your own projects.

Putting Out Fires with Gasoline

3:15 PM MDT

Once upon a time, it was just me and my app – the days when all I had to know was “get data, put on screen.” Fast forward ten years later, and what the hell happened? The level of complexity that we deal with in modern software development is insane.

Are we really better off than we were 10 years ago, or have we just been putting out our fires with gasoline?

In this session, we'll turn the projector off, and focus on a deep-dive discussion, contrasting the world of 10 years ago versus today. Rather than generalizations and hand-waiving about the golden promises of automation and magic frameworks, we're going to question everything and anchor our discussions in concrete experience.

Looking back across your career in software development, how has the developer experience changed?

First, we'll dig into the biggest causes of friction in software development, and how our solutions have created new problems. Then we'll focus on distilling strategies for overcoming these challenges, and how we can take our teams, and our industry in a better direction.