Variability in Software: State of the Art and Future Directions

MONDAY, 30 SEP – 09:00 – 10:30
Variability is a fundamental aspect of software. It is the ability to create system variants for different market segments or contexts of use. Variability has been most extensively studied in software product lines, but is also relevant in other areas, including software ecosystems and context-aware software.

Variability introduces essential complexity into all areas of software engineering, and calls for variability-aware methods and tools that can deal with this complexity effectively. Engineering a variable system amounts to engineering a set of systems simultaneously. As a result, requirements, architecture, code and tests are inherently more complex than in single-system engineering. Variability-aware methods and tools leverage the commonalities among the system variants, while managing the differences effectively.

This talk will analyze how variability affects the software lifecycle, focusing on requirements, architecture and verification and validation, review the state of the art of variability-aware methods and tools, and identify future directions.


Krzysztof Czarnecki is a Professor of Electrical and Computer Engineering at the University of Waterloo. Before coming to Waterloo, he was a researcher at Daimler Chrysler Research (1995-2002), Germany, focusing on improving software development practices and technologies in enterprise, automotive, space and aerospace domains. He co-authored the book on “Generative Programming” (Addison- Wesley, 2000), which deals with automating software component assembly based on domain-specific languages. While at Waterloo, he held the NSERC/Bank of Nova Scotia Industrial Research Chair in Requirements Engineering of Service-oriented Software Systems (2008-2013) and has worked on a range of topics in model-driven software engineering, including software-product lines and variability modeling, consistency management and bi-directional transformations, and example-driven modeling. He received the Premier’s Research Excellence Award in 2004 and the British Computing Society in Upper Canada Award for Outstanding Contributions to IT Industry in 2008.

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

TUESDAY, 01 OCT – 16:30 – 18:00
Abstract. 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, smelly anti-patterns. Yet how
BBoM architectures come into existence and successfully evolve is much
more nuanced. BBoMs often do not result from well-intentioned design
ideas gone wrong. Nor are they simply an accretion of expedient
implementation hacks. Often BBoM systems can be extremely complex,
with unclear and unstable architectural boundaries and requirements.
Because of their complexity, BBoM architectures are likely not
understood by any single mind. They typically are fashioned out of
many parts, which together comprise a sprawling whole. So BBoM systems
can and do have good, as well as bad and ugly parts. Successfully
deployed BBoM systems continue to work well enough, in spite of their
design flaws. How can that be?

Much has happened in our industry since the original discussion and
publication of the Big Ball of Mud paper in 1998. When that paper was
originally published, agile methodologies such as eXtreme Programming
and Scrum were just beginning to gain popularity. The growth and
popularity of agile practices might be partially due to the fact that
the state of the art of software architectures is so muddy. Being
agile, with its focus on extensive testing and frequent integration,
arguably makes it easier to deal with evolving architectures and
keeping systems working while making significant improvements and
adding functionality. However, although Agile has been around for
quite some time, we can see that it still does not prevent Mud.

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 code clean or from getting muddier 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.


Joseph Yoder is a founder and principal of The Refactory, Inc., a
company focused on software architecture, design, implementation,
consulting and mentoring on all facets of software development. Joseph
is an international speaker and pattern author, long standing member
of the ACM, and the President of The Hillside Group, a, a group
dedicated to improving the quality of software development. Joseph
specializes in Architecture, Analysis and Design, C#, Java, Smalltalk,
Patterns, Agile Methods, Adaptable Systems, Refactoring, Reuse, and
Frameworks. Joe is the author of many patterns, including being an
author of the Big Ball of Mud pattern, which illuminates many
fallacies in the approach to software architecture.Joe currently
resides in Urbana, Illinois. He teaches Agile Methods, Design
Patterns, Object Design, Refactoring, and Testing in industrial
settings and mentors many developers on these concepts. He currently
oversees a team of developers who have constructed many systems based
on enterprise architecture using the .NET environment. Other projects
involve working in both the Java and .NET environments deploying
Domain-Specific Languages for clients. Joe presents tutorials and
talks, arranges workshops, and organizes leading technical conferences
held throughout the world, including international conferences such as
Agile, Agile Portugal, Encontro ¡gil, AOSD, CBSoft, JAOO, QCon, PLoP,
AsianPLoP, SugarLoafPLoP, OOPSLA, ECOOP, and SPLASH. Joe thinks
software is still too hard to change. He wants do something about this
and believes that with good patterns and by putting the ability to
change software into the hands of the people with the knowledge to
change it seems to be on promising avenue to solve this problem.