Let's Make Long Methods a Thing of the Past!

Developers write code as a form of communication. The code they write should tell a story and be self-explanatory. Unfortunately, there is a lot of codebases containing long, complex and hard to read methods. Developers spend a significant amount of their time reading code. The easier it is to read, then the more time they can focus on delivering business value to customers.

In this talk, attendees will learn how to recognize long methods and code paragraphs. Additionally, they will learn about simple refactoring techniques to make the code easier to understand.

Attendees will come away from this session with the ability to

- identify long methods
- refactor long methods to cleaner code
- improve naming

Cultivating a Culture of Learning and Deliberate Practice

Today’s developers are always sprinting—meetings, deadlines, and user stories leave little time for growth. Many companies don’t prioritize learning, leaving developers to improve on their own time. But what if practice was built into the workday?

My team embraces Learning Hours, where we code together and practice refactoring, TDD, clean code, and other technical practices. These interactive sessions boost morale, improve collaboration, and strengthen technical skills that lead to direct business impact.

In this talk, you’ll learn how to:

- make time for practice
- create a learning culture
- introduce Learning Hours
- use ensemble programming as a learning tool

Raleigh DevOpsDays 2024 - https://youtu.be/zBTggl1AcEU?si=iiVeO8xETC4DioS_

The Java Legacy Code Survival Guide: Add Features Without Fear

How do you feel when you need to add a new feature to a legacy system with no tests, confusing naming, and tight coupling? Nervous? Anxious? What if there was a way to make it safer to work with and even enjoyable?

The key is to make the code safer to work with by adding tests, improving names, and refactoring toward OO principles like encapsulation and abstraction. Through live coding examples, you’ll see how small, simple refactorings can make adding new features easier.

By the end of this session, you’ll be able to

- identify common Java code smells
- apply refactoring techniques to improve code design
- safely add new features to your codebases with confidence

Spring Boot, Meet ATDD: Transform User Stories into Working Software

TDD is a powerful practice, but many developers struggle to make tests truly guide their design. Without the right approach, it can feel like extra work rather than an asset. What if there was a way to make TDD more intuitive and valuable from day one?

Acceptance Test-Driven Development (ATDD) connects developers and business stakeholders by turning requirements into testable specifications. ATDD, combined with dependency simulation, creates a controlled test environment where you can confidently verify business behavior without the unpredictability of live services.

In this talk, you’ll learn about ATDD and how to translate Gherkin user stories into readable acceptance tests that reflect your domain.

By the end of this session, you’ll learn to:

- use ATDD to guide your design
- translate business requirements into readable, automated acceptance tests
- Isolate your tests from slow I/O operations using API mocking and test containers

Ensemble Programming By Example: Think Together, Code Better

Experience how high-performing teams turn coding into a true team sport. In this interactive session, we’ll explore Ensemble Programming (aka Mob Programming) by actually doing it! Volunteers will rotate through the roles of typist, navigator, and ensemble member, while applying Test-Driven Development (TDD) to engage with a coding challenge together.

With quick rotations, you’ll see how collaboration leads to cleaner code, better design, and shared learning. By the end of this session, you’ll have practical strategies to strengthen teamwork, boost efficiency, and create well-crafted software.

No prior experience needed—just bring your curiosity and be ready to code together!

3-5 mics needed
I will ask for 4 volunteers to ensemble together while I facilitate

Refactor Java with Confidence Workshop

Refactoring isn’t just cleanup. It’s how great developers keep code fast and flexible.

If you’ve ever struggled with messy logic, confusing names, or code that’s hard to change, this hands-on workshop will level up your refactoring skills.

What we’ll cover:

- Refactoring fundamentals: what refactoring is, when to do it, and why it matters
- Testing for safe refactoring: using Approval Testing and Mutation Testing to prevent regressions
- Small wins, big impact: techniques like renaming, simplifying logic, and improving structure
- Decoupling code for maintainability: separating business logic from I/O for cleaner, more adaptable systems

Expect plenty of coding, guided exercises, and practical takeaways you can apply immediately. Whether you’re new to refactoring or looking to sharpen your expertise, this workshop will give you the confidence to refactor fearlessly.

Bad Code Is Killing Your Team

Software teams don't slow down because they're adding new features. They slow down because they struggle to change and maintain their existing code. Slow releases, rising bug counts, and declining team morale are the inevitable result of poor software design practices.

In this session, we’ll break down why incremental refactoring is the key to sustainable development and how the best teams integrate it into their daily work.

We’ll explore:

- The Business Case for Refactoring – How regular code improvement reduces costs and accelerates delivery.
- Why Refactoring Feels Hard – The hidden psychological and organizational blockers that make teams resist it.
- Building a Refactoring Culture – Practical ways to make refactoring a habit without disrupting feature work.

Bad code doesn't fix itself. Either you refactor continuously or you pay the price later.

When Microservices are just Procedural Code in a Trench Coat

Java is supposed to be object-oriented, but too many codebases look like procedural spaghetti. Many enterprise Java microservices devolve into procedural scripts with global state, long functions, and poor encapsulation.

In this live coding session, we’ll take a messy procedural Spring Boot application and refactor it step by step into a modular, testable, and maintainable object-oriented microservice.

If you’ve ever been frustrated by rigid, procedural Java that resists change, this session will give you practical techniques to fix it.