Archive
Customer Suffering
For some context, assume that your software-intensive system can actually be modeled in terms of “identifiable C”s:
Given this decomposition of structure, the ideal but pragmatically unattainable test plan that “may” lead to success is given by:
On the opposite end of the spectrum, the test plan that virtually guarantees downstream failure is given by:
In practice, no program/project/product/software leader in their right mind skips testing at all the “C” levels of granularity. Instead, many are forced (by the ubiquitous “system” they’re ensconced in) to “fake it” because by the time the project progresses to the “Start Formal Testing” point, the schedule and budget have been blown to bits and punting the quagmire out the door becomes the top priority.
Messmatiques And Empathic Creators
Assume that you have a wicked problem that needs fixing; a bonafide Ackoffian “mess” or Warfieldian “problematique” – a “messmatique“. Also assume (perhaps unrealistically) that a solution that is optimal in some sense is available:
The graphic below shows two different social structures for developing the solution; individual-based and group-based.
If the messmatique is small enough and well bounded, the individual-based “structure” can produce the ideal solution faster because intra-cranial communication occurs at the speed of thought and there is no need to get group members aligned and on the same page.
Group efforts to solve a messmatique often end up producing a half-assed, design-by-committee solution (at best) or an amplified messmatique (at worst). D’oh!
Alas, the individual, genius-based, problem solving structure is not scalable. At a certain level of complexity and size, a singular, intra-cranial created solution can produce the same bogus result as an unaligned group structure.
So, how to resolve the dilemma when a messmatique exceeds the capacity of an individual to cope with the beast? How about this hybrid individual+group structure:
Note: The Brooksian BD/UA is not a “facilitator” (catalyst) or a hot shot “manager” (decider). He/she is both of those and, most importantly, an empathic creator.
Composing a problem resolution social structure is necessary but not sufficient for “success“. A process for converging onto the solution is also required. So, with a hybrid individual+group social structure in place, what would the “ideal” solution development process look like? Is there one?
The Gap Of Woe
In “Why Software Fails”, the most common factors that contribute to software project failure are enumerated as:
- Unrealistic or unarticulated project goals
- Inaccurate estimates of needed resources
- Badly defined system requirements
- Poor reporting of the project’s status
- Unmanaged risks
- Poor communication among customers, developers, and users
- Use of immature technology
- Inability to handle the project’s complexity
- Sloppy development practices
- Poor project management
- Stakeholder politics
- Commercial pressures
Yawn. These failure factors have remained the same for forty years and there are no silver bullet(s) in sight. Oh sure, tools and practices and methodologies have “slightly” improved project performance over the decades, but the increase in size/complexity of the software systems we develop is outpacing performance improvement efforts by a large margin.
A Dearth Of Libraries
In Herb Sutter’s talk at GoingNative 2012, he opined that the biggest weakness of C++11 is its dearth of libraries; which causes programmers to waste lots of time ($$$) writing their own code to implement mundane functionality like XML parsing, cryptography, networking/sockets, thread-safe containers (<- I’ve had to spend quite a bit of time doing this!), serialization, etc.
Using language and library specification page counts, Herb started out by showing the progressive growth of C and C++ over time:
Next, Herb presented this eye-popping chart of relative library size for C++11, .NET, and Java:
Yes, that’s C++11 down in those tiny blue boxes. WTF! Note that the core language specifications on the left side of the chart are roughly the same size.
To address the issue, Herb proposed the formation of a an open-source Portable C++ Libraries (PCL) organization with the following guiding principles:
Herb also addressed the issue of how the PCL would interact with the C++ standards committee with this chart:
Basically, the PCL would serve as a front end vetter and integrator of library submittals in order to unburden the committee from the responsibility and allow it to concentrate more on tricky core language features (concepts, modules, static if, etc). The C++ committee would serve as the final fine-grained scrutinizer and approver of library additions to the language. In practice, libraries like poco and Qt could be shipped with every standards-compliant C++ compiler in the future.
I think Herb’s idea is a good one and I hope it blossoms into the real deal. How about you? What do you think?
operateUntilDeath()
Putting aside the “NotYouAndMe” class name in the bogus BD00 model below for a moment, I think most powerful and wealthy people believe that they can willfully control their feelings, actions, and behaviors via a “Conscious Executive” entity hosted within their brain. Objects of this fictitious class “require” and are “provided” energy by the one and only “life force“.
“NotYouAndMe” objects continually execute the “operateUntilDeath()” function in a “while(alive)” loop until the “life force” asynchronously pulls the plug – which can be anytime and anywhere. D’oh!
Each cycle through the “operateUntilDeath()” function goes something like this:
- Poll your senses for objects and events “out there“.
- Evaluate the sensor input data against prior memories accumulated and stored in your “Experience Database“.
- Speak/act according to whether you consciously perceive the current landscape as a threat or an opportunity.
The only problem with the model above (beside the fact that it’s another whacky BD00 concoction) is the “conscious” part playing the CEO of your corpus. That’s why the aggregator class is aptly named “NotYouAndMe“. To see this fallacy more vividly, feast your eyes upon the real, Nobel prize winning “YouAndMe” model below.
The BD00 mandated reality is that there’s a hidden and oft-denied “Unconscious Executive” behind the scenes that enables/disables the “Conscious Executive” object whenever it damn well pleases. In effect, the “Conscious Executive” gets sloppy seconds on the sensor data only after it’s been censored and chewed up by the “Unconscious Executive”. In totally clueless people like BD00, the “Conscious Executive” is rarely, if ever, “enabled“. D’oh!
How about you dear reader? Do you believe that you’re “fully in control and in charge”? Are you a “Conscious Executive“? The more you believe it, the less it is.
An Unexpected Honor
Whoo hoo, BD00 has arrived! Effective immediately:
Ghastly Style
In Bjarne Stroustrup‘s keynote speech at “Going Native 2012“, he presented the standard C library qsort() function signature as an example of ghastly style that he’d wish programmers and (especially) educators would move away from:
Bjarne then presented an alternative style, which not only yields cleaner and less error prone code, but much faster performance to boot:
Bjarne blames educators, who want to stay rooted in the ancient dogma that “low level coding == optimal efficiency“, for sustaining the unnecessarily complex “void star” mindset that still pervades the C and C++ programming population.
Because they are taught the “void star” way of programming by teaching “experts“, and code of that ilk is ubiquitous throughout academia and the industry, newbie C and C++ programmers who don’t know any better strive to produce code of that “quality“. The innocent thinking behind the motivation is: “that’s the way most people write code, so it must be good and kool“.
I can relate to Mr. Stroustrup’s exasperation because it took perfect-me a long time to overcome the “void star” mental model of the world. It was so entrenched in my brain and oft practiced that I still unconsciously drift back into my old ways from time to time. It’s like being an alcoholic where constant self-vigilance and an empathic sponsor are required to keep the demons at bay. Bummer.
Concurrency Support
Assuming that I remain a lowly, banana-eating programmer and I don’t catch the wanna-be-uh-manager-supervisor-director-executive fever, I’m excited about the new features and library additions provided in the C++11 standard.
Specifically, I’m thrilled by the support for “dangerous” multi-threaded programming that C++11 serves up.
For more info on the what, why, and how of these features and library additions, check out Scott Meyers’ pre-book training package, Anthony Williams’ new book, and Bjarne’s C++11 FAQ page.
HW And SW ICs
Because software-intensive system development labor costs are so high, the holy grail of cost reduction is “reusability” at all levels of the stack; reusable requirements, reusable architectures, reusable designs, reusable source code. If you can compose a system from a set of pre-built components instead of writing them (over and over again) from scratch, then you’ll own a huge competitive advantage over your rivals who reinvent the wheel over and over again.
One of the beefs I’ve heard over the years is “why can’t you software weenies be like the hardware guys“. They mastered “reusability” via integrated circuits (IC) a looong time ago.
One difference between a hardware IC and a software IC is that the number of input/output (IO) pins on a physical chip is FIXED. Because of the malleability and ephemeral nature of software, the number of IO “pins” is in constant flux – usually increasing over time as the software is created.
Even when a software IC is considered “finished and ready for reuse” (LOL), unlike a hardware IC, the documentation on how to use the dang thing is almost always lacking and users have to pour through 1000s of lines of code to figure out if and how they can integrate the contraption into their own quagmire.
Alas, the software guys can master “reusability” like the hardware guys, but the discipline and time required to do so just isn’t there. With the increasing size of software systems being built today, the likelihood of software guys and their managers overcoming the discipline-time double whammy can be summarized as “not very“.
Why am I here?
WTF?
Meh!
D'oh!
My BTC Address
Bulldozer00's Blog 