Conference Talk: Joseph Yoder on “Taming Big Balls of Mud with Diligence, Agile Practices, and Hard Work”

sw-arch-2014-headerDuring the First Israeli Conference on Software Architecture, our invited keynote speaker Joseph Yoder gave a talk about “Taming Big Balls of Mud with Diligence, Agile Practices, and Hard Work”.

Title: Taming Big Balls of Mud with Diligence, Agile Practices, and Hard Work

Abstract: This talk will examine the paradoxes that underlie Big Balls of Mud, what causes them, and why they are so prominent. I’ll explore what agile practices can help us avoid or cope with mud. I’ll also explain why continuous delivery and TDD with refactoring is not enough to help ensure clean architecture and why it is important to understand what is core to the architecture and the problem at hand. Understanding what changes in the system and at what rates can help you prevent becoming mired in mud. By first understanding where a system’s complexities are and where it keeps getting worse, we can then work hard (and more intelligently) at sustaining the architecture. Additionally, I’ll talk about some practices and patterns that help keep the architecture/code clean or from getting muddier.

These are the original slides of Joe’s presentation:

Here is the video of the talk (in English):

Description: Big Ball of Mud (BBoM) architectures are viewed as the culmination of many design decisions that, over time, result in a system that is hodgepodge of steaming and smelly anti-patterns. It can be arguably claimed that one of the reasons for the growth and popularity of agile practices is partially due to the fact that the state of the art of software architectures was not that good. Being agile, with its focus on extensive testing and frequent integration, has shown that it can make it easier to deal with evolving architectures (possibly muddy) and keeping systems working while making significant improvements and adding functionality. Time has also shown that Agile practices are not sufficient to prevent or eliminate Mud. It is important to recognize what is core to the architecture and the problem at hand when evolving an architecture.

This talk will examine the paradoxes that underlie Big Balls of Mud, what causes them, and why they are so prominent. I’ll explore what agile practices can help us avoid or cope with mud. I’ll also explain why continuous delivery and TDD with refactoring is not enough to help ensure clean architecture and why it is important to understand what is core to the architecture and the problem at hand. Understanding what changes in the system and at what rates can help you prevent becoming mired in mud. By first understanding where a system’s complexities are and where it keeps getting worse, we can then work hard (and more intelligently) at sustaining the architecture. This can become a key value to the agile team. The results will leave attendees with practices and patterns that help clean your code (refactor) as well as keeping the code clean or from getting muddier.

Additionally, I’ll talk about some practices and patterns that help keep the code clean or from getting muddier. Some of these include: Testing, Divide & Conquer, Gentrification, Demolition, Quarantine, Refactoring, Craftmanship and the like.. The original Big Ball of Mud paper described some best practices such as SHEARING LAYERS and SWEEPING IT UNDER THE RUG as a way to help deal with muddy architectures. Additionally there are some other practices such as PAVING OVER THE WAGON TRAIL and WIPING YOUR FEET AT THE DOOR that can make code more habitable.

Bio: Joseph Yoder is a founder and principle of The Refactory, Inc. and Teams that Innovate, companies focused on software architecture, design, implementation, consulting and mentoring on all facets of software development.

Joseph is an international speaker and pattern author and longstanding member of The Hillside Group, a group dedicated to improving the quality of software development. He is coauthor of the Big Ball of Mud pattern, which illuminates many fallacies in the approach to software architecture.

Joseph has chaired the Pattern Languages of Programming Conference (PLoP), as well as presented tutorials and talks at various international conferences. Joe teaches Agile Methods, Architecture, Design Patterns, Object Design, Refactoring, and Testing in industrial settings and mentors many developers on these concepts.

Joe currently resides in Urbana, Illinois where he had led teams of developers who have constructed systems based on enterprise architecture; specifically adaptable architecture. Projects involve working in various environments such as Ruby, Java, and .NET deploying Domain-Specific Languages for clients.

Joe thinks software is still too hard to change. He wants do something about this and believes that putting the ability to change software into the hands of the people with the domain knowledge seems to be one promising avenue toward solving this problem.

The conference was organized with the cooperation of ILTAM.

To participate in our future meetings, please join the IASA IL group on LinkedIn.

Feel free to share your comments below. Thanks!

About Hayim Makabee

Veteran software developer, enthusiastic programmer, author of a book on Object-Oriented Programming, co-founder and CEO at KashKlik, an innovative Influencer Marketing platform.
This entry was posted in Agile, IASA Israel, Refactoring, Software Architecture and tagged , , , . Bookmark the permalink.

One Response to Conference Talk: Joseph Yoder on “Taming Big Balls of Mud with Diligence, Agile Practices, and Hard Work”

  1. Muhammad Affaan says:

    Excellent talk.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s