Archive
Reasonable Debugging
In Rich Hickey‘s QCon talk, “Simple Made Easy”, he hoisted this slide:
So, what can enhance one’s ability to “reason about” a program, especially a big, multi-threaded, multi-processing beast that maps onto a heterogeneous hodge-podge network of hardware and operating systems? Obviously, a stellar memory helps, but come on, how many human beings can remember enough detail in a >100K line code base to be able to debug field turds effectively and efficiently?
How about simplicity of design structure (whatever that means)? How about the deliberate and intentional use of a small set of nested, recurring patterns of interaction – both of the GoF kind and/or application specific ones? Or, shhhh, don’t say it too loudly, how about a set of layered blueprints that allow you and others to mentally “fly” over the software quickly at different levels of detail and from different aspect angles; without having to slodge through reams of “flat” code?
Do you, your managers, and/or your colleagues value and celebrate: simplicity of design structure; use of a small set of patterns of interaction; use of a set of blueprints? Do you and they walk the talk? If not, then why not? If so, then good for you, your org, your colleagues, your customers, and your shareholders.
Geeks Bearing Formulas
Since there are so few champions that have successfully leveraged simplicity to paradoxically conquer complexity, and he is one of them, legendary investor Warren Buffet is high on my hero and mentor list. Check these jewels out:
All I can say is, beware of geeks … bearing formulas. – Warren Buffet
The business schools reward difficult complex behavior more than simple behavior, but simple behavior is more effective. – Warren Buffet
Unnecessarily Complex, or Sophisticated?
I recently stumbled upon the following quote:
“A lot of people mistake unnecessary complexity for sophistication.” – Dan Ward
Likewise, these two quotes from maestro da Vinci resonate with me:
“Simplicity is the ultimate sophistication.” – Leonardo da Vinci
“In nature’s designs, nothing goes wanting, and nothing is superfluous.” – Leonardo DaVinci
When designing and developing a large software-intensive system, over-designing it (i.e. adding too much unessential complexity to the system’s innate essential complexity) can lead to disastrously expensive downstream maintenance costs. The question I have is, “how do you know if you have enough expertise to confidently judge whether an existing complex system is over-designed or not?”. Do you just blindly trust the subjective experts that designed the system when they say “believe me, all the complexity in the system is essential”? If you’re a true layman, then there is probably no choice – ya gotta believe. But what if you’re a tweener? Between a layman and an expert? It’s dilemma city.
The figure below depicts a simple model of a generic multi-sensor system. The individual sensors may probe, detect, and measure any one or more of a plethora of physical attributes in the external environment to which they are “attached”. For example, the raw sensor samples may represent pressure, temperature and/or wind speed measurements. They also may represent the presence of objects in the external environment, their positions, and/or kinematic movements.
The fusion processor produces an integrated surveillance picture from the inputs it receives via all of the individual sensors. This fused picture is then propagated further downstream for:
- display to human users,
- additional value-added processing,
- automatically issuing control actions to actuators (e.g. gates, lights, valves, motors) embedded in the external environment .
Now assume that you are given a model of a multi-sensor system as shown in the figure below. Is the feedback interface from the fusion processor back to one (and only one) sensor evidence of an over-designed system and/or unnecessary added complexity? Well, it depends.
If the feedback interface was purposely designed into the system in order to increase the native functionality or performance of the individual sensor processor that utilizes the data, then the system may not be over-designed and the added complexity introduced by designing in the interface may be essential. If the feedback loop only serves to “push back” into the sensor processor some functionality that the fusion processor can easily do itself, then the interface may be interpreted as adding some unessential complexity to the system.
In any system design or system analysis/evaluation process, effectively judging what is essential and what is unessential can be a difficult undertaking. The more innately complex a system is, the more difficult it is to ferret out the necessary from the unnecessary.
Why am I here?
WTF?
Meh!
D'oh!
My BTC Address
Bulldozer00's Blog 