The software development process is a big black box for basically everyone on the planet earth, except for a few, proud individuals who speak geek and wear silly tee-shirts. To everyone else who doesn’t read code or wear silly tee-shirts but work with people who do, the last bit of sanity they have is during the time they get to tell development what they want. After that, stakeholders are left praying that at the end of the developmental process, they get something out of it that works. More often than not, if that developmental process takes a long time, stakeholders don’t get want they want.

Along came iterative processes and customer involvement and things got better. A little. Stuff still broke. And developers still had horrible manners and wore silly tee-shirts. A few of them also appeared not to have learned basic hygiene.
Then came test driven development. Developers’ manners were the same and they still wore silly tee-shirts, but at least the code wasn’t as horrible. Hygienic concerns remained.
Iterative processes became more popular and the stakeholder wanted more. The stakeholder wanted visibility into that black box that those silly tee-shirt wearing developers called the “dev cycle” or the “software construction phrase” but what the normal people called “sit tight and pray a lot” time or “oh gosh, what’s this gonna cost this time?”. After all, they were paying for it and the tee-shirts those developers wore didn’t make any sense (hygienic concerns not withstanding).
Along came the gurus shouting “traceability!” which makes total sense since stakeholders are paying the bill. Emboldened, stakeholders declared:
“When a user selects 3 items, then they should receive a 10% discount.”
Heads nodded. The look of approval was unmistakable. Business was accelerating forward and everyone was happy.
Soon, stakeholders were summoned. The silly tee-shirt wearing developers proudly showed the stakeholders a test case proving the requirement was met and even tested.
![]()
The stakehoders looked puzzled. Confused even. And they weren’t trying to read those silly tee-shirts or ponder hygienic skills. Development put their finest heads together and clarified the situation with some documentation:

The stakeholders did their best to understand what they were looking at. In fact, the code even tried to convey more meaning. Yet, no matter how hard they tried, the stakeholders couldn’t speak geek. They couldn’t read the code. They couldn’t laugh at the tee-shirts. They couldn’t not brush their teeth.
Then one of the stakeholders (who used to wear silly tee-shirts) got an interesting idea– why not leverage the same language for both defining the requirements and validating them? In fact, by leveraging BDD constructs and paying attention to what was originally asked for, things can become quite easy.
This is what was originally asked for:
“When a user selects 3 items, then they should receive a 10% discount.”
The key word being should– in fact, the mechanism by which the requirement was requested sounded an awful lot like a story, which could be written like so:

Then working with a few developers (who showered that morning), the stakeholder convinced them to author the story using a BDD framework (like easyb), which yielded a file containing the requirements like so:

After the code was implemented, the stakeholder was pleased. Other stakeholders were summoned. Other developers were also summoned. Soon heads nodded. Approval was in the air. Business had been accelerated and all involved parties understood each other, for indeed, stakeholders could read what development had finally produced:

Stakeholders rejoiced! Developmental jollification ensued. Speaking geek was no longer needed. Things were written in plain English. Those silly tee-shirts still didn’t make sense, but it didn’t matter anymore– stakeholders got what they wanted. They got validation. They got assurance that indeed their requirements had coverage. They didn’t get some of the developers to shower, but they weren’t asking for miracles, just progress. The “sit tight and pray a lot” time became a collaborative effort. BDD had saved the day.

April 2nd, 2008 at 8:15 pm
[…] 0.8 is easyb’s bag The hip folks over at easyb.org have released version 0.8 of easyb. If you haven’t seen easyb yet, then you are in a for a real treat as easyb is the coolest thing since sliced bread, baby. As a BDD framework for the Java platform, easyb makes it super easy to craft executable documentation for software requirements by leveraging a flexible (and easy) story based domain specific language. […]
April 4th, 2008 at 9:22 am
I had the great pleasure of seeing Andy speak on the topic of BDD last night at the APLN-DC meeting. While he’s been trying to drag me along on why BDD is both important and relevant, I walked away with the appreciation that: (1) people *think* in terms of behavior rather than testing and (2) BDD *drives* the correct implementation of TDD.
I am definitely going to look into BDD at much greater depth!
April 18th, 2008 at 9:26 am
[…] Saving the day with BDD- Customer-oriented thinking in action, baby. […]
May 16th, 2008 at 8:57 am
[…] As an example of how fixtures can be copasetic, over on testearly.com, easyb was utilized in combination with Selenium to create a more human readable functional story. […]
May 22nd, 2008 at 12:28 pm
What this story doesn’t mention is that the stakeholders, all of whom hold Masters Degrees in Business from Harvard (or insert Ivy League School here), change the requirements every 15 minutes because they actually have no clue as to what they want. They also consult their completely non-technical friends (who they retain at a salary equivalent to 3-4 developers) to “give a second opinion” about what development is doing. Said non-technical
friendsbusiness consultants ALWAYS respond with “you should outsource this to a team with absolutely no knowledge or understanding of the technology you use ’cause they’ll work for pennies on the dollar, saving you money and ensuring that you’ll get your bonus.” Stakeholders then approach development and demand that the project be completed within the next 15 minutes because all software development, really, is just somebody sitting at a computer and typing a bunch of code. (They think because business management is just a matter of somebody in an office with authority making arbitrary/bad decisions, that there’s no skill or actual intelligence required anywhere else within the organization).The story also omits the part about stakeholders being so ignorant that they think their legacy AS400 system can be fully converted to a secure web-based application written in pure client-side Javascript (because they heard Javascript was cool in a business magazine) which will be deployed on a $400 multimedia desktop machine they provisioned from Circuit City.
If developers don’t practice good hygiene it’s likely so that they’ll chase the ignorant vermin away. It’s called a “defense mechanism.” Stakeholder Stupidity burns more than hydrochloric acid… and oh, it leaves scars.
Major flaws in the storyline aside, I fully agree that BDD is awesome.