1. A Logic Meta-Programming Approach to support the Co-Evolution of Object-Oriented Design and Implementation Roel Wuyts 15-12-2000, PROG

2. 2 Roadmap Context Thesis Synchronization Artifact: Synchronization Framework –SOUL –Declarative Framework –Synchronization Tool Framework Validation –HotDraw Experiments –MediaGeniX Experiments Conclusion and Future Work

3. 3 Context: Problem Relation between design and implementation is often implicit ==>both can change independently, without leaving any traces ==>architectural drift documentation problems iterative development support problems

4. 4 Context: Co-evolution To solve these problems: co-evolutionary development: design and implementation are subject to evolution, and influence each other ==> Link explicit, and usable by tools Problem: how to support co-evolution ?

5. 5 Thesis A framework for co-evolution of design and implementation, where design and implementation are related in such a way that the one can check, generate or constrain the other, can be achieved in a logic meta-programming language integrated with a software development environment.

6. 6 Synchronization: overview Synchronization = ‘to occur at the same time’ We relax this timing constraint ==> spectrum ==> characterizing synchronization of design and implementation

7. 7 Synchronization: related work CS = CoffeeStrainer, LGA = Law Governed Architectures SRM = Software Reflexion Models, FM = Fragment Model SF = Synchronization Framework

8. 8 Synchronization Framework Framework to construct applications that require synchronization of design and implementation Goal: support different characterizations Two parts: –Declarative framework to express design as a logic meta program over implementation –Synchronization Tool Framework to integrate the declarative framework in the development environment

9. 9 Synchronization Framework: setup

10. 10 SOUL: Overview Logic meta-programming language, featuring symbiosis and reflection with Smalltalk Specific language features: –Smalltalk term: wrap extended Smalltalk code –Generate predicate: transform collection of x Smalltalk elements into x logic solutions –Quoted term: represent strings with logic variables Incremental solver implemented on top of SOUL

11. 11 SOUL: Symbiosis Up-down mechanism: ST SOUL [?c selectors isEmpty], {?c -> [Array]} [:env | (env at: 1) soulUp selectors isEmpty] false [false] up down reification in the smalltalk term of the repository and bindings used in the interpretation for reflection

12. 12 SOUL: Incremental Solver Built on top of SOUL Local propagation of changes to results of relations Symbolic constraint solver

13. 13 Declarative Framework Reifies classes, methods, instance variables and inheritance Maps design to implementation Uses the SOUL nested repositories Logic layer Representational layer Basic layer Design layer

14. 14 Synchronization Tool Framework Integrates tools with the development environment

15. 15 Validation Conceptual proof that the framework supports the characterizations Experimental proof that the framework supports the characterizations -> HotDraw experiments Experiments on real-world case study to assess the practical usability and scalability -> MediaGeniX experiments

16. 16 HotDraw Experiments HotDraw = framework for drawing editors Experiments: –Extracting design from implementation –Adding specific HotDraw design information –Generating implementation from design –Checking conformance of design and implementation Done for direct and delayed synchronization –Direct -> incremental solver –Delayed -> SOUL queries

17. 17 MediaGeniX Experiments Experiments: –Conformance checking MMM UML-diagrams with MMM’s implementation –Checking evolution in MMM’s implementation –Expressing MAF-conventions –Finding MAF-violations in the implementation Usable on real-world implementations Scalable through programming conventions Conformance checking feasible in practice

18. 18 Conclusion Co-evolution between design and implementation -> synchronization of changes Characterization of synchronization Synchronization framework artefact –design logic-meta program of implementation –design can check, generate and constrain implementation, and vice versa –Supports the characterizations Conceptual and experimental validation

19. 19 Conclusion: contributions Contributions: –Study and characterization of synchronization of design and implementation –Symbiosis of a logic meta-programming language and an object-oriented programming language –Incremental solver that uses local propagation techniques to solve symbolic constraints –The synchronization framework itself (the combination of the synchronization tool framework and the declarative framework)

20. 20 Future Work Further validation on more cases (as a framework can only become better the more it is applied) SOUL-2: SOUL, but –using stack-based interpretation mechanism, –With better reflection with Smalltalk –With a tighter integration with the incremental solver –With a true repository composition mechanism Combining Solvers: of different expressive power and performance in one system Full Co-evolution support