Presentation: "When should you consider meta-architectures?"

Time: Friday 14:05 - 15:05

Location: City Room


There are times when a system must adapt to new requirements within months or weeks rather than years. These new requirements can include complicated rules and new products or services the organization needs to scale to suport.  As the system scales up and becomes more complicated it can become very hard to adapt quickly to these changing requirements.  In fact, the system can even become harder to change and slower to accept new requirements.  This can lead to a desired architecture that is designed to scale allowing the system to more easily adapt to changing requirements.

Do you have the goal of building a system that can be extended and adapted without programmer intervention? Do you have the itch to explore meta-programming, not just because it is cool or complicated, but because you want your system's behavior or domain representations to scale? If so, consider learning about the design of systems that represent user-defined behavior specifications as metadata.

Architects create Adaptive Object-Model systems when they want to enable end-user programmers to adapt their system's behavior and they don't want developers to become the bottleneck. But what does it take to build a system that can be changed and adapted without programming? How do Adaptive Object-Models differ from little languages or DSLs and when is it appropriate to consider stepping into the meta world to build such an extensible system? This talk presents the basic ideas about meta-architecture such as an Adaptive Object-Model architecture and shares experiences that the presenters have had building and tuning various production meta-architecture systems that have enabled organizations to scale them more easily and without programming wizardry.

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!