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).