Architectural Point Mappingfor Design Traceability
Naoyasu Ubayashi and Yasutaka KameiKyushu University, Japan
March 26, 2012
FOAL 2012 (AOSD Workshop)
2
Overview
2
Bidirectional traceabilitybetween design and code(preserving appropriate
abstraction level)
public class Subject{ private Vector observers = new Vector(); private String state = “”; public void addObserver(Observer o){ … } public void removeObserver(Observer o){ … } public void notify(){ Iterator i = observers.iterator(); while(i.hasNext() ){ Observers o = (Observer)i.next(); o.update( this ); } } public void setState(String s){ state = s; } public String getState() {return state; }}
Prog
ram
Code
Archi
tect
u
reTraceability
1. Abstraction mechanism based on Archpoints (Pointcut-based architectural representation)
2. Traceability link based on Archmapping (Automatic verification using an SMT solver)
3
Outline
Introduction
Architectural points and mapping
SMT-based traceability checking
Conclusions and Future work
4
Introduction
5
Software architecture
Definition (Bass, L. et. al) The software architecture of a program or computing
system is the structure or structures of the system, which comprise of software elements, the externally visible properties of those elements, and relationships among them.
Architecture plays an important role in software development.
System characteristics such as robustness and maintainability depend on the architecture.
Bass, L., et al.: Software Architecture in Practice, Addison-Wesley, 2003.
6
Open issues
Precious design description
Synchronization between design and code
public class Subject{ private Vector observers = new Vector(); private String state = “”; public void addObserver(Observer o){ … } public void removeObserver(Observer o){ … } public void notify(){ Iterator i = observers.iterator(); while(i.hasNext() ){ Observers o = (Observer)i.next(); o.update( this ); } } public void setState(String s){ state = s; } public String getState() {return state; }}
Prog
ram
Code
Archi
tect
u
re Important research issueAdequate support for fluidly moving between design and coding tasks
Taylor, R. N. and Hoek, A.: Software Design and Architecture --The once and future focus of software engineering,In Proceedings of 2007 Future of Software Engineering (FOSE 2007), pp.226-243, 2007.
7
Example: Observer Pattern
Architectural constraints
Class diagram Sequence diagram
8
Does this code conform to its architectural design ?
It behehaves correctly !It corresponds to its class diagram !
HoweverIt does not conform to its design !There is a code clone.
Correct implementation
9
public class Subject{ private Vector observers = new Vector(); private String state = “”; public void addObserver(Observer o){ … } public void removeObserver(Observer o){ … } public void notify(){ Iterator i = observers.iterator(); while(i.hasNext() ){ Observers o = (Observer)i.next(); o.update( this ); } } public void setState(String s){ state = s; } public String getState() {return state; }}
Solution ? – Detailed design descriptions
Det
aile
d
Mod
el
Des
crip
tion
sComplete
code generation
However,architectural design should be appropriate abstract !
Prog
ram
Code
Traditional MDD approach
10
Problems to be tackled
It is not easy to reflect the design decisions at the code level.
It is not easy to synchronize design and code with preserving adequate abstraction level.
A mechanism for checking the design traceability is needed.
11
Our approach: Archface
public class Subject{ private Vector observers = new Vector(); private String state = “”;…} Code
Architectural design
Archface(Exposure of shared
design points)
Design
Implementation
Modification ofArchitectural design
Naoyasu Ubayashi, Jun Nomura, and Tetsuo Tamai:Archface: A Contract Place Where Architectural Design and Code Meet Together. 32rd ACM/IEEE International Conference on Software Engineering (ICSE 2010), ACM PRESS, pp.75-84 (2010).
Contract between
design and code A set of
architecturalpoints
A set ofprogrampoints
However, a verification mechanism for design traceability is not provided !
Our proposal :A verification mechanism for design traceability
Basic concept Archpoint: Architectural point
Points for representing the essence of architectural design. Architecture represented by inter-component structure and message interaction
among components can be designed.
ArchMapping: Archpoint mapping A mechanism for design traceability An archpoint such as message send in design is mapped to a program point such
as method call in code.
Traceability can be verified by checking whether archpoints are consistently mapped to program points while preserving order.
For this checking, an SMT (Satisfiability Modulo Theories) solver is used. 12
Architectural points and mapping
13
14
Archpoint and ArchMapping
Bidirectional traceability while preserving appropriate abstraction level
SMTsolver
In this talk, Archmapping is introduced from
behavioral aspects
Bisimulation-based synchronization
There is a bisimulation relation between design and code. We cannot distinguish code from its associated design in terms of archpoints.
Moreover, a sequence of archpoints (behavioral archpoints such as message send) can be regarded as a process if we regard the sequence as a trace of an LTS (Labelled Transition System).
15
16
Bisimulation-based synchronization
Abstraction＝ Bisimulation in terms of archpoints
Translation from Archfaceinto logical formula
17
cSubjectComponent interface
cObserverComponent interface
cObserverPatternConnector interface
Architectural design Logicalformula
AspectJpointcut
Design description
18
Architecture is defined asa set of archpoints and
a set of constraints among them.
[List 3]Observer_Pattern := sequence( ; [predicate] cSubject_setState_message_receive, ; archpoint cSubject_notify_message_send, ; archpoint cSubject_notify_message_receive, ; archpoint iteration( ; [predicate] cSubject_update_message_send, ; archpoint cObserver_update_message_receive, ; archpoint cObserver_getState_message_send, ; archpoint cSubject_getState_message_receive)) ; archpoint
Program description
19
A program can be represented asa set of program points and
a set of constraints among them.
[List 4]Program_List1 := sequence( ; [predicate] cSubject_setState_execution, ; program point iteration( ; [predicate] cSubject_size_call, ; program point Vector_size_execution, ; program point cSubject_get_call, ; program point Vector_get_execution, ; program point cSubject_update_call, ; program point cObserver_update_execution, ; program point cObserver_getState_call, ; program point cSubject_getState_execution, ; program point cObserver_println_call, ; program point System_out_println_execution)) ; program point
Traceability check based on ArchMapping
20
ArchMapping: refine
Traceability check
Not satisfied !
Code does not conform to it
design !
SMT-based traceability checking
21
22
SMT (Satisfiability Modulo Theories)
SMT generalizes SAT (Satisfiability).
Theories Uninterpreted function symbols with equality Linear real and integer arithmetic Tuples Records Extensional arrays
Yices, one of SMT solvers, decides the satisfiability of logical formulas.
Yices: http://yices.csl.sri.com/
Yices eccoding
23
A sequence of archpointsIs encoded by an array.
Order preservation
Example of verification-- Model checking
24
Verification of temporal behavior of architectural design
Yices encoding
Bounded model checking
LTL
25
Conclusions and Future work
26
Summary
The essence of our approach is a fruitful integration of a design abstraction mechanism based on
archpoints, bidirectional mapping between archpoints
and program points, and SMT-based verification.
27
Future work
In this paper, we considered only one-to-one mapping between archpoints in design and program points in code.
We think there is a case in which one-to-multiple mapping and multiple-to-one mapping are needed.
28
Thank you for your attention.
