W1. Ultimate Agility: Users Do Your Work!
The ongoing surge in interest in software patterns has placed a long overdue spotlight on how good programs are put together. Design patterns are distillations of design insight drawn from practice. They capture recurring solutions to software design problems. Once a designer is familiar with these patterns, he or she can use them in his or her own designs without having to reinvent them from first principles. Using patterns allows developers to make their systems more flexible, reusable, adaptable, and readable. Patterns also provide a common vocabulary for concisely communicating these architectural insights. After you learn the basics of design patterns it is often the case that you are comfortable with some of the core patterns but advanced use of some of the more complex patterns such as interpreter or visitor can still be complex and hard to adapt. Specifically when trying to build more complex adaptable systems such as those in an Adaptive Object Model (AOM).
Architectures that can dynamically adapt to changing requirement are sometimes called reflective or meta-architectures. We call a particular kind of reflective architecture an Adaptive Object-Model (AOM). An Adaptive Object-Model is a system that represents classes, attributes, relationships, and behavior as metadata. It is a model based on instances rather than classes. Users change the metadata (object model) to reflect changes to the domain model. AOM stores its Object-Model in XML files or in a database and interprets it. Consequently, the object model is adaptive; when the descriptive information for the object model is changed, the system immediately reflects those changes. We have noticed that the architects of a system with AOMs often claim this is the best system they have ever created, and they brag about its flexibility, power, and eloquence. At the same time, many developers find them confusing and hard to work with. This is due in part because the developers do not understand the architecture. There are some core advanced patterns such as Interpreter, TypeObject, EntityRelationship, and Properties that are important to know in order to build these type of flexible architectures.
This course examines review core patterns in Design Patterns. We examine the most important patterns in depth, while ensuring that attendees have seen all the patterns at least once. In addition, the Type Object, Properties, Entity-Relationship, and Interpreter patterns will be discusssed, and their roles in building highly configurable dynamic systems will be examined. The course will be taught using examples from Java, and exercises will be conducted in Java and UML. Once the class is over, students should understand and be more comfortable with implementing more advanced design patterns, know where they fit in the software development process, and be able to leverage them to solve design problems efficiently; specifically when building more dynamic adaptable systems.
This is a one-day course to be realized on 22nd of June.
Price: 300 Euros. Special discounts apply for conference participants and groups.