Abstract
A Big Ball of Mud is haphazardly structured, sprawling, sloppy, duct-tape and bailing wire, spaghetti code jungle. We've all seen them. These systems show unmistakable signs of unregulated growth, and repeated, expedient repair. Information is shared promiscuously among distant elements of the system, often to the point where nearly all the important information becomes global or duplicated. The overall structure of the system may never have been well defined. If it was, it may have eroded beyond recognition. Programmers with a shred of architectural sensibility shun these quagmires. Only those who are unconcerned about architecture, and, perhaps, are comfortable with the inertia of the day-to-day chore of patching the holes in these failing dikes, are content to work on such systems.
Still, this approach endures and thrives. Why is this architecture so popular? Is it as bad as it seems, or might it serve as a way-station on the road to more enduring, elegant artifacts? What forces drive good programmers to build ugly systems? Can we avoid this? Should we? How can we make such systems better?
Come and hear what Brian and Joseph have to say about the Big Ball of Mud, and other architectural patterns.
Brian Foote has over twenty-one years of professional software development experience. He has been working with Smalltalk and objects since 1985.
Brian has written numerous papers on Smalltalk, object-oriented design, software reuse, patterns, and software architecture. He used Smalltalk to prototype an extensive framework for scientific laboratory experimental control and data acquisition. He subsequently implemented this framework, OSIRIS, in C++ and sold it commercially. It is currently in use at several universities and research firms.
Brian was also involved in the development of the object-oriented enterprise frameworks developed at the Illinois Department of Public Health. His current research, on using objects to build better object-oriented languages, is being conducted in Smalltalk.
Brian is the author of over two-dozen published patterns and has been working with patterns for a long time, writing his first pattern paper for the first PLoP conference in 1994, and chaired the PLoP'96, conference on software patterns.
Joseph Yoder is a founder and principle of The Refactory, Inc., a
company focused on software architecture, design, implementation,
consulting and mentoring on all facets of software development. Joseph
has been working in the software industry since the 80's and is an
international speaker and pattern author and long standing member of The
Hillside Group, a group dedicated to improving the quality of software
development. Joe is the author of many patterns including being the
co-author 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 conferences such as AGILE, ECOOP, JAOO,
OOPSLA, PLoP, and QCON.
Joe currently resides in Urbana, Illinois where he 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 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 domain knowledge seems to be some promising avenues to
solve this problem.
