Temperature Converter

The Challenge

Since I began mentoring software teams in 1994, my first priority as an Object Mentor has been to understand each team member and hear directly from them about what they want to learn. To achieve this, I needed a way for them to evaluate their own skills, see where they stood, and decide what they wanted to ask me for help with.

The Solution: A Simple Exercise

The solution? A temperature converter.

At first glance, the task seemed straightforward:

• A GUI to input a temperature and convert it between Celsius and Fahrenheit by pressing a button or selecting an option from a list.
• A log feature to save the conversion to a text file in a predefined format by pressing another button.

Most participants thought it was simple. I’d ask if they had questions—usually, they just asked me to draw the user interface. Before starting, I would ask them for an estimate, have them write it on a whiteboard, and sign it. If more time was needed later, they could revise their estimate and sign again.

Most estimated they’d finish in one or, at most, three Pomodoros. I had booked the room for the entire day.

The Reality

Almost no one delivered anything before 3 or 4 Pomodoros. Often, the exercise stretched far beyond that. By the end of the day—and sometimes late into the night—participants were still working.

What seemed simple was anything but. Challenges emerged:

• IFs for different button scenarios.
• Exceptions and their corresponding UI messages.
• Graphics threads that froze or crashed the app mysteriously.
• The different conversion logic.

Reflections: Seeing Themselves Clearly

Team members had the chance to see themselves as they truly were, not as they imagined. This exercise, though deceptively simple, mirrors the complexities of real-world software design and development. The next day, we worked together to map out how they wanted to improve their development processes, and each developer left with something they genuinely wanted to learn.

In over three decades, no one has ever delivered a temperature converter with a good design.

Now, It’s My Turn

It’s time for me to show my solution. I’ll build it live, step by step, one object at a time.

Is This Workshop Right for You?

This workshop is for junior and senior developers, software architects, and anyone who wants to improve their software design skills.

You’ll learn to build and grow an application step-by-step, covering GUI, domain, persistence, and communication.

Modern applications, whether web or GUI-based, often suffer from tight coupling between modules. A bug in the graphical interface might unexpectedly originate from unrelated layers like persistence or communication. We’ll explore how to break this cycle of fragility.

You'll discover how to:

• Manage GUI threads effectively.
• Design interactions between components to make them interchangeable and testable.
• Apply the Defuse the IF Strategy and design patterns to decouple your architecture.

This workshop also teaches you how to handle exceptions properly, ensuring clean boundaries between modules.

What Makes This Workshop Unique?

• Build a Simple Yet Complete
  Application We start with a single button sending messages to a domain object. Step by step, we grow the architecture into a fully functioning application.
• #NoIFStrategy
  Learn to tackle problems without IF statements, avoiding brittle, overly complex code. Avoiding IF statements leads to more flexible, maintainable code that adapts easily to new requirements.
• Emerging Architecture
  See how design and architecture emerge through small, incremental steps.
• Practical Design Patterns
  Understand patterns like MVC, PAC, Mediator, Observer, etc.:
  
  • What are they for?
  • When should you use them?
  • How can they reduce complexity?
• Live Programming
  Every feature is developed live, one step at a time, applying the Defuse the IF Strategy in real-time.

Program Outline

Day 1: Breaking Down Complexity with Defuse IF Strategy and TDD

Foundations for Emergent Design

Duration: 3.5 Hours

Module 1: Setting the Stage (30 minutes)

Objectives: Establish workshop goals, introduce participants, and align expectations.

• Participant introductions and their goals for attending.
• Overview of the workshop: How Defuse-IF Strategy, TDD and the temperature converter exercise will evolve over the two days.
• Live demonstration: Exploring some poorly designed temperature converter—identifying flaws and challenges.

Module 2: Introducing Defuse IF Strategy and TDD (1 hour)

Objectives: Establish workshop goals, introduce participants, and align expectations.

• Defuse IF Strategy: Why avoiding IF statements improves flexibility and reduces complexity.
• Overview of TDD: Using tests as a design tool.
• Setting up the development environment, tools, and project skeleton.
• Live coding: Writing the first test for the temperature converter and finding the simplest solution.
• Interactive Q&A on challenges faced during the setup.

Module 3: Growing the Temperature Converter (1 hour)

Objectives: Learn how to evolve design incrementally through tests.

• Live coding: Adding functionality one test at a time (e.g., handling Fahrenheit-to-Celsius conversions).
• Reflection on emerging design principles and architectural simplicity.
• Interactive exercise: Participants identify potential areas of complexity and propose Anti-IF solutions.

Module 4: Tackling Real-World Challenges (1 hour)

Objectives: Address common issues in GUI design, logging, and threading.

• Live coding: Adding a GUI layer and logging feature to the converter.
• Discussion: Managing threads, exceptions, and decoupling modules for testability.
• Group exercise: How would you extend the converter to handle dynamic inputs or errors?

Day 2: Refining and Expanding the Design

Mastering Emergent Design and Applying Defuse IF Principles

Duration: 3.5 Hours

Module 5: Decentralizing Collision Detection

Objectives: Refine the existing solution to improve adaptability and maintainability.

• Identifying abstractions: What parts of the converter are rigid?
• Live coding: Simplifying and decoupling components to make the design more flexible.
• Discussion: How these principles apply to real-world software development.
• Exercise: Participants review their own designs and propose refinements.

Module 6: Beyond the Temperature Converter (1 Hour)

Objectives: Explore advanced applications and reflect on broader lessons.

• Can the converter "move"? Exploring dynamic behaviors through modular design.
• Experimenting with new features: What if the converter handled currencies or other units?
• Reflection: Why the Defuse IF Strategy allows us to adapt without anticipation.

Module 7: Observations and Insights (30 Minutes)

Objectives: Discuss misconceptions and key takeaways.

• Open Q&A: Participants ask questions or share their own insights.
• Final thoughts and practical next steps for applying workshop lessons.

Additional Details

• Recording Access: Participants will have access to the session recording for 30 days post-workshop.
• Student Discounts: Students studying software architecture, computer science, or software engineering can email us for a chance to receive a voucher for a full discount on the workshop fee.
• Limited Spaces: Secure your spot today and start transforming the way you develop software!