Syntactic symbol manipulation may be the universal way of deriving new knowledge in science and engineering, but the technique is still rarely used in the act of writing software. We will explore this alternate way of reasoning about code, while demonstrating the power of formal refactoring and its potential for automation.

1. Let the symbols do the work

2. Computing's core challenge is how not to make a mess of it

3. Move fast and break things

6. Think like a computer

8. func inlineCount(fetchedCount: Int, totalCount: Int) -> Int {
if (fetchedCount == totalCount) {
return fetchedCount
}
let inlineCount = fetchedCount - 1
let overflowCount = totalCount - inlineCount
if overflowCount < minimumOverflowCount {
return totalCount - minimumOverflowCount
} else {
return inlineCount
}
}

9. func inlineCount(fetchedCount: Int, totalCount: Int) -> Int {
if (fetchedCount == totalCount) {
return fetchedCount
}
let inlineCount = fetchedCount - 1
if totalCount - inlineCount < minimumOverflowCount {
return totalCount - minimumOverflowCount
} else {
return inlineCount
}
}

10. func inlineCount(fetchedCount: Int, totalCount: Int) -> Int {
if (fetchedCount == totalCount) {
return fetchedCount
}
let inlineCount = fetchedCount - 1
if totalCount - minimumOverflowCount < inlineCount {
return totalCount - minimumOverflowCount
} else {
return inlineCount
}
}

11. func inlineCount(fetchedCount: Int, totalCount: Int) -> Int {
if (fetchedCount == totalCount) {
return fetchedCount
}
let inlineCount = fetchedCount - 1
return min(inlineCount, totalCount - minimumOverflowCount)
}

12. func inlineCount(fetchedCount: Int, totalCount: Int) -> Int {
if (fetchedCount == totalCount) {
return fetchedCount
} else {
return min(fetchedCount - 1, totalCount - minimumOverflowCount)
}
}

14. func affectedRows(tappedIndexPath: NSIndexPath?) -> Set<NSIndexPath> {
if let selectedIndexPath = selectedIndexPath {
if let tappedIndexPath = tappedIndexPath {
if tappedIndexPath == selectedIndexPath {
return [selectedIndexPath]
} else {
return [selectedIndexPath, tappedIndexPath]
}
} else {
return [selectedIndexPath]
}
} else {
if let tappedIndexPath = tappedIndexPath {
return [tappedIndexPath]
} else {
return []
}
}
}

15. func affectedRows(tappedIndexPath: NSIndexPath?) -> Set<NSIndexPath> {
var rows = Set<NSIndexPath>()
if let selectedIndexPath = selectedIndexPath {
if let tappedIndexPath = tappedIndexPath {
if tappedIndexPath == selectedIndexPath {
rows.insert(selectedIndexPath)
} else {
rows.insert(selectedIndexPath)
rows.insert(tappedIndexPath)
}
} else {
rows.insert(selectedIndexPath)
}
} else {
if let tappedIndexPath = tappedIndexPath {
rows.insert(tappedIndexPath)
}
}
return rows
}

16. func affectedRows(tappedIndexPath: NSIndexPath?) -> Set<NSIndexPath> {
var rows = Set<NSIndexPath>()
if let selectedIndexPath = selectedIndexPath {
if let tappedIndexPath = tappedIndexPath {
if tappedIndexPath == selectedIndexPath {
rows.insert(selectedIndexPath)
rows.insert(tappedIndexPath)
} else {
rows.insert(selectedIndexPath)
rows.insert(tappedIndexPath)
}
} else {
rows.insert(selectedIndexPath)
}
} else {
if let tappedIndexPath = tappedIndexPath {
rows.insert(tappedIndexPath)
}
}
return rows
}

17. func affectedRows(tappedIndexPath: NSIndexPath?) -> Set<NSIndexPath> {
var rows = Set<NSIndexPath>()
if let selectedIndexPath = selectedIndexPath {
if let tappedIndexPath = tappedIndexPath {
rows.insert(selectedIndexPath)
rows.insert(tappedIndexPath)
} else {
rows.insert(selectedIndexPath)
}
} else {
if let tappedIndexPath = tappedIndexPath {
rows.insert(tappedIndexPath)
}
}
return rows
}

18. func affectedRows(tappedIndexPath: NSIndexPath?) -> Set<NSIndexPath> {
var rows = Set<NSIndexPath>()
if let selectedIndexPath = selectedIndexPath {
rows.insert(selectedIndexPath)
if let tappedIndexPath = tappedIndexPath {
rows.insert(tappedIndexPath)
}
} else {
if let tappedIndexPath = tappedIndexPath {
rows.insert(tappedIndexPath)
}
}
return rows
}

19. func affectedRows(tappedIndexPath: NSIndexPath?) -> Set<NSIndexPath> {
var rows = Set<NSIndexPath>()
if let selectedIndexPath = selectedIndexPath {
rows.insert(selectedIndexPath)
}
if let tappedIndexPath = tappedIndexPath {
rows.insert(tappedIndexPath)
}
return rows
}

20. if condition {
doSomething()
doSomethingElse()
} else {
doSomething()
}
➡
doSomething()
if condition {
doSomethingElse()
}

21. Add Parameter - Change Bidirectional Association to Unidirectional - Change Reference to Value - Change Unidirectional Association to Bidirectional
- Change Value to Reference - Collapse Hierarchy - Consolidate Conditional Expression - Consolidate Duplicate Conditional Fragments - Decompose
Conditional - Duplicate Observed Data - Dynamic Method Definition - Eagerly Initialized Attribute - Encapsulate Collection - Encapsulate Downcast -
Encapsulate Field - Extract Class - Extract Interface - Extract Method - Extract Module - Extract Subclass - Extract Superclass - Extract Surrounding
Method - Extract Variable - Form Template Method - Hide Delegate - Hide Method - Inline Temp - Inline Class - Inline Method - Inline Module -
Introduce Assertion - Introduce Class Annotation - Introduce Expression Builder - Introduce Foreign Method - Introduce Gateway - Introduce Local
Extension - Introduce Named Parameter - Introduce Null Object - Introduce Parameter Object - Isolate Dynamic Receptor - Lazily Initialized Attribute
- Move Eval from Runtime to Parse Time - Move Field - Move Method - Parameterize Method - Preserve Whole Object - Pull Up Constructor Body - Pull
Up Field - Pull Up Method - Push Down Field - Push Down Method - Recompose Conditional - Remove Assignments to Parameters - Remove Control
Flag - Remove Middle Man - Remove Named Parameter - Remove Parameter - Remove Setting Method - Remove Unused Default Parameter - Rename
Method - Replace Abstract Superclass with Module - Replace Array with Object - Replace Conditional with Polymorphism - Replace Constructor with
Factory Method - Replace Data Value with Object - Replace Delegation With Hierarchy - Replace Delegation with Inheritance - Replace Dynamic
Receptor with Dynamic Method Definition - Replace Error Code with Exception - Replace Exception with Test - Replace Hash with Object - Replace
Inheritance with Delegation - Replace Loop with Collection Closure Method - Replace Magic Number with Symbolic Constant - Replace Method with
Method Object - Replace Nested Conditional with Guard Clause - Replace Parameter with Explicit Methods - Replace Parameter with Method -
Replace Record with Data Class - Replace Subclass with Fields - Replace Temp with Chain - Replace Temp with Query - Replace Type Code with Class
- Replace Type Code with Module Extension - Replace Type Code With Polymorphism - Replace Type Code with State/Strategy - Replace Type Code
with Subclasses - Self Encapsulate Field - Separate Query from Modifier - Split Temporary Variable - Substitute Algorithm

22. Sure why not?

23. A leap of faith

24. The fear of introducing the wrong abstraction

25. The code is the truth

26. Let the computer do the work?

27. The Refactoring Browser

30. virtual bool VisitDeclStmt(DeclStmt *st) {
if (st->isSingleDecl()) {
if (VarDecl *varDecl = dyn_cast<VarDecl>(st->getSingleDecl())) {
if (varDecl->getName() == variableName) {
value = rewriter.getRewrittenText(varDecl->getInit()->getSourceRange());
rewriter.RemoveText(st->getSourceRange());
}
}
}
return true;
}
virtual bool VisitExpr(Expr *expr) {
if (DeclRefExpr *refExpr = dyn_cast<DeclRefExpr>(expr)) {
if (refExpr->getNameInfo().getName().getAsString() == variableName) {
rewriter.ReplaceText(refExpr->getSourceRange(), value);
}
}
return true;
}

31. What's next?

32. What else?

33. Questions