Visualization Mnemonics for Software Principles
Whether it’s because you want to be able to participate in software engineering discussions without having to surreptitiously look things up on your phone, or whether it’s because you have an interview coming up with a firm that wants you to be some kind of expert in OOP or something, you probably have at least some desire to be knowledgeable about development terms. This is probably doubly true of you, since ipso facto, you read blogs about software.
Toward that end, I’m writing this post. My goal is to provide you with a series of somewhat vivid ways to remember software concepts so that you’ll have a fighting chance at remembering what they’re about sometime later. I’m going to do this by telling a series of stories. So, I’ll get right to it.
Law of Demeter
Last week I was on a driving trip and I stopped by a gas station to get myself a Mountain Dew for the sake or road alertness. I grabbed the soda from the cooler and plopped it down on the counter, prompting the clerk to say, “that’ll be $1.95.” At this point, naturally, I removed my pants and the guy started screaming at me about police and indecent exposure. Confused, I said, “look, I’m just trying to pay you — I’ll hand you my pants and you go rummaging around in my pockets until you find my wallet, which you’ll take out and go looking through for cash. If I’m due change put it back into the wallet, unless it’s a coin, and then just put it in my pocket, and give me back the pants.” He pulled a shotgun out from behind the counter and told me that in his store, people obey the Law of Demeter or else.
So what does the Law of Demeter say? Well, anecdotally, it says “give collaborators exactly what they’re asking for and don’t give them something they’ll have to go picking through to get what they want.” There’s a reason we don’t hand the clerk our pants (or even our wallet) at the store and just hand them money instead; it’s inappropriate to send them hunting for the money. The Law of Demeter encourages you to think this way about your code. Don’t return Pants and force clients of your method to get what they want by invoking Pants.Pockets.Wallet.Money — just give them a Money. And, if you’re the clerk, don’t accept someone handing you a Pants and you going to look for the money — demand the money or show them your shotgun.
Single Responsibility Principle
My girlfriend and I recently bought an investment property a couple of hours away. It’s a little house on a lake that was built in the 1950’s and, while cozy and pleasant, it doesn’t have all of the modern amenities that I might want, resulting in a series of home improvement projects to re-tile floors, build some things out and knock some things down. That kind of stuff.
One such project was installing a garbage disposal, which has two components: plumbing and electrical. The plumbing part is pretty straightforward in that you just need to remove the existing drain pipe and insert the disposal between the drain and the drainage pipe. The electrical is a little more interesting in that you need to run wiring from a switch to the disposal so that you can turn it on and off. Now, naturally, I didn’t want to go to all the hubub of creating a whole different switch, so I decided just to use one that was already there. The front patio light switch had the responsibility for turning the front patio light on and off, but I added a little to its burden, asking it also to control the garbage disposal.
That’s worked pretty well. So far the only mishap occurred when I was rinsing off some dishes and dropped a spoon in the drain while, at the same time, my girlfriend turned the front light on for visitors we were expecting. Luckily, I had only a minor scrape and a mangled spoon, and that’s a small price to pay to avoid creating a whole new light switch. And really, what’s the worst that could happen?
Well, I think you know the worst thing that could happen is that someone loses a hand due to this absurd design. When you run afoul of the Single Responsibility Principle, which could loosely be described as saying “do one thing only and do that thing well” or “have only one reason to change.” In my house, we have two reasons to change the state of the switch: turning on the disposal and turning on the light, and this creates an obvious problem. The parallel situation in code is true as well. If you have a class that needs to be changed whenever schema updates occur and whenever GUI changes occur, then you have a class that serves two masters and the possibility for changes to one thing to affect the other. Disk space is cheap and classes/namespaces/modules are renewable resources. When in doubt, create another one.
I don’t have a ton of time for TV these days, and that’s mainly because TV is so time consuming. It was a lot simpler when I just had a TV that got an analog signal over the air. But then, things went digital, so I had to take apart my TV and rewire it to handle digital signals. Next, we got cable and, of course, there I am, disassembling the TV again so that we can wire it up to get a cable signal. The worst part of that was that when I became furious with the cable provider and we switched to Dish, I was right back to work on the TV. Now, we have a Nintendo Wii, a DVD player, and a Roku, but who has the time to take the television apart and rewire it to handle each of these additional items? And if that weren’t bad enough, I tried hooking up an old school Sega Genesis last year, and my Dish stopped working.
… said no one, ever. And the reason no one has ever said this is that televisions that you purchase follow the Open/Closed Principle, which basically says that you should create components that are closed to modification, but open for extension. Televisions you purchased aren’t made to be disassembled by you, and certainly no one expects you to hack into the guts of the TV just to plug some device into it. That’s what the Coax/RCA/Component/HDMI/etc feeds are for. With the inputs and the sealed-under-warranty case, your television is open for extension, but closed for modification. You can extend its functionality by plugging anything you like into it, including things not even out yet, like an X-Box 12 or something. Follow this same concept for flexible code. When you write code, you strive to maximize flexibility by facilitating maintenance via extension and new code. If you program to interfaces or allow overriding of behavior via inheritance, life is a lot easier when it comes time to change functionality. So favor that over writing some juggernaut class that you have to go in and modify literally every sprint. That’s icky, and you’ll learn to hate that class and the design around it the same way you’d hate the television I just described.
Liskov Substitution Principle
I’m someone that usually eats a pretty unremarkable salad with dinner. You know, standard stuff: lettuce, tomatoes, crutons, scallions, carrots, and hemlock. One thing that I seem to do differently than most, however, is that I examine each individual item in the salad to see whether or not it will kill me before I put it into my mouth (a lot of other salad consumers seem to play pretty fast and loose with their lives, sheesh). I have a pretty simple algorithm for this. If the item is not hemlock, I eat it. If it is hemlock, I put it onto my plate to throw out later. I highly recommend eating your hemlock salad this way.
Or, you could bear in mind the Liskov Substitution Principle, which basically says that if you’re going to have an inheritance relationship, then derived types should be seamlessly swappable for their base type. So, if I have a salad full of Edibles, I shouldn’t have some derived type, Hemlock, that doesn’t behave the way other Edibles do. Another way to think of this is that if you have a heterogeneous collection of things in an inheritance hierarchy, you shouldn’t go through them one by one and say, “let’s see which type this is and treat it specially.” So, obey the LSP and don’t make hemlock salads for people. You’ll have cleaner code and avoid jail.
Interface Segregation Principle
Thank goodness for web page caching — it’s a life saver. Whenever I go to my favorite dictionary site, expertbeginnerdictionary.com (not a real site if you were thinking of trying it), it prompts me for a word to lookup and, when I type in the word and hit enter, it sends me the dictionary over HTTP, at which time I can search the page text with Ctrl-F to find my word. It takes such a long time for my browser to load the entire English dictionary that I’d be really up a creek without page caching. The only trouble is, whenever a word changes and the cache is invalidated, my next lookup takes forever while the browser re-downloads the dictionary. If only there were a better way…
… and there is. Don’t give me the entire dictionary when I want to look up a word. Just give me that word. If I want to know what “zebra” means, I don’t care what “aardvark” means, and my zebra lookup experience shouldn’t be affected and put at risk by changes to “aardvark.” I should only be depending on the words and definitions that I actually use, rather than the entire dictionary. Likewise, if you’re defining public interfaces in your code for clients, break them into minimum composable segments and let your clients assemble them as needed, rather than forcing the kitchen sink (or dictionary) on them. The Interface Segregation Principle says that clients of an interface shouldn’t be forced to depend on methods that they don’t use because of the excess, pointless baggage that comes along. Give clients the minimum that they need.
Dependency Inversion Principle
Have you ever been to an automobile factory? It’s amazing to watch how these things are made. They start with a car, and the car assembles its own engine, seats, steering wheel, etc. It’s pretty amazing to watch. And, for a real treat, you can watch these sub-parts assemble their own internals. The engine builds its own alternator, battery, transmission, etc — a breathtaking feat of engineering. Of course, there’s a downside to everything, and, as cool as this is, it can be frustrating that the people in the factory have no control over what kind of engine the car builds for itself. All they can do is say, “I want a car” and the car does the rest.
I bet you can picture the code base I’m describing. A long time ago, I went into detail about this piece of imagery, but I’ll summarize by saying that this is “command and control” programming where constructors of objects instantiate all of the object’s dependencies — FooService instantiates its own logger. This runs afoul of the Dependency Inversion Principle, which holds that high level modules, like Car, should not depend directly on lower level modules, like Engine, but rather that both should depend on an abstraction of the Car-Engine interaction. This allows the car and the engine to vary independently meaning that our automobile factory workers actually could have control over which engines go in which cars. And, as described in the linked post, a code base making heavy use of the Dependency Inversion Principle tends to be composable whereas a command and control style code base is not, favoring instead the “car, build thyself” approach. So to remember and understand Dependency Inversion principle ask yourself who should control what parts go in your car — the people building the car, or the car itself? Only one of those ideas is preposterous.By the way, if you liked this post and you're new here, check out this page as a good place to start for more content that you might enjoy.
You write a lot of great posts, but this one is near the top. Thank you for the fun way to think about these.
Thanks for the feedback and the kind words! I’m glad you liked it.
Great post! I really liked the comparison between DIP and automobile factory.
Thanks, glad you liked!
Ugh. It started so good and then deteriorated until finally ending in a boring old en.wikipedia.org / wiki / Car_analogy
I suppose the combination of composability and ubiquity makes car analogies an easy fallback. I suppose I could have related it to cooking or something like that.
I have to disagree. While I normally groan at the car analogy, I felt it was one of the most vivid explanations of the benefits of DI principles I’ve ever read.
When you consider a car factory in which cars assemble their own dependencies it really makes clear the absurdity of the practice in software development. I’ve understood what the principle means for a long time, reading this was the first time I really grokked why the principle is a good idea (rather than just allowing for ease of unit testing).
Glad to hear the car analogy wasn’t a total flop 🙂
The car analogy is expected, but a lot of people have never seen a car factory, or have thought about how a car might be made. The first analogy with the pants was excellent. The shock value alone will start a discussion after someone uses that story, and it has a lot of great connotations, such as the amount of effort to rummage through the pants to try and find the thing they’re looking for. They could even talk about what if they’re given different kinds of pants, or what if the wallet is stored in an unusual place.
For me, absurd imagery is a great mnemonic so that’s really what I was going for — “shock value” as you put it. I was hoping people would find these things easy to remember, at least. Entertaining is a bonus, if applicable. 🙂
I didn’t know what “Law of Demeter” means. Now, thanks to you, I know and I’ll not forget it easily 🙂
Glad to hear it — that’s *exactly* what I was going for. 🙂
You intended everyone to think of a pants-less Erik Dietrich?…
It’s like the classic advice about public speaking, but in reverse.
[…] Anyhow, poking around the net, I found this dude talking about Visualization Mnemonics for Software Principles. […]
So the next time I’m in a technical interview and I ask the candidate to describe the Law Of Demeter, I won’t bat an eyelid when they take their trousers off. Thank you so much.
The SRP analogy is a nice one too.
If that ever happens in an interview and the candidate cites my blog, I legitimately have no idea how I’d react to that. I think I’d be amused…?
Anyway, glad if you liked 🙂
Great use of fresh analogies on the SOLID design principles (even the car one was a different take than usual). Nicely done! I’ve passed this on to my coworkers as I think it drives the point home.
Thanks for the kind words and for sharing with others! I appreciate it.