Training: "Rulemakers and Toolmakers: Adaptive Object Models as Agile Division of Labor"

Time: Monday 09:00 - 16:00

Location: Commonwealth Room


Ultimate Agility: Let your Users Do Your Work!

Agile practices liberate us from the straightjackets of top-down design. But, the ease with which requirements can change encourage users to overwhelm us with requests for features. The result: Featuritis. Adaptive Object-Models support changeable domain modules by casting business rules as interpreted data and representing objects, properties and relationships in external declarations. Now users can change the system themselves as their business dictates without having to deal with programmers at all. It's the ultimate in agility!

Agile practitioners value incremental delivery of working software. This typically means that there is not a long, involved design phase that precedes implementation. Design simplicity is also important. At first glance, Adaptive Object-Model based systems seem to fly in the face of these values. Yet we have found that under the right conditions, choosing to implement an Adaptive Object-Model architecture has made our users happier and have given them back the control they need to confidently revise, extend and grow their software on their own.

The centerpiece of this tutorial will be a presentation of the highlights of several real-world systems the authors have worked on.  Our examination of each will showcase ways in which the incorporation of an Adaptive Object-Model Architecture made the systems more adaptable and our users more agile, thereby justifying the additional effort and complexity of this approach. The Adaptive Object-Model Architecture will be presented as a system that represents classes, attributes, relationships, and behavior as metadata. Additionally, a review of a process for developing AOMs will be examined.

Learning outcomes:

    * See how to let users build and modify complex structures like business rules themselves, so that you, the programmer don't have to anymore.

    * Learn when and when not to use this architecture.

    * See how to make new types of objects with attributes, relationships, and behavior through using the TypeObject, Properties, EntitiyRelationship, and RuleObject patterns.

    * Learn about the other machinery, mechanisms, end-user tools, and design patterns commonly used to implement AOM systems

    * Understand when to consider AOM architectures for building end-user adaptable software.

    * Understand the basics of using metadata to represent objects, properties and relationships.

    * Be able to identify the risks of exposing programming and model extension facilities to users, and how to mitigate these risks.

    * Learn how a system that is a model based on instances rather than classes allows users to more quickly change the system by simply changing the metadata (object model) to reflect changes in the domain.

    * Understand an incremental process for developing highly adaptive systems and how important an agile process is for evolving and growing these architectures.

Attendee Background:
Attendees should have a good understanding of Object Principles.  Pattern experience is helpful.  Understanding agile software development is a plus along with an awareness of the basic concepts of Doman Specific Languages (DSLs).

Joseph Yoder, Software Patterns writer

 Joseph  Yoder

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 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. He is co-author of the Big Ball of Mud pattern, which illuminates many fallacies in the approach to software architecture. Joseph has organized and participated in many international conferences including program chair for the Pattern Languages of Programming Conferences (PLoP and SugarLoaf PLoP) and helping organize the first Agile Portugal. Joe has presented many tutorials and talks at many international conferences such as Agile, JAOO, QCon, PLoP, OOPSLA and ECOOP.

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 Adaptive Systems or Domain-Specific Languages for clients. Joe thinks software is still too hard to change. He wants do something about this and believes that by using 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.

Rebecca Wirfs-Brock, Inventor of Responsibility-Driven Design

 Rebecca  Wirfs-Brock

Rebecca Wirfs-Brock, president of Wirfs-Brock Associates and IEEE Software's Design Columnist, is a well-known and respected object practitioner. She invented the way of thinking about objects known as Responsibility-Driven Design and is the lead author of Object Design: Roles, Responsibilities, and Collaborations(2003) and the classic Designing Object-Oriented Software (1990). Through her writing, teaching, consulting, and speaking she popularizes the use of informal techniques and thinking tools for architects, designers, and analysts.

Rebecca is a past board member of the Agile Alliance and co-founder of the Agile Open Northwest conference. Most recently she reviewed enterprise architectures and major designs, developed courses on agile use cases, enterprise application design and developing and communicating software architecture. She mentors teams on agile design, object modeling, architecture, agile use case writing, meshing usage scenarios with use cases and agile user stories, and managing incremental, iterative object-technology projects. She practices what she teaches!