Joseph W. Yoder


Joseph W. 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, Java, C#/.NET, Smalltalk, Patterns, Agile Methods, Adaptable Systems, Refactoring, Reuse, and Frameworks. Additionally, Joe is an accomplished author, having written a few dozen published papers, including being an author of the Big Ball of Mud pattern, which illuminates many fallacies in the approach to software architecture. Additionally Joe has trained and mentored developers on various types of software applications.

Joseph W. Yoder evolved from the Software Architecture and Patterns group at the University of Illinois. Joe has worked on various projects during his career that has incorporated many technologies. These range from stand- alone to client-server applications, web applications, web services, cloud computing, service oriented architecture, multi-tiered, various databases, object-oriented, frameworks, human-computer interaction, collaborative environments, and domain-specific visual-languages. In addition these projects have spanned many domains, including Medical Information Systems, Financial Systems, Ordering, Import, Invoicing, Print, Shipping, Warehouse Management, Manufacturing, Medical Examination, Statistical Analysis, Scenario Planning, Client-Server Relational Database System for keeping track of shared specifications in a multi-user environment, Telecommunications Billing System, and Business & Medical Decision Making.

Joe teaches Agile Methods, Design Patterns, Object Design, Refactoring, and Testing in industrial settings and mentors many developers on these concepts.  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 in Brazil, AOSD, CBSoft, JAOO, QCon, PLoP, AsianPLoP, SugarLoafPLoP in Brazil, OOPSLA, ECOOP, SATURN, 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. Joe currently resides in Urbana, Illinois. (home page)


Big Ball of Mud: Is This The Best That Agile Can Do?

While much attention had been focused on high-level software architectural patterns, what is, in effect, the de facto standard software architecture has seldom been discussed: the Big Ball of Mud. A Big Ball of Mud is a haphazardly structured, sprawling, sloppy, duct-tape-and-baling-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. Somewhat to our astonishment, since our original statement made in the late 90′s, no one has ever undertaken to dispute this premise. 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? And how can we make such systems better?

This talk will examine the paradoxes that underlie Big Balls of Mud, what causes them, and why they are so prominent. What Agile Practices help us avoid or cope with mud? Does Agile practices such as TDD really help minimize mud? What are we doing RIGHT? What Agile Practices contribute to the problem? Encourage mud? Is Mud really the best that Agile can do? Is Agility’s utilitarian focus on process rather than design its secret weapon, or its Achilles heel?


Rulemakers and Toolmakers: Adaptive Object-Models as an Agile Division of Labor

Ultimate Agility: Let your Users Do Your Work!

Agile practitioners value both the incremental delivery of working software and design simplicity. But when working on Agile projects, developers can become overwhelmed with the rate of requirements change. The ease with which requirements can change encourages users to overwhelm us with requests for features. The result: Featuritis, which can promotes hasty construction of poorly designed software to support those features. The design of an expressive domain model might get lost in the rush to write working code. Adaptive Object-Models support changeable domain modules by casting business rules as interpreted data and representing objects, properties and relationships in external declarations. At first glance, AOM systems seem to contradict Agile values. Yet we find that under the right conditions, an AOM architecture has made our users happier and has given them the ability to control the pace of change. It’s the ultimate in agility!

This tutorial presents the core elements of an AOM architecture based on an example from a working system and surveys other patterns essential to this architecture style. I will then showcase several production AOM systems and demonstrate how they have given users the control they needed to confidently revise, extend, and grow their software. (More Info)

Laptops are not required.

Limit of participants: 30

  • jdd


Gold Sponsors:

  • e-point
  • j-labs

Silver Sponsors:

  • Lumesse
  • Luxoft
  • SII


  • Redhat
  • WITS

Sponsor JDD Afterparty:

  • WITS

Media Partners:

  • helion
  • Polish JUG
  • Poznan JUG
  • SDJ