Exploring Extreme Programming
Operating System Principles, by Per Brinch Hansen. 1973. This is a classic book on operating systems – better than many of its successors. What I love about this book is that it comes just after an era of experimentation, when Continue reading Review: Operating System Principles
Immutability is the idea that once created, data never changes. Why might we want this? Avoid aliasing bugs: Aliasing occurs when there are multiple ways to access the same piece of data, and one piece changes it in a way Continue reading Immutable Objects
Functional languages often have immutable data types – you can’t change an object once you’ve created it, though you can include it as part of other objects. Immutable objects are easier to reason about, and prevent errors where two parts Continue reading Queues from Stacks: Functional Data Types
Refactoring improves the design of code without changing its observable behavior. But what is observable behavior? We’ll look at how language semantics affect that. When you devise new refactorings, you have to take semantics into account. The Simple View is Continue reading Refactoring and Programming Language Semantics
Coupling occurs when one part of a system depends on another part. That is, if one part changes, the other must be adjusted too. Lambda expressions can reduce coupling by needing to refer to fewer things. Dependencies on Objects Consider Continue reading Lambda to Reduce Coupling
Several mainstream languages have added better support for lambda expressions (including lighter syntax) in the last few years. This can let you define new forms of control structures, and reduce duplication in a different way than say extracting a common Continue reading Lambda for Control Structures, a Refactoring
Last time (“Extracting” in References), we looked at why you’d use parameterized tests, to reduce duplication, improve clarity, and improve test quality. This time we’ll look at an example parameterized test in three languages: Java, Kotlin, and Swift. Java Example Continue reading Example Parameterized Tests: Java, Kotlin, and Swift
Duplication across tests may not be as harmful as duplication in production code, but a parameterized unit test can reduce duplication and help us create better tests. Judging Tests – The Pause Spotting duplication in tests is like spotting it Continue reading Extracting Parameterized Unit Tests
Automated refactoring tools are great, but sometimes the tool doesn’t make the best choice. We can often nudge the tool to a better choice. Why Bother? Why bother nudging? Couldn’t you do the refactoring manually just as quickly? You could Continue reading Refactoring: Forcing the Right Extract Method
In incremental development, we grow a system by adding capabilities one at a time. Our bet is that we won’t often hit a dead end, but if we do, the time we’ve already saved will let us dig our way Continue reading Disaster Strikes! A Design Dead End