Make It Super Simple (MISS) is the design principle John Weathington advocates for data scientists. He notes that simplicity actually requires a lot of effort.
KISS (Keep It Simple, Stupid) is a good design principle--I like the objective, but I struggle with some of the assumptions. Aside from the unnecessary and unwarranted insult that's intended to put a more exclamatory hue on the idea, the bigger issue I have with KISS is that it implies a design just emerges in its simplest form.
The implication follows that those who are non-stupid should resist the urge to spoil a nascent, simple design by overanalyzing, overengineering, and consequently overdesigning it into a more complicated form. Although this sounds reasonable, the problem is with the premise: Designs rarely emerge in their simplest forms. So, perhaps we should put less consideration into the KISS principle and more consideration into the MISS principle: Make It Super Simple.
Simple as Pi
Most designs involving data science emerge as complicated and must be simplified. Here's an example.
If I told you I have a bag that's filled with 332 marbles, 83 of which are red, and asked you the probability of randomly selecting a red marble out of the bag, the first thing you would probably consider is 83 of 332. However, if you simplify this probability, you'd arrive at a 1 in 4 chance. And if you wanted to further simplify this for communication and comparison purposes, you might say there's a 25% chance of drawing a red marble from the bag. Notice how much easier it is to talk about a 25% chance of something happening vs. an 83 out of 332 probability?
This happens with computer programming as well. Experienced programmers will tell you that simple code just doesn't fly out of their heads onto the screen. It takes time--sometimes a lot of time--to simplify code. Agile programmers call this refactoring, a practice and discipline of code simplification that was popularized by the Extreme Programming movement of the 1990s. So, why go through the extra time and energy of modifying perfectly working code, just to make it simple? Because the agile sages understood that good code involves more than just functionality. Simplicity of design allows for readability, transferability, maintainability, scalability--there's a lot of ability going on here. Simple designs are enabling.
The idea of simplicity extends beyond data science. Although the thought of incorporating data science and big data analytics into your corporate strategy may conjure up images of mad scientists furiously scribbling complicated equations on a blackboard, the reality is your success rate is in direct proportion to the simplicity of your strategy. Like math and code, simple strategies are easier to understand, communicate, and adjust when necessary. And like math and code, this strategy won't likely emerge in its simplest state--you'll need to make a focused effort to make it simple.
Simple is as simple does
If simplicity is your goal, your first order of business is to make it an explicit value in your organization. Simplicity will inexorably be challenged within your organization, and you must be prepared to defend it.
For example, your new prediction engine is working just as you imagined. You can put it into production today--on schedule--but there's one problem: The code looks like linguine. The data scientist who finally cracked the code spent the last 36 hours trying to hit your deadline. She nailed it from a functional perspective, but she's the only one who understands the code, and even she won't understand her own code in a couple of weeks. What would you do? Do you push the schedule back solely for the sake of refactoring the code? To uphold your value of simplicity, you must push the date so the team has time to get the code untangled. I know a lot of leaders who would have a hard time with this. You must stand your ground on values like this one, or they'll quickly become empty platitudes.
As a leader, one of the best ways to instill the value of simplicity is to lead by example. Once communicated as a value, practice what you preach. The overt act of devoting yourself to the simplification of your corporate strategy will communicate your level of commitment to this value.
For instance, how many metrics are you tracking on your scorecard? I remember working with Sun Microsystems on a strategic scorecard, where the executives started with hundreds of metrics. After months of deliberation, they still couldn't get it below 50. That's ridiculous. Jack Welch, former CEO of GE, recommends boiling it down to only one metric. It doesn't get simpler than that!
Although keeping things simple is a nice idea, when you're working with data science, it's more valuable to consider making things simple. Unfortunately, this is not as easy as just keeping things simple--making things simple takes a lot of energy and effort.
The MISS principle that I've suggested is more than a cute acronym--it's a design principle that you must take seriously in your data science, in your corporate strategy, and in the way you run your organization.
Take the time to revisit your commitment to simplicity. Otherwise, you may find yourself in a complicated situation.