|
|
Presentation: "When should you consider meta-architectures?"
Time:
Friday 14:05 - 15:05
Location:
City Room
Abstract:
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 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, 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!
|
 |
| |
