Reuse Contracts as a basis for
     investigating reusability of
           Smalltalk code
                      Koen De H...
Overview
     Problems with reuse
     Problems with evolution
     What are reuse contracts?
     Reuse contracts at work...
How do You Reuse a Class?

     Cloning (copy and paste)
     Inheritance / method overriding
     Composition / delegatio...
Reuse by Cloning
    Reused ““components”” are not easily
    adaptable
    –– no support is provided for adaptation/reuse...
Reuse by Inheritance
                                           Class A

    How do you determine
      –– what to reuse (...
Example: Make a Subclass of
    Set
    Framework
                         What to override?
      Set #add:              ...
Reuse by Composition

    How do you determine
      –– what to reuse (what to compose, what to
         delegate)?
      ...
Reusing a Class is Hard

    Current OOA/OOD notations do not provide
    enough information to reuse a class
    Usually,...
Inspecting the Source Code

     To reuse a class:
     –– inspect the class
     –– inspect all its superclasses
     –– ...
What are You Looking for?
     Self sends
     Super sends
                                     Reusers need the
     Abst...
Self Sends are Important

     Self sends & template methods & abstract
     methods reify the design of a class
     Meth...
Self Sends: Planning for Reuse
ApplicationModel in VisualWorks 2.5
                                       can be reused wi...
Co-operation with Other
     Objects/Classes is Important

      Delegation of responsibilities principle
      Using dele...
Delegation: Planning for Reuse
Menu in VisualWorks 2.0
                                        can be reused for
     Menu...
Overview
      Problems with reuse
      Problems with evolution
      What are reuse contracts?
      Reuse contracts at ...
Evolution is Important

      Iterative development
      –– a framework is never finished
      Changing requirements
   ...
What to do When the
     Framework Changes?
     Framework 1.0                 Framework 2.0

         X                  ...
Example Evolution Conflict (1)
     Framework 1.0                         Framework 2.0




                              ...
Example Evolution Conflict (2)
     Framework 1.0                         Framework 2.0
          #m                      ...
More Evolution Conflicts

      Interface conflicts
      –– the name of a reused method/class has been
         changed
 ...
Spotting Evolution Problems

      Unless the changes to the framework
      are well-documented (informally), the
      a...
What are the Challenges?
     Supporting reuse
     –– what can be reused, what must be adapted, and what
        must be ...
Overview
      Problems with reuse
      Problems with evolution
      What are reuse contracts?
      Reuse contracts at ...
Reuse Contracts

      Are contracts between the framework
      developer and the application
      developer
      State...
Reuse Contract Notation

     Notation based on OMT (UML)
     Methods are annotated with
     specialisation clauses to m...
Reuse Contracts for Inheritance
                                                       specialisation clause
     Enhance ...
Reuse Operator: Concretisation

                                   Collection
     Makes abstract methods     #collect: [#...
Reuse Operator: Abstraction
                                        View
                                #preferredBounds ...
Reuse Operator: Extension
     Typically performed by an
     application developer to add           Collection
     appli...
Reuse Operator: Cancellation
                                             Collection
     Typically performed by an   ...
...
Reuse Operator: Refinement
     Adds elements to the
                                                 Object
     speciali...
Reuse Operator: Coarsening
     Removes elements from
                                       Collection
     the specialis...
Reuse Operators

      Make a distinction between different
      kinds of inheritance
      State how a class is derived ...
Frequently Used Combinations
     of Reuse Operators
     Extension & refinement
     Coarsening & cancellation
     Concr...
Multi-Class Reuse Contracts
     (in short)
     Co-operating classes are put in one reuse
     contract; these classes ar...
Reuse Contract Notation
     Interface opening          specialisation clauses              participants

                ...
Overview
      Problems with reuse
      Problems with evolution
      What are reuse contracts?
      Reuse contracts at ...
Reuse Contracts at Work
     The formal nature of reuse contracts
     enables their use in a development
     environment...
Estimating Reuse
     Framework                  Framework

      Set #add:                  Set #add: [ ]
          #addA...
Evolution
     Framework                               Framework

      Set #add: [ ]                           Set #add: ...
Documenting Reuse
                                Framework
     Framework
                                 Set #add: [ ]
...
Documenting Evolution
     Framework                                      Framework

      Set #add: [ ]                  ...
Estimating Impact of Changes
Framework                                             Framework

     Set #add: [ ]          ...
Overview
      Problems with reuse
      Problems with evolution
      What are reuse contracts?
      Reuse contracts at ...
Extraction of Reuse Contracts

     Reuse contracts for
     inheritance can be
     extracted from
     Smalltalk code   ...
Too Much Extracted
     Information
      The extractor does not know which
      methods are important
      Interaction ...
Inspecting Extracted
     Extensions




47
Inspecting Extracted
     Concretisations




48
Inspecting Extracted
     Refinements




49
Inspecting Extracted
     Coarsenings




50
Inspecting Extracted
     Cancellations




51
Spotting Bad Designs in a
     Class Hierarchy
      Look for design breaching reuse
      operators
      –– they indicat...
Spotting Bad Designs: Example
     The Stream hierarchy is awkward
     wrt. the #next method.

                     1



...
Impact of Bad Coding Style

      Bad coding style is troublesome for the
      extractor
      –– e.g. only super send, b...
Overview
      Problems with reuse
      Problems with evolution
      What are reuse contracts?
      Reuse contracts at ...
Reuse Contract Research
     Reuse contracts have been applied to
     –– classes (inheritance)
     –– sets of interactin...
Design Pattern Example
     Client                    Component      graphics

                               #operation

...
Summary: Theory

     Reuse contracts formally document what
     a reuser can assume about a ““reusable
     component””
...
Summary: Practice

      Reuse contracts for inheritance can be
      extracted
      –– examination of existing source co...
Overview
      Problems with reuse
      Problems with evolution
      What are reuse contracts?
      Reuse contracts at ...
The Browser for the Exercises

     Home-made fully-functional browser
     Composed of reusable ““browser part
     compo...
Enhanced Browser —— General

        Different views   Different views/tools


                                       Meth...
Browser —— Reuse Contracts




63
Browser —— Code Analysis




64
Browser —— Clusters




65
Browser —— Metrics




66
Exercises
      Use the enhanced browser to
      investigate Smalltalk code
      –– Examine class hierarchies based on
 ...
Up-to-date Information




       http://progwww.vub.ac.be/prog/pools/rcs/

68
Upcoming SlideShare
Loading in...5
×

Reuse Contracts

765

Published on

Reuse Contracts as a basis for investigating reusability of Smalltalk code. ESUG97, Koen De Hondt.

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
765
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
9
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Reuse Contracts

  1. 1. Reuse Contracts as a basis for investigating reusability of Smalltalk code Koen De Hondt Programming Technology Lab Computer Science Department Vrije Universiteit Brussel kdehondt@vub.ac.be http:/progwww.vub.ac.be/ 1
  2. 2. Overview Problems with reuse Problems with evolution What are reuse contracts? Reuse contracts at work Examining class hierarchies based on reuse contracts Reuse contract research Exercises: introduction to the browser 2
  3. 3. How do You Reuse a Class? Cloning (copy and paste) Inheritance / method overriding Composition / delegation 3
  4. 4. Reuse by Cloning Reused ““components”” are not easily adaptable –– no support is provided for adaptation/reuse No relation between original and result –– difficult to maintain since bug fixes and upgrades are not propagated to the derived application (proliferation of versions) ! This kind of reuse should be avoided 4
  5. 5. Reuse by Inheritance Class A How do you determine –– what to reuse (inherit)? Subclass B –– what to adapt (override)? –– what to write from scratch? Subclass C ? Subclass D 5
  6. 6. Example: Make a Subclass of Set Framework What to override? Set #add: –– #add: if #addAll: uses #add: #addAll: –– #add & addAll: if #addAll: does not use #add: CountingSet A CountingSet is a Set that Application counts all added elements 6
  7. 7. Reuse by Composition How do you determine –– what to reuse (what to compose, what to delegate)? –– what to adapt (how to compose)? –– what to write from scratch? Class B Class A ? Class C 7
  8. 8. Reusing a Class is Hard Current OOA/OOD notations do not provide enough information to reuse a class Usually, developers do not document how a class can be reused, they only document what each method does If a class comment contains reuse information, it usually has the form of a cookbook Reusers are compelled to inspect the source code 8
  9. 9. Inspecting the Source Code To reuse a class: –– inspect the class –– inspect all its superclasses –– inspect all the classes it co-operates with Source code inspection is error-prone If source code inspection doesn’’t work: talk to the developer (i.e. the expert)! 9
  10. 10. What are You Looking for? Self sends Super sends Reusers need the Abstract methods specialisation interface Template methods Default methods Methods that are overridden frequently Methods that are part of a design pattern Co-operation with other objects/classes ... 10
  11. 11. Self Sends are Important Self sends & template methods & abstract methods reify the design of a class Method decomposition –– distinguish ““core”” methods from ““peripheral”” methods Using self sends = planning for reuse –– fine-grained overriding of methods 11
  12. 12. Self Sends: Planning for Reuse ApplicationModel in VisualWorks 2.5 can be reused with other builders openInterface: aSymbol builder := self builderClass new. ... “a lot of expressions here” ... same external interface (#builderClass is private) ApplicationModel in VisualWorks 2.0 openInterface: aSymbol builder := UIBuilder new. cannot be reused with other builders ... without overriding all methods that “a lot of expressions here” refer to UIBuilder ... 12
  13. 13. Co-operation with Other Objects/Classes is Important Delegation of responsibilities principle Using delegation= planning for reuse –– a system can easily be extended by adding new classes –– objects with ““the same interface”” can be substituted for each other 13
  14. 14. Delegation: Planning for Reuse Menu in VisualWorks 2.0 can be reused for Menu MenuItem different menu items items same external behaviour same interface PopUpMenu in VisualWorks 1.0 for instance creation PopUpMenu Strings ! labels cannot be reused for different menu items 14
  15. 15. Overview Problems with reuse Problems with evolution What are reuse contracts? Reuse contracts at work Examining class hierarchies based on reuse contracts Reuse contract research Exercises: introduction to the browser 15
  16. 16. Evolution is Important Iterative development –– a framework is never finished Changing requirements –– functional: user requirements –– non-functional: maintainability, adaptibility, reusability, customisability, ... 16
  17. 17. What to do When the Framework Changes? Framework 1.0 Framework 2.0 X X Evolution ? Y Y Application Application 17
  18. 18. Example Evolution Conflict (1) Framework 1.0 Framework 2.0 d) te en #m do d m X X ot en #m cu (n lf s Evolution #p se #p Y #p Y Method capture i instance of i Application subclass of Application 18
  19. 19. Example Evolution Conflict (2) Framework 1.0 Framework 2.0 #m #m X X #p #p Evolution #p #p #q Y #q Y self send instance of Inconsistent methods i Application i Application subclass of 19
  20. 20. More Evolution Conflicts Interface conflicts –– the name of a reused method/class has been changed –– a method that was added by a reuser has been introduced by the new version of the framework Unanticipated recursion –– a method invokes another one in the application while the new version of the framework introduces an invocation of the first by the latter 20
  21. 21. Spotting Evolution Problems Unless the changes to the framework are well-documented (informally), the application developer is condemned to perform code inspection to determine what has changed Often evolution conflicts are not spotted until the application is running based on the new version of the framework 21
  22. 22. What are the Challenges? Supporting reuse –– what can be reused, what must be adapted, and what must be built from scratch ? –– formal documentation on how classes are reused Supporting evolution –– change propagation Support for estimates/testing/metrics –– feasibility of reusing a class –– the cost of ““upgrading”” the class repository 22
  23. 23. Overview Problems with reuse Problems with evolution What are reuse contracts? Reuse contracts at work Examining class hierarchies based on reuse contracts Reuse contract research Exercises: introduction to the browser 23
  24. 24. Reuse Contracts Are contracts between the framework developer and the application developer State what assumptions can be made about reusable components State how components are actually reused 24
  25. 25. Reuse Contract Notation Notation based on OMT (UML) Methods are annotated with specialisation clauses to make the specialisation interface explicit ““Reuse operators””, or ““modifiers””, lay down how reuse is achieved 25
  26. 26. Reuse Contracts for Inheritance specialisation clause Enhance the interface of a class abstract method with specialisation clauses Collection Identify what changes are made #collect: [#do:] when a class is subclassed: #do: –– concretisation/abstraction #select: [#do:] –– extension/cancellation concretisation –– refinement/coarsening #do: Specialisation clauses may contain Set names of methods invoked #collect: [#do:] through self sends, and ““super”” #do: reuse operator #select: [#do:] 26
  27. 27. Reuse Operator: Concretisation Collection Makes abstract methods #collect: [#do:] concrete #do: #select: [#do:] Does not change the specialisation clause of concretisation #do: the concretised methods Design preserving Set #collect: [#do:] Inverse = abstraction #do: #select: [#do:] 27
  28. 28. Reuse Operator: Abstraction View #preferredBounds [ ] Makes a concrete method abstract SimpleView Design breaching #preferredBounds [ ] Inverse = concretisation BasicButtonView #preferredBounds [ ] abstraction #preferredBounds LabeledButtonView #preferredBounds [ ] 28
  29. 29. Reuse Operator: Extension Typically performed by an application developer to add Collection application specific behaviour ... Adds new methods to the extension interface of a class #- #grow Design preserving Set Inverse = cancellation ... #- [ ] #grow [ ] 29
  30. 30. Reuse Operator: Cancellation Collection Typically performed by an ... #add: [ ] application developer to #remove:ifAbsent: [ ] remove behaviour cancellation #remove:ifAbsent: Removes methods from the interface of a class SequenceableCollection ... Design breaching #add: [ ] Inverse = extension cancellation #add: ArrayedCollection ... 30
  31. 31. Reuse Operator: Refinement Adds elements to the Object specialisation clause of a method #postCopy [ ] Used to e.g. : refinement #postCopy [super, –– reduce redundancy + #breakDependents] –– specialise the behaviour of Model an existing method with an #postCopy existing behaviour [super, #breakDependents] Design preserving Inverse = coarsening 31
  32. 32. Reuse Operator: Coarsening Removes elements from Collection the specialisation clause of a method #size [#do:] Used to e.g.: coarsening #size [- #do:] –– optimize performance Design breaching Set Inverse = refinement #size [ ] 32
  33. 33. Reuse Operators Make a distinction between different kinds of inheritance State how a class is derived from its superclass Are orthogonal basic operators Usually, one subclassing step is a combination of several reuse operators 33
  34. 34. Frequently Used Combinations of Reuse Operators Extension & refinement Coarsening & cancellation Concretisation & refinement Concretisation & extension & refinement Coarsening & refinement = redefinition Coarsening & extension & refinement = factorization 34
  35. 35. Multi-Class Reuse Contracts (in short) Co-operating classes are put in one reuse contract; these classes are called ““participants”” Interfaces of classes as in reuse contracts for inheritance Specialisation clauses are extended with names of methods invoked on other classes Reuse operators identify what changes are made to a whole contract 35
  36. 36. Reuse Contract Notation Interface opening specialisation clauses participants #openInterface: UIBuilder ApplicationModel [#source:, #add:, #source: #openWithExtent:] #add: #openInterface: builder #openWithExtent: self #openInterface: [#model:, #displayPendingInvalidation] #openInterface: [#preBuildWith:, ApplicationWindow #hookupWindow:spec:builder:, #model: #postBuildWith:, #displayPendingInvalidation #postOpenWith:] 36
  37. 37. Overview Problems with reuse Problems with evolution What are reuse contracts? Reuse contracts at work Examining class hierarchies based on reuse contracts Reuse contract research Exercises: introduction to the browser 37
  38. 38. Reuse Contracts at Work The formal nature of reuse contracts enables their use in a development environment –– code generation from reuse contracts –– impact analysis when a framework changes (assessing evolution conflicts) –– effort estimation for framework customisation –– extraction from source code 38
  39. 39. Estimating Reuse Framework Framework Set #add: Set #add: [ ] #addAll: #addAll: [#add:] ? What to override? CountingSet CountingSet #add: [super, #incCount] #incCount [ ] Application Application 39
  40. 40. Evolution Framework Framework Set #add: [ ] Set #add: [ ] #addAll: [#add:] Evolution #addAll: [#add:] CountingSet CountingSet #add: [super, #incCount] #add: [super, #incCount] #incCount [ ] #incCount [ ] Not all additions Application Application are counted anymore 40
  41. 41. Documenting Reuse Framework Framework Set #add: [ ] #addAll: [#add:] Set #add: [ ] #addAll: [#add:] extension #incCount refinement #add: [super,+#incCount] CountingSet CountingSet #add: [super, #incCount] #incCount [ ] #add: [super, #incCount] #incCount [ ] Application Application 41
  42. 42. Documenting Evolution Framework Framework Set #add: [ ] Set #add: [ ] #addAll: [#add:] Evolution #addAll: [#add:] Framework Framework Set #add: [ ] coarsening Set #add: [ ] #addAll: [#add:] #addAll: [ ] #addAll: [-#add:] 42
  43. 43. Estimating Impact of Changes Framework Framework Set #add: [ ] Set #add: [ ] #addAll: [#add:] coarsening #addAll: [ ] #addAll: [-#add:] extension extension #incCount #incCount refinement refinement #add: [super,+#incCount] #add: [super,+#incCount] CountingSet CountingSet #add: [super, #incCount] #add: [super, #incCount] #incCount [ ] #incCount [ ] #addAll: needs to be Application overridden too Application 43
  44. 44. Overview Problems with reuse Problems with evolution What are reuse contracts? Reuse contracts at work Examining class hierarchies based on reuse contracts Reuse contract research Exercises: introduction to the browser 44
  45. 45. Extraction of Reuse Contracts Reuse contracts for inheritance can be extracted from Smalltalk code reuse Each subclassing step operators is decomposed in a class combination of maximum 6 different reuse operators 45
  46. 46. Too Much Extracted Information The extractor does not know which methods are important Interaction with a developer is required to strip implementation details 46
  47. 47. Inspecting Extracted Extensions 47
  48. 48. Inspecting Extracted Concretisations 48
  49. 49. Inspecting Extracted Refinements 49
  50. 50. Inspecting Extracted Coarsenings 50
  51. 51. Inspecting Extracted Cancellations 51
  52. 52. Spotting Bad Designs in a Class Hierarchy Look for design breaching reuse operators –– they indicate methods that do not respect the design as laid down by a superclass Examine what happens with the affected methods in reuse operators that are applied later on 52
  53. 53. Spotting Bad Designs: Example The Stream hierarchy is awkward wrt. the #next method. 1 2 3 53
  54. 54. Impact of Bad Coding Style Bad coding style is troublesome for the extractor –– e.g. only super send, bad super send, ... This has driven us to make qualitative assessment of source code possible An analysis tool is integrated in our browser 54
  55. 55. Overview Problems with reuse Problems with evolution What are reuse contracts? Reuse contracts at work Examining class hierarchies based on reuse contracts Reuse contract research Exercises: introduction to the browser 55
  56. 56. Reuse Contract Research Reuse contracts have been applied to –– classes (inheritance) –– sets of interacting classes/components –– state diagrams Under investigation: –– can reuse contracts describe design patterns? –– generic reuse contracts –– extraction of multi-class reuse contracts –– software architectures and componentware –– reuse contracts in a development environment –– more documentation than interfaces and invocations 56
  57. 57. Design Pattern Example Client Component graphics #operation concretisation refinement operation [operation] extension Composite concretisation Leaf #operation #add: #operation #remove: #getChild: CompositeA #operation #add: #remove: #getChild: 57
  58. 58. Summary: Theory Reuse contracts formally document what a reuser can assume about a ““reusable component”” Reuse operators formally document how a reusable component is actually reused Formal rules for change propagation enable automatic detection of evolution conflicts 58
  59. 59. Summary: Practice Reuse contracts for inheritance can be extracted –– examination of existing source code –– understanding the design –– human input is needed to filter out implementation details –– bad coding style may give rise to extraction problems 59
  60. 60. Overview Problems with reuse Problems with evolution What are reuse contracts? Reuse contracts at work Examining class hierarchies based on reuse contracts Reuse contract research Exercises: introduction to the browser 60
  61. 61. The Browser for the Exercises Home-made fully-functional browser Composed of reusable ““browser part components”” built with ApplFLab Can easily be See ESUG’’96 Summer School ““ApplFLab: Custom-made user extended with other interface components in VisualWorks”” ““class view/editor components”” 61
  62. 62. Enhanced Browser —— General Different views Different views/tools Method selector Different views Class selector Different method editors Method editor 62
  63. 63. Browser —— Reuse Contracts 63
  64. 64. Browser —— Code Analysis 64
  65. 65. Browser —— Clusters 65
  66. 66. Browser —— Metrics 66
  67. 67. Exercises Use the enhanced browser to investigate Smalltalk code –– Examine class hierarchies based on extracted reuse contracts –– Analyse the code to find methods that hinder reuse –– Explore the different tools File in your own Smalltalk classes/ frameworks 67
  68. 68. Up-to-date Information http://progwww.vub.ac.be/prog/pools/rcs/ 68
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×