Runtime Specialization - Java has never been so dynamic before
Much of software development is about creating variants of things that have been done in similar ways before. Typical means to create such variants include inheritance / subtyping, extension points and dependency injection. Unfortunately, all of these approaches require that the original author anticipated the required variation points in his/her module, to enable you to create whatever variant comes to your mind. This means, modules intended for reuse tend to be bloated with indirections just in case someone needs to modify something, and still many interesting adaptations are simply not possible due to lack of pre-planning.
Object Teams reverses this situation. Creating unanticipated variants is at the core of this approach. Starting with the Neon release, even a running application can be morphed into a new variant of itself.
Outline/structure of the Session
The session presents the language OT/J, which adds three layers of dynamism to Java:
- Your POJOs are empowered to assume different Roles during their lifetime. Dynamically attaching a Role object to a base object creates a variant of the original object. This is similar to inheritance but no factories are needed to select the class, because roles can be attached at any point during an object's life-cycle.
- Roles are grouped into meaningful units, called Teams. Teams provide modular ways for controlling which Roles are active at which point in time. This allows your program to react differently in different situations.
- Starting with the Neon release, it is possible to add Role and Team classes even at runtime. No need to re-start, simply add those classes to the running applications and immediately your application morphs into a variant of itself.
With power comes responsibility. Object Teams emphasizes the importance of modularity, transparency and control. Variants are created as modules, variants are clearly visible in the application architecture, and simply deactivating any active Teams puts the application back into its pristine state.
The audience will understand the inherent conflict between two fundamental goals:
- Things change dynamically
- We want static guarantees about correct program behaviour
Participants will learn about "Roles" as a central concept in software engineering for describing aspects that change based on context, where Roles combine the desired dynamism with static analysability.
Participants will also learn, how the above concepts map to a technology stack based on Java, JDT and OSGi, each layer being extended to OT/J, OTDT, and OT/Equinox, respectively.
seasoned developers, architects