Designing and Maintaining Software (DAMS) - GitHub
Recommend Documents
Habitable Software. Leaner. Less Complex. Loosely Coupled. More Cohesive. Avoids Duplication. Clearer. More Extensible ?
When we are testing the way that a unit behaves when a condition is met, use a stub to setup the condition. Solution: us
Size != Complexity. âImagine a small (50 line) program comprising. 25 consecutive "IF THEN" constructs. Such a program
Page 1. Getting Lean. Designing and Maintaining Software (DAMS). Louis Rose. Page 2. Lean software⦠Has no extra parts
Getting Cohesion. Designing and Maintaining Software (DAMS). Louis Rose. Page 2. Single Responsibility. Principle. A cla
Open-source. Influenced by Perl, Smalltalk, Eiffel, Ada and Lisp. Dynamic. Purely object-oriented. Some elements of func
ASTs are tree data structures that can be analysed for meaning (following JLJ in SYAC 2014/15) ... More Cohesive. Avoids
Ruby Testing Frameworks. 3 popular options are: RSpec, Minitest and Test::Unit. We'll use RSpec, as it has the most comp
Fixes issue #42. Users were being redirected to the home page after login, which is less useful than redirecting to the
âWe want the reading of code to be easy, even it makes the writing harder. (Of course, there's no way to write code wi
Getting loose coupling. Designing and Maintaining Software (DAMS). Louis Rose ... should not depend on low-level modules
Plug-ins. Designing and Maintaining Software (DAMS). Louis Rose. Page 2. Problem. Page 3. Current Architecture. Shareabl
Tools: Vagrant. Designing and Maintaining Software (DAMS). Louis Rose. Page 2. Bugs that appear in production and that c
Observers. Designing and Maintaining Software (DAMS). Louis Rose. Page 2. Page 3. Delivery people need to know when pizz
Reducing duplication. Designing and Maintaining Software (DAMS). Louis Rose. Page 2. Tactics. Accentuate similarities to
%w.rack tilt date INT TERM..map{|l|trap(l){$r.stop}rescue require l};. $u=Date;$z=($u.new.year + 145).abs;puts "== Almos
What is it? Several pieces of data are often used together. Why is it problematic? Behaviour that operates on the clump
R&D: sketch habitable solutions on paper, using UML. 4. Evaluate solutions and implement the best, using TDD. Probab
Clear Names. Designing and Maintaining Software (DAMS). Louis Rose. Page 2. Naming is hard. âThere are only two hard t
Why not duplicate? Designing and Maintaining Software (DAMS). Louis Rose. Page 2. Habitable Software. Leaner. Less Compl
Clear Documentation. Designing and Maintaining Software (DAMS). Louis Rose. Page 2. Bad documentation. Misleading or con
âWe have tried to demonstrate that it is almost always incorrect to begin the decomposition of a system into modules o
Coupling Between Objects. Counts the number of other classes to which a class is coupled (other than via inheritance). C
providers are examples of issues that may need attention in online settings. .... World Congress in Computer Science, Computer Engineering, & Applied Com- ...... The work resulted among many contributions in a framework and notation for.
Designing and Maintaining Software (DAMS) - GitHub
Automatically detect similar fragments of code. class StuffedCrust def title. "Stuffed Crust " +. @toppings.title +. " P
Clone detection
Designing and Maintaining Software (DAMS) Louis Rose
Habitable Software Leaner
Avoids Duplication
Less Complex
Clearer
Loosely Coupled
More Extensible
More Cohesive
???
Goal Automatically detect similar fragments of code.
class StuffedCrust def title "Stuffed Crust " + @toppings.title + " Pizza" end
class DeepPan def title "Deep Pan " + @ingredients.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @ingredients.cost + 4 end end
Goal Automatically detect similar fragments of code.
class StuffedCrust def title "Stuffed Crust " + @toppings.title + " Pizza" end
class DeepPan def title "Deep Pan " + @ingredients.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @ingredients.cost + 4 end end
Beginnings Automatically detect identical fragments of text.
class StuffedCrust def title "Stuffed Crust " + @toppings.title + " Pizza" end
class DeepPan def title "Deep Pan " + @ingredients.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @ingredients.cost + 4 end end
Beginnings Automatically detect identical fragments of text.
class StuffedCrust def title @toppings.title + " Pizza" end
class DeepPan def title @toppings.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @toppings.cost + 4 end end
Beginnings Automatically detect identical fragments of text.
class StuffedCrust def title @toppings.title + " Pizza" end
class DeepPan def title @toppings.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @toppings.cost + 4 end end
Comparing Fragments Simple approach: identify lines of A appearing in B.
class StuffedCrust def title @toppings.title + " Pizza" end
class DeepPan def title @toppings.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @toppings.cost + 4 end end
Comparing Fragments Simple approach: identify lines of A appearing in B.
class StuffedCrust def title @toppings.title + " Pizza" end
class DeepPan def title @toppings.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @toppings.cost + 4 end end
Comparing Fragments Simple approach: identify lines of A appearing in B.
class StuffedCrust def title @toppings.title + " Pizza" end
class DeepPan def title @toppings.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @toppings.cost + 4 end end
Comparing Fragments Simple approach: identify lines of A appearing in B.
class StuffedCrust def title @toppings.title + " Pizza" end
class DeepPan def title @toppings.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @toppings.cost + 4 end end
Comparing Fragments Simple approach: identify lines of A appearing in B.
class StuffedCrust def title @toppings.title + " Pizza" end
class DeepPan def title @toppings.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @toppings.cost + 4 end end
Comparing Fragments Simple approach: identify lines of A appearing in B.
class StuffedCrust def title @toppings.title + " Pizza" end
class DeepPan def title @toppings.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @toppings.cost + 4 end end
Comparing Fragments Simple approach: identify lines of A appearing in B.
class StuffedCrust def title @toppings.title + " Pizza" end
class DeepPan def title @toppings.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @toppings.cost + 4 end end
Comparing Fragments Increase fragment size until no new clones appear.
class StuffedCrust def title @toppings.title + " Pizza" end
class DeepPan def title @toppings.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @toppings.cost + 4 end end
Results The simple approach indicates the following clones:
class StuffedCrust def title @toppings.title + " Pizza" end
class DeepPan def title @toppings.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @toppings.cost + 4 end end
Tweaking From now on, strip out whitespace and comments
class StuffedCrust def title @toppings.title + " Pizza" end def cost @toppings.cost + 6 end end
class DeepPan def title @toppings.title + " Pizza" end def cost @toppings.cost + 4 end end
More Tweaking Ignore fragments containing only Ruby keywords.
class StuffedCrust def title @toppings.title + " Pizza" end def cost @toppings.cost + 6 end end
class DeepPan def title @toppings.title + " Pizza" end def cost @toppings.cost + 4 end end
Recap: Goal Automatically detect similar fragments of code.
class StuffedCrust def title "Stuffed Crust " + @toppings.title + " Pizza" end
class DeepPan def title "Deep Pan " + @ingredients.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @ingredients.cost + 4 end end
Parameterisation Alter the source before clone detection
class StuffedCrust def title "Stuffed Crust " + @toppings.title + " Pizza" end
class DeepPan def title "Deep Pan " + @ingredients.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @ingredients.cost + 4 end end
Parameterisation Alter the source before clone detection
class C def title "Stuffed Crust " + @toppings.title + " Pizza" end
class C def title "Deep Pan " + @ingredients.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @ingredients.cost + 4 end end
Parameterisation Alter the source before clone detection
class C def M "Stuffed Crust " + @toppings.title + " Pizza" end
class C def M "Deep Pan " + @ingredients.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @ingredients.cost + 4 end end
Parameterisation Alter the source before clone detection
class C def M S+ @toppings.title + " Pizza" end
class C def M S+ @ingredients.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @ingredients.cost + 4 end end
Parameterisation Alter the source before clone detection
class C def M S+ @A.title + " Pizza" end
class C def M S+ @A.title + " Pizza" end
def cost @toppings.cost + 6 end end
def cost @ingredients.cost + 4 end end
Parameterisation Alter the source before clone detection
class C def M S+ @A.title + S end
class C def M S+ @A.title + S end
def M @A.cost + I end end
def M @A.cost + I end end
Clone Detection Now perform detection on parameterised source.
class C def M S+ @A.title + S end def M @A.cost + I end end
class C def M S+ @A.title + S end def M @A.cost + I end end
Baker’s Algorithm “Duplication may be introduced into a large system as modifications are made to add new features or to fix bugs. Rather than rewrite working sections of code, programmers may copy and modify sections of code. It has long been known that copying sections of code may make the code larger, more complex, and more difficult to maintain.” - Brenda S. Baker A Program for Identifying Duplicated Code Computing Science and Statistics, 24, 1992
Performance
https://en.wikipedia.org/wiki/Suffix_tree
Limitations Baker’s algorithm cannot detect syntactically distinct but semantically equivalent clones class StuffedCrust def title "Stuffed Crust " + @toppings.title + " Pizza" end def cost @toppings.cost + 6 end end
class Stonebaked def cost 6 + @toppings.cost end def title "Stonebaked #{@toppings.title} Pizza" end end
Clones are Indicators No algorithm can definitively determine whether a clone is accidental or essential duplication class StuffedCrust def title "Stuffed Crust " + @toppings.title + " Pizza" end def cost @toppings.cost + 6 end end
class Stonebaked def cost 6 + @toppings.cost end def title "Stonebaked #{@toppings.title} Pizza" end end
Clones are Indicators No algorithm can definitively determine whether a clone is accidental or essential duplication class StuffedCrust def title "Stuffed Crust " + @toppings.title + " Pizza" end def cost @toppings.cost + 6 end end
class Stonebaked def cost 6 + @toppings.cost end def title "Stonebaked #{@toppings.title} Pizza" end end
Clones are Indicators No algorithm can definitively determine whether a clone is accidental or essential duplication class StuffedCrust def title "Stuffed Crust " + @toppings.title + " Pizza" end def cost @toppings.cost + 6 end end
class Stonebaked def cost 6 + @toppings.cost end def title "Stonebaked #{@toppings.title} Pizza" end end
Summary Clones can indicate potentially duplicated code Baker’s is the most straightforward clone detection algorithm, and there are many more sophisticated No tool can distinguish accidental and essential duplication