Exploring Extreme Programming
How should we handle error conditions? We’ll look at the try-catch exception mechanism that’s similar across many languages, and a few patterns and pitfalls for working with it. Old-School One way of handling errors is for a method to have Continue reading Spooky Action at a Distance: Exceptions
Here are the the articles and videos I made last year. Key topics: user stories, refactoring, TDD, functional languages, and design. I’ve grouped them into these areas: My favorites: Want More?Have you found these articles useful or want more? * Continue reading 2021 Articles in Review
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
I recall a game design challenge where your only input is a pushbutton. What if your only input is a single textfield? Let’s look at what search engines have done under this limitation. That can give us ideas for intensifying Continue reading Intensifying Stories with Limited Input
Loop unrolling is a performance optimization where you repeat the inside of a loop to reduce the looping overhead. It’s also a way to get rid of loops, and we’ll look at an example from a test. While ⇒ If-While Continue reading Loop Unrolling: While ⇒ If-While
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
Some teams doing incremental development can release whenever any new capability is ready. But what can you do when you need to control when capabilities are available? Consider the Backroom/Frontroom approach. The term “Backroom/FrontRoom” comes from the Gilb’s book Competitive Continue reading Backroom/Frontroom to Smooth Releases
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