Refactoring to

Size: px

Start display at page:

Download "Refactoring to"

Basil Clyde Crawford
5 years ago
Views:

1 Refactoring to

6 Functional programming combines the flexibility and power of abstract mathematics with the intuitive clarity of abstract mathematics.

7 Functional programming typically avoids using mutable state.

8 Asking a question should not change the answer. Bertrand Meyer

9 Asking a question should not change the answer, and nor should asking it twice!

11 Referential transparency is a very desirable property: it implies that functions consistently yield the same results given the same input, irrespective of where and when they are invoked. That is, function evaluation depends less ideally, not at all on the side effects of mutable state. Edward Garson "Apply Functional Programming Principles"

12 your code should be reasonable

13 you should be able to reason about code

14 A large fraction of the flaws in software development are due to programmers not fully understanding all the possible states their code may execute in. John Carmack

17 A large fraction of the flaws in software development are due to programmers not fully understanding all the possible states their code may execute in. In a multithreaded environment, the lack of understanding and the resulting problems are greatly amplified, almost to the point of panic if you are paying attention. John Carmack

18 Threads

19 Locks

20 Unshared mutable data needs no synchronisation Unshared Mutable Shared mutable data needs synchronisation Shared Unshared immutable data needs no synchronisation Immutable Shared immutable data needs no synchronisation

21 Mutable The Synchronisation Quadrant Unshared mutable data needs no synchronisation Unshared Shared mutable data needs synchronisation Shared Unshared immutable data needs no synchronisation Immutable Shared immutable data needs no synchronisation

23 Architecture represents the significant design decisions that shape a system, where significant is measured by cost of change. Grady Booch

24 As an evolving program is continually changed, its complexity, reflecting deteriorating structure, increases unless work is done to maintain or reduce it. Meir M Lehman

26 µονόλιθος

Refactoring (noun): a change made to the internal structure of software to make it easier to understand and cheaper to modify without changing its

28 Refactoring (noun): a change made to the internal structure of software to make it easier to understand and cheaper to modify without changing its observable behavior. Refactor (verb): to restructure software by applying a series of refactorings without changing the observable behavior of the software.

30 Functional Operational Developmental

31 Functional Operational Developmental

32 Many programming languages support programming in both functional and imperative style but the syntax and facilities of a language are typically optimised for only one of these styles, and social factors like coding conventions and libraries often force the programmer towards one of the styles.

34 public class Clock public static Clock Instance =>... public TimeOfDay Now =>......

35 public void Example() var now = Clock.Instance.Now;...

36 public void Example(Clock clock) var now = clock.now;...

37 public interface Clock TimeOfDay Now =>... public class ClockImpl : Clock public static Clock Instance =>......

38 public interface IClock TimeOfDay Now =>... public class Clock : IClock public static IClock Instance =>......

39 public interface IClock TimeOfDay Now =>... public class LocalClock : IClock public static IClock Instance =>......

40 public interface Clock TimeOfDay Now =>... public class LocalClock : Clock public static Clock Instance =>......

41 public void Example(Func<TimeOfDay> timeofday) var now = timeofday();...

42 public void Example(TimeOfDay now)...

43 If you have a procedure with ten parameters, you probably missed some. Alan Perlis

44 Reduce Scope of Variable Declare variables at the point of their initialisation. Variables used in a single block should be declared in it. Fields used in a single method invocation should be variables local to that method. Replace Second Assignment to a Variable with New Variable Instead of accumulating changes in a variable, use different variables to represent changes. Pass Globals as Parameters Make dependencies explicit by passing them as arguments rather than relying on global access. Replace Long Parameter List with Parameter Object Group cohesive parameters together as objects. These are often value types, and may also reveal new domain types. Replace Resource Passing with Direct Value Instead of passing suppliers, factories, etc. to methods, pass the result of their use directly.

47 Immutable Value Define a value object type whose instances are immutable. The internal state of a value object is set at construction and no subsequent modifications are allowed.

48 public class TimeOfDay... public int Hour get... set... public int Minute get... set... public void NextHour()... public void NextMinute()...

49 public class TimeOfDay private int minutes; public const int minutesinhour = 60; public const int hoursinday = 24; public const int minutesinday = hoursinday * minutesinhour; private static int Wrap(int minutes) return minutes % minutesinday; public int Hour get return minutes / minutesinhour; set if (value < 0 value >= hoursinday) throw new ArgumentException(); minutes = Wrap(value * minutesinhour + Minute); public int Minute get return minutes % minutesinhour; set if (value < 0 value >= minutesinhour) throw new ArgumentException(); minutes = Wrap(Hour * minutesinhour + value); public void NextHour() minutes = Wrap(minutes + minutesinhour); public void NextMinute() minutes = Wrap(minutes + 1);

50 public class TimeOfDay... public int Hour get... set... public int Minute get... set... public void NextHour()... public void NextMinute()...

51 public class TimeOfDay... public int Hour get... public int Minute get... public void NextHour()... public void NextMinute()...

52 public class TimeOfDay... public int Hour =>... public int Minute =>... public void NextHour()... public void NextMinute()...

53 public class TimeOfDay... public int Hour =>... public int Minute =>... public TimeOfDay WithHour(int newhour)... public TimeOfDay WithMinute(int newminute)... public void NextHour()... public void NextMinute()...

54 public class TimeOfDay... public int Hour =>... public int Minute =>... public TimeOfDay WithHour(int newhour)... public TimeOfDay WithMinute(int newminute)... public TimeOfDay NextHour()... public TimeOfDay NextMinute()...

55 public class TimeOfDay... public TimeOfDay(int hour, int minute)... public int Hour =>... public int Minute =>... public TimeOfDay WithHour(int newhour)... public TimeOfDay WithMinute(int newminute)... public TimeOfDay NextHour()... public TimeOfDay NextMinute()...

56 public class TimeOfDay... public TimeOfDay(int hour, int minute)... public int Hour =>... public int Minute =>... public TimeOfDay WithHour(int newhour)... public TimeOfDay WithMinute(int newminute)... public TimeOfDay NextHour()... public TimeOfDay NextMinute()... public class Builder...

public class TimeOfDay private readonly int minutes; public const int minutesinhour = 60; public const int hoursinday = 24; public const int minutesinday = hoursinday * minutesinhour; private

57 public class TimeOfDay private readonly int minutes; public const int minutesinhour = 60; public const int hoursinday = 24; public const int minutesinday = hoursinday * minutesinhour; private TimeOfDay(int minutes) this.minutes = minutes % minutesinday; public TimeOfDay(int hour, int minute) if (hour < 0 hour >= hoursinday minute < 0 minute >= minutesinhour) throw new ArgumentException(); minutes = hour * minutesinhour + minute; public int Hour => minutes / minutesinhour; public int Minute => minutes % minutesinhour; public TimeOfDay WithHour(int newhour) => new TimeOfDay(newHour, Minute); public TimeOfDay WithMinute(int newminute) => new TimeOfDay(Hour, newminute); public TimeOfDay NextHour() => new TimeOfDay(minutes + minutesinhour); public TimeOfDay NextMinute() => new TimeOfDay(minutes + 1);...

58 Remove Modifiers Remove unused modifiers (e.g., setters) and consider Replace Modifiers with Constructors, Extract Modifiers to Builder and Make Void Methods Fluent. Replace Modifications with Constructors Many sequences of modification can often be replaced with a broader set of meaningful constructors. Move Modifiers to Builder Define a mutable companion class to handle sequences of modification (cf. String and StringBuilder). Replace Side Effect with New Object Return a new object instead of changing an existing one. Often Make Void Methods Fluent is a useful stepping stone. Make Void Methods Fluent Have a method return an existing or new object the caller can chain from.

60 A book is simply the container of an idea like a bottle; what is inside the book is what matters. Angela Carter

61 public class Stack<T> private List<T> items = new ArrayList<>(); public int depth() return items.size(); public T top() if (depth() == 0) throw new IllegalStateException(); return items.get(depth() - 1); public void pop() if (depth() == 0) throw new IllegalStateException(); items.remove(depth() - 1); public void push(t newtop) items.add(newtop);

62 In computing, a persistent data structure is a data structure that always preserves the previous version of itself when it is modified. Such data structures are effectively immutable, as their operations do not (visibly) update the structure in-place, but instead always yield a new updated structure. (A persistent data structure is not a data structure committed to persistent storage, such as a disk; this is a different and unrelated sense of the word "persistent.")

70 public interface Stack<T> int depth(); T top(); Stack<T> pop(); Stack<T> push(t newtop);...

71 public interface Stack<T>... class Empty<T> implements Stack<T> public int depth() return 0; public T top() throw new IllegalStateException(); public Stack<T> pop() throw new IllegalStateException(); public Stack<T> push(t newtop) return new NonEmpty(newTop, this);...

72 public interface Stack<T>... default Stack<T> push(t newtop) return new NonEmpty<>(newTop, this); class Empty<T> implements Stack<T> public int depth() return 0; public T top() throw new IllegalStateException(); public Stack<T> pop() throw new IllegalStateException();...

73 public interface Stack<T>... class NonEmpty<T> implements Stack<T> private T top; private Stack<T> tail; public NonEmpty(T newtop, Stack<T> previous) top = newtop; tail = previous; public int depth() return 1 + tail.depth(); public T top() return top; public Stack<T> pop() return tail;

74 The goal of the Anti-IF Campaign is to raise awareness of the effective use of software design principles and practices, by first of all removing bad, dangerous IFs.

75 Stack<String> stack = new Stack<>(); stack.push("sdd"); stack.push("2018");

76 Stack<String> stack = new Stack.Empty<>(); stack = stack.push("sdd").push("2018");

77 public interface Stack<T> int depth(); T top(); Stack<T> pop(); Stack<T> push(t newtop);... Either T must be a type whose instances are immutable, or only instances that will remain immutable may be pushed.

78 Replace Mutable Collection with Persistent Collection Use, create or repurpose a mutable collection with or as a persistent collection, i.e., one that is effectively immutable to referential observers, allowing sharing without cost of copying. Replace Mutable Collection Values with Immutable Values A collection that is itself unchanging or persistent cannot preserve its immutability guarantee if its collected references are mutable, so use immutable values for collection elements. Replace State-based Object Behaviour with Polymorphism Replace flags that are unchanging for a given collection, but cause branching to different behaviours, with polymorphism, i.e., use instances of types to represent the behavioural differences.

81 try Integer.parseInt(time.substring(0, 2)); catch (Exception x) return false; if (Integer.parseInt(time.substring(0, 2)) > 12) return false;... if (!time.substring(9, 11).equals("AM") &!time.substring(9, 11).equals("PM")) return false; Burk Hufnagel "Put the Mouse Down and Step Away from the Keyboard"

82 public static boolean validatetime(string time) return time.matches("(0[1-9] 1[0-2]):[0-5][0-9]:[0-5][0-9] ([AP]M)"); Burk Hufnagel "Put the Mouse Down and Step Away from the Keyboard"

86 intension, n. (Logic) The set of characteristics or properties by which the referent or referents of a given expression is determined. The sense of an expression that determines its reference in every possible world, as opposed to its actual reference. For example, the intension of prime number may be having non-trivial integral factors, whereas its extension would be the set 2, 3, 5, 7,... E J Borowski and J M Borwein Dictionary of Mathematics

87 x 2 x, x 1 x 100 select from where

88 A list comprehension is a syntactic construct available in some programming languages for creating a list based on existing lists. It follows the form of the mathematical setbuilder notation (set comprehension) as distinct from the use of map and filter functions.

91 // Get the unique surnames in uppercase of the // first 15 book authors that are 50 years old // or older? library.stream().map(book -> book.getauthor()).filter(author -> author.getage() >= 50).limit(15).map(Author::getSurname).map(String::toUpperCase).distinct().collect(toList())

92 // Get the first 15 unique surnames in // uppercase of the book authors that are 50 // years old or older. library.stream().map(book -> book.getauthor()).filter(author -> author.getage() >= 50).map(Author::getSurname).map(String::toUpperCase).distinct().limit(15).collect(toList())

93 // Get the unique surnames in uppercase of the // first 15 book authors that are 50 years old // or older. library.stream().map(book -> book.getauthor()).filter(author -> author.getage() >= 50).distinct().limit(15).map(Author::getSurname).map(String::toUpperCase).distinct().collect(toList())

94 // Get the unique surnames in uppercase of the // first 15 book authors that are 50 years old // or older. library.stream().map(book -> book.getauthor()).distinct().filter(author -> author.getage() >= 50).limit(15).map(Author::getSurname).map(String::toUpperCase).distinct().collect(toList())

95 Simple filters that can be arbitrarily chained are more easily re-used, and more robust, than almost any other kind of code. Brandon Rhodes

96 // Get the unique surnames in uppercase of the // first 15 book authors that are 50 years old // or older? List<Author> authors = new ArrayList<Author>(); for (Book book : library) Author author = book.getauthor(); if (author.getage() >= 50) authors.add(author); if (authors.size() == 15) break;

97 // Get the unique surnames in uppercase of the // first 15 book authors that are 50 years old // or older? List<Author> authors = new ArrayList<Author>(); for (Book book : library) Author author = book.getauthor(); if (author.getage() >= 50) authors.add(author); if (authors.size() == 15) break; List<String> result = new ArrayList<String>(); for(author author : authors) String name = author.getsurname().touppercase(); if (!result.contains(name)) result.add(name);

98 // Get the first 15 unique surnames in // uppercase of the book authors that are 50 // years old or older. List<String> result = new ArrayList<String>(); for (Book book : library) Author author = book.getauthor(); if (author.getage() >= 50) String name = author.getsurname().touppercase(); if (!result.contains(name)) result.add(name); if (result.size() == 15) break;

99 // Get the unique surnames in uppercase of the // first 15 book authors that are 50 years old // or older. List<Author> authors = new ArrayList<Author>(); for (Book book : library) Author author = book.getauthor(); if (author.getage() >= 50 &&!authors.contains(author)) authors.add(author); if (authors.size() == 15) break; List<String> result = new ArrayList<String>(); for(author author : authors) String name = author.getsurname().touppercase(); if (!result.contains(name)) result.add(name);

100 Try to leave out the part that readers tend to skip. Elmore Leonard

101 // Get the unique surnames in uppercase of the // first 15 book authors that are 50 years old // or older, in Java. library.stream().map(book -> book.getauthor()).distinct().filter(author -> author.getage() >= 50).limit(15).map(Author::getSurname).map(String::toUpperCase).distinct().collect(toList())

102 // Get the unique surnames in uppercase of the // first 15 book authors that are 50 years old // or older, in C#. library.select(book => book.author).distinct().where(author => author.age >= 50).Take(15).Select(author => author.surname).select(name => name.toupper()).distinct().tolist()

103 // Get the unique surnames in uppercase of the // first 15 book authors that are 50 years old // or older, in C#. library.select(book => book.author).distinct().where(author => author.age >= 50).Take(15).Select(author => author.surname.toupper()).distinct().tolist()

104 Extract Iteration Repetition is repetitive, so factor out common loops into appropriately named and parameterised methods. Extract Control Flow as Higher-Order Functions Much control flow has stable structure but variable conditions or actions, so use pluggable behaviour. Replace Control Flow with Data Structure Many data structures embody control intelligence, e.g., sorted collections and regular expressions, so replace long-hand logic and control with more intelligent data structures. Replace Control Flow with Data Flow Use pipelines, polymorphism and higher-order methods to replace control flow with data flow. Replace Loop with Stream Filtering Use collection pipelines to replace explicit looping and control flow with data flow.

105 When it is not necessary to change, it is necessary not to change. Lucius Cary

Procedural Programming. It's Back? It Never Went

Procedural Programming. It's Back? It Never Went Procedural Programming It's Back? It Never Went Away @KevlinHenney procedural? µονόλιθος µservices µservices This is the Unix philosophy: Write programs that do one thing and do it well. Write programs