Reverse Engineering of Design Patterns from Java Source Code

1. Reverse Engineering ofDesign Patterns from Java Source Code UCDAVIS Nija Shi shini@cs.ucdavis.edu Ron Olsson olsson@cs.ucdavis.edu

2. Outline • Design patterns vs. reverse engineering • Reclassification of design patterns • Pattern detection techniques • PINOT • Ongoing and future work ASE 2006

3. Design Patterns A design pattern offers guidelines on when, how, and why an implementation can be created to solve a general problem in a particular context. -- Design Patterns: Elements of Reusable Object-Oriented Software Gang of Four (GoF) • A few well-known uses • Singleton: Java AWT’s (GUI builder) Toolkit class • Proxy: CORBA’s (middleware) proxy and real objects • Chain of Responsibility:Tomcat’s (application server) request handlers ASE 2006

4. Component Toolkit private static Toolkit toolkit; public static synchronized Toolkit getDefaultToolkit() protected abstract ButtonPeer createButton(Button target) protected abstract TextFieldPeer createTextField(TextField target) protected abstract LabelPeer createLabel(Label target) protected abstract ScrollbarPeer createScrollbar(Scrollbar target) Container TextField Label Button ComponentPeer TextFieldPeer LabelPeer ButtonPeer LayoutManager ComponentPeer Reverse Engineering of Design Patterns Singleton Composite layoutMgr 1 AbstractFactory 1 Strategy Bridge ASE 2006

5. Representative Current Approaches ASE 2006

6. Current Approaches • Limitations • Misinterpretation of pattern definitions • Limited detection scope on implementation variants • Can be grouped as follows: • Targeting structural aspects • Analyze class/method declarations • Analyze inter-class relationships (e.g., whether one class extends another) • Targeting behavioral aspects • Analyze code semantics (e.g., whether a code segment is single entry) ASE 2006

7. Targeting Structural Aspects • Method • Extract structural relationships (inter-class analysis) • For a pattern, check for certain structural properties • Drawback • Relies only on structural relationships, which are not the only distinction between patterns ASE 2006

8. Targeting Behavioral Aspects • Method • Narrow down search space • using inter-class relationships • Verify behavior in method bodies • Dynamic analysis • Machine learning • Static program analysis ASE 2006

9. Targeting Behavioral Aspects • Drawback • Dynamic analysis: • Requires good data coverage • Verifies program behavior but does not verify the intent • Complicates the task for detecting patterns that involve concurrency • Machine learning: • Most patterns have concrete definitions, thus does not solve the fundamental problem. ASE 2006

10. Detecting the Singleton Pattern: As detected by FUJABA Common search criteria privateSingleton() private staticSingleton instance public staticSingleton getInstance() Problem No behavioral analysis on getInstance() Solution? Inaccurately recognized as Singleton Correctly identified as a Singleton A Motivating Example public class Singleton { private static Singleton instance; private Singleton(){} public static Singleton getInstance() { if (instance == NULL) instance = new Singleton(); return instance; instance = new Singleton(); return instance; return new Singleton(); } } ASE 2006

11. GoF Patterns Reclassified ASE 2006

12. Language-provided Patterns • Patterns provided in the language or library • The Iterator Pattern • “Provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation” [GoF] • In Java: • Enumeration since Java 1.0 • Iterator since Java.1.2 • The for-each loop since Java 1.5 • The Prototype Pattern • “Specify the kinds of objects to create using a prototypical instance, and create new objects based on this prototype” • In Java: • The clone() method in java.lang.Object • Pattern Detection • Recognizing variants in legacy code ASE 2006

13. Structure-driven Patterns • Patterns that are driven by software architecture. • Can be identified by inter-class relationships • The Template Method, Composite, Decorator, Bridge, Adapter, Proxy, Facade patterns • Inter-class Relationships • Accessibility • Declaration • Inheritance • Delegation • Aggregation • Method invocation ASE 2006

14. Behavior-driven Patterns • Patterns that are driven by system behavior. • Can be detected using inter-class and program analyses. • The Singleton, Abstract Factory, Factory Method, Flyweight, CoR, Visitor, Observer, Mediator, Strategy, and State patterns. • Program analysis techniques: • Program slicing • Data-flow analysis • Call trace analysis ASE 2006

15. Domain-specific Patterns • Patterns applied in a domain-specific context • The Interpreter Pattern • “Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language” [GoF] • Commonly based on the Composite and Visitor patterns • The Command Pattern • “Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations” [GoF] • A use of combining the Bridge and Composite patterns to separate user interface and actual command execution. The Memento pattern is also used to store a history of executed commands • Pattern Detection • Requires domain-specific knowledge ASE 2006

16. Generic Concepts • Patterns that are generic concepts • The Builder Pattern • “Separate the construction of a complex object from its representation so that the same construction can create different representation” [GoF] • System bootstrapping pattern, object creation is not necessary • The Memento Pattern • “Without violating encapsulation, capture and externalize an object’s internal state so that the object can be restored to this state later” [GoF] • Implementation of memo pool and representation of states are not specifically defined. • Pattern detection • Lack implementation trace ASE 2006

17. Recognizing the Singleton Pattern • Structural aspect • privateSingleton() • private static Singleton instance • public staticSingletongetInstance() • Behavioral aspect • Analyze the behavior in getInstance() • Check if lazy-instantiation is implemented • Check if instance is returned • Slice the method body for instance and analyze the sliced program recall ASE 2006

18. Conditions theSpoon == null Statements theSpoon (created) Conditions theSpoon != null Statements theSpoon (returned) Recognizing the Singleton Pattern public class SingleSpoon { private SingleSpoon(); privatestatic SingleSpoon theSpoon; publicstatic SingleSpoon getTheSpoon() { if (theSpoon == null) theSpoon = new SingleSpoon(); return theSpoon; } } ASE 2006

19. PatternINference and recOveryTool • PINOT • A fully automated pattern detection tool • Designed to be faster and more accurate • Detects structural- and behavioral-driven patterns • How PINOT works Pattern Instances JAVA Text PINOT Source Code Pattern Instances view XMI U M L editors ASE 2006

20. Implementation Alternatives • Program analysis tools • Extract basic information of the source code • Class, method, and variable declarations • Class inheritance • Method invocations, call trace • Variable refers-to and refers-by relationships • Parsers • Extract the abstract syntax tree (AST) • Compilers • Extract the AST and provide related symbol tables and built-in functions operating on the AST ASE 2006

21. Implementation Overview • A modification of Jikes (open source C++ Java compiler) • Analysis using Jikes abstract syntax tree (AST) and symbol tables • Identifying Structure-driven patterns • Considers Java language constructs • Considers commonly used Java utility classes: java.util.Collection and java.util.Iterator • Identifying Behavior-driven patterns • Applies data-flow analysis, inter-procedural analysis, alias analysis • PINOT considers related patterns • Speed up the process of pattern recognition • E.g., Strategy and State Patterns, CoR and Decorator, etc. ASE 2006

22. Benchmarks • Java AWT (GUI toolkit) • javac (Sun Java Compiler) • JHotDraw (GUI framework) • Apache Ant (Build tool) • Swing (Java Swing library) • ArgoUML (UML editor tool) ASE 2006

23. PINOT Results • PINOT works well in terms of accuracy: it recognizes many pattern instances in the benchmarks. • Like other pattern detection tools, PINOT is not perfect: • False positives • Prototype vs. Factory Method • PINOT does not detect Prototype pattern • Prototype pattern involves object creation • PINOT identifies implementation of clone methods as factory methods • False Negatives • User-defined data structures • Container structures are commonly used with Observer, Mediator, Composite, Chain of Responsibility patterns, etc. ASE 2006

24. Pattern Interpretation • Flyweight vs. Immutable • Immutable classes are sharable singletons • Mediator vs. Facade • Colleagues of participating in the Mediator pattern can have different types • A mediator class becomes a facade against an individual colleague class ASE 2006

25. PINOT Results ASE 2006

26. Ongoing and Future Work • Investigate other domain-specific patterns • High performance computing (HPC) patterns • Real-time patterns • Extend usability of PINOT • Formalize pattern definitions • Visualizing detection results ASE 2006

27. PINOT +Eclipse ASE 2006

28. Conclusion • Reverse engineering of design patterns • Reclassifying the GoF patterns for reverse-engineering • PINOT – a faster and more accurate pattern detection tool • Ongoing and future work • More information on our website: http://www.cs.ucdavis.edu/~shini/research/pinot ASE 2006