In this post I want to talk about the mindset you need to have when you are designing software and then building it. Abstracting the details of the software you are building to a place where it is an idea, not a specific case. For example, say you are building a piece of software to capture corporate spending. Or sales in all of your branches. The data is probably not available to you as a designer, only the concepts, but you still need to create software for it.
Or maybe you are working on something like a weapon system testing system. No way are you going to get data on the weapon systems to actually test or present to your clients until some form of user acceptance testing phase, and unless you have a fascinating job, you are not going to be privy to that data either. Yet, you will get change notes on what you need to build and then change, possibly with plenty of redactions.
“We tested the and the setting can’t be set to a high enough value for _”
Ok, clearly you can’t work like that either.
Enter abstraction

Obviously, as architects/programmers, we can’t really know everything they will be capturing about this hypothetical weapon they want to capture and test (and if you have ever thought about actuarial work in your life, you know you do NOT want to know the gory details!!). All we can know is that they will have a set of test types they will tell you about.
And then you abstract the concepts to something that the programming team can relate to. Maybe the type of damage a Nerf toy or a dog can do. Clearly not the same thing, but also, both can be thought of as weapons of destruction as a homeowner (or Lego owner at the very least.)
Values that make sense
The next thing our brain always wants is a set of data that we can verify that the entire system works. The big desire is to get production data (perhaps sanitized, but certainly real data at its core). If we can show the customer their sales, their weapon test, we will feel better about our code.
This realistic data allows us to be able to do the two tests I described here. It compiles, and we get output that feels like it is correct.
This makes the customer also feel good about your work.
Real data is a trap
Once you leave the abstract phase, you start limiting your thinking and instead of thinking about all the problems that could happen with any data of a certain type, you start thinking just about the real data and what is currently occurring. If it looks good, it must be good. (Just like theme park seafood, it is prudent to be wary depending on the situation.)
If you believe that all weapons are made of metal, you won’t consider capturing the materials. Or if the shopping center only currently sells hard products, but wants to move into services, you may limit your thinking to their current products and suggested services and forget the requirements, and they may be limited to vague guesses too.
Requirements keep you grounded, Abstractions let you think
One of the things I tell everyone I meet (even the cashier at the restaurant I just ate breakfast in), is that design, code, tests, etc, all come from requirements. When we start making up our own requirements we are in a really bad place where we are not only probably giving the customer something different than they specified, but also spending someone else’s money to do it.
But at the same time, when you abstract the problem, you stop thinking in only the specifics of how the requirements are written, and start solving the problem. Done during design, this is generally welcomed. Requirements indicate they have sales in one location of a fixed list of products, but the statement of work says they are expanding.
And then you design processes that fit the actual need, rather than with blinders on, using data that has only specific data where they want to expand. Of course fitting the old data in your system is necessary, but fitting new data that doesn’t yet exist is even more important.
“We’ve never had duplicate data” is one of those things. “No need to worry with uniqueness constraints, we write perfect code” and such fairy tales.
Conclusion
If you are designing and building software, one of the first things you need to learn to do is to take a specific problem and turn it into an abstraction of itself, all without losing sight of the actual problem you are trying to solve. This abstraction doesn’t have to be like the weapon system test where you determine the blast radius of a Nerf gun and a puppy, it could just be creating test data that pushes the limits and doesn’t rely on what has been to predict the future.
It is not easy, but it is generally always possible. Sometimes it informs your design, but it always makes testing easier because you are almost never going to be building a system that works exactly like the previous system and holds exactly the same data.



Leave a Reply