Steve Yegge hits a homer: Your requirements are stupid.

Lately, I’ve been ruminating on requirements and requirements management (also known as disaster control). I was actually typing something up on this, but Steve Yegge hit the nail on the head – then he rammed it through the board and into the house next door:

Anyway, there you have it: the slightly expanded version of the email I sent that CEO guy. Gathering business requirements is hokum. Hooey. Horseshit. Call it what you want, but it’s a sign of organizational (or individual) cluelessness. If you don’t already know exactly what to build, then you’re in the wrong business. At the very least, you should hire someone who does know. Don’t gather business requirements: hire domain experts.

Also, FWIW, here’s the hackernews discussion. Here is a link from one of the comments pointing to something Linus once said about specs:

they’re dangerously wrong. Reality is different, and anybody who thinks specs matter over reality should get out of kernel programming NOW. When reality and specs clash, the spec has zero meaning. Zilch. Nada. None.

I think one of the comments also added something spectacular – noting that “building something for yourself” is why so many open source projects flourish. If you’re building something useful for yourself – there’s a high chance that someone else is going to want to A>Use it B>Buy it – “building for yourself” is also in some ways, “keeping the vision clear”

One of the key concepts which seems to be the undercurrent to what he talk about is vision. You need someone who can stand up and say “this is what the product is, does and where it is going”. You need that visionary who can clearly outline what itch you are trying to scratch. In open source – that’s the project “core” – in business, it’s the CTO or founder. It’s always the person that had the itch, they’ve “walked a mile in the shoes” so to speak.

That vision has to be the core of both the product, and all of the requirements – this “clarity of vision” (some might say “simplicity of vision”) is what makes so many projects and products successful.

Sure – as you grow you’ll add features: You don’t want to stagnate – but those features have to make sense – they have to mesh with the core vision of the product. You don’t add a source code management service to say, twitter.

Why? Because even if 1 customer thinks “that it would be AWESOME” – you’re going to spend $X hours of engineering time gluing a volvo on the side of your battleship, and unless those $X hours are compensated by the amount of money the customer is willing to pay (it never is) you’ve wasted time, and muddied the functionality and philosophy of the product. It’s about as useful as a screen-door on a submarine.

When you’re thinking about requirements ask yourself this: If at the start, you can not describe exactly what your product does in under a minute – you’ve already got a problem. If adding this feature makes it even harder to describe/encapsulate the vision and capabilities of the product you’re rapidly running towards wronger-than-wrong.

If you yourself would not use the feature: Does it really make sense? When a customer requests a feature – does it make sense for anyone outside of them? Would you be better served by providing an API and an SDK?

This is the beauty of things like a clean API – you can keep the philosophy and core of the product/project clean and empower your users to build any number of things they want on top of your product. Keep it simple, keep it clean. Empower your users to “mashup” as they need or want to.

Think of it terms of cooking: If you wouldn’t eat it yourself, in all likelihood your customers won’t like it, at best it will be mediocre. The best chefs taste and consume what they cook.

Right now I’m wishing Brian Fitzpatrick’s keynote from pycon: “You *can* Fool All of the People All of the Time” was online in video form.

See also: THE TECHNOLOGY OBSESSION by S. Lott

  • I'm loving the "volvo on the side of your battleship" comment .... soo true :)
  • Jeez, read the Mythical Man Month. Then read it again. Fred Brooks was the first to say it and he said it better than anyone since. Why people need to keep on re-discovering the obvious is beyond me. FOSS projects are successful because they follow so many of Brooks principles for success.
  • No one is "re-discovering" anything - Yeah, this is old hat rehashed, but it still doesn't change the fact that too many companies, people and developers themselves don't adhere to basic sanity. You don't need to preach to the choir.
  • CAT
    There is a lot of truth in this.
    I cannot say, who approved or dismissed the requirement for a trash bin at least somehow similar to the desktop counterparts in every iPhone 1.0 app, but both the person (don't care shit, if he's also named Steve ?;-) and this requirement is extraordinarily stupid, too.

    In another media company which tried to jump the music download bandwagon, a service they killed soon after Apple started dropping DRM I was in a project where a couple of stakeholders had various meetings about how the search pages and "microformats" for music download items should be designed. A couple of approaches from various business guys and managers a "simple" DBA or sysadmin stood up and said "This is all Bullshit, let's try the opposite approach". And it worked just fine for us to design and implement it in a few week's time.

    I know a few similar episodes, but this probably meets your tagline best..
  • Although I agree that "requirements gathering" usually smells of overpaid balding contractors, I've noticed that a software project will quickly fail if there is not a clear specification for how a user should use it. Rather than use the word specification, my company has adopted the phrase User Story. Specifically, we pull a lot of operational theory from the Scrum methodology (http://en.wikipedia.org/wiki/Scrum_%28development%29). Scrum goes so far as to say all User Stories must look like this: "As a <specific user=""> I want to <perform action="" some=""> so that <some achieved="" is="" value="">." While it is sometimes hard to get these stories right the structure is genius. It forces the development team AND the business to prioritize features better, cut out unnecessary features, and focus on delivering software solutions to the user for business value. If the stories aren't in this structure then they start to look more like "requirements."

    I heard recently about a team that had a story, something like "Migrate to new database." This never got prioritized in a work sprint. The business and developers just kept pushing it back putting other stories in front of it. Then, finally someone rewrote the story better: "As a developer I want to migrate the database from Oracle to Postgres so that the business can save hundreds of thousands of dollars per year." Well, guess what, that revised story took precedence over all others ;)

    It's also true about having one single visionary. There's another interesting methodology called DSDM (http://en.wikipedia.org/wiki/DSDM). They actually define a role in software development called the "Visionary," a person who is responsible for the direction of the product. This always reminds of the Mac OS X desktop. I read somewhere that there is *one* single person who approves UI decisions. I personally think OS X has a great user interface and if this is true then it certainly proves the importance of making one person (not a committee) in charge of the really hard decisions.</some></perform></specific>
  • Wardo
    I certainly can't argue with Linus, but Steve Yegge has a dangerously one sided (and immature) view of requirements engineering. I used to feel the same way when it came to requirements, just a bunch unnecessary busy-work that got in the way of real work. Then I started developing medical applications and realized the value of requirements. Not only will you never release anything that falls into the realm of FDA regulatory oversight without them, but when you are a patient, trust me, you'll be glad they're there.

    I think when Linus made that statement, specs were not as iterative as they are now. Just as the waterfall approach to development has gone the way of the dinosaur, so too has requirements being etched into stone - reality always wins. BTW, requirements and specs are two very different beasts...
  • So, Steve and by extension, I, am not arguing *against* requirements - we're both arguing against the "normal" method of gathering and identifying those requirements (and by extension, features) in many companies, starups and others alike. Steve's idea is simple: Don't build something *you* wouldn't use.

    I don't think anything either one of us has said runs counter to the idea of mission-critical applications. Especially when designing those types of devices and applications it's important not to muddy the waters with useless features, ideas, or requirements. It's critical to "keep to the core" - do one thing, and do it exceedingly well. Design one thing: And design it well.

    Do not create things you yourself - or your company - you would not use. Requirements are good - they define what you have to do, but where those requirements and features come from is the key to what we're both saying.

    As for waterfall going the way of the dinosaur - well, you obviously haven't worked in a lot of bigger software teams or groups, or with people who "came to age" in that era. The waterfall method of requirements definition is very alive and well, much to the chagrin of many :)

    The same applies to specs - you can design a per-the-spec NFS server, but guess what? Most clients on the desktop and server are *not* spec compliant. You will always be making concessions to clients that played it fast and loose.

    It's much better to identify your core users (of which you are one) and write the software to help and serve *them* - not the spec.

    Ultimately I think Steve's post stands on it's own: Build something you love, use and believe in. Don't build something for some mythical audience with a made up set of requirements which will ultimately not serve them properly - a product that only does 50% of what they need, 50% of the way they need and want to work will ultimately fail.
  • Wardo
    Upon re-reading my comments, I realize I didn't effectively communicate my position. That position is: Requirements are *mostly* necessary, and the discipline of requirements engineering is a neglected and misunderstood discipline. I apologize for the *immature* remark, because now I understand where Steve is coming from, and stupid requirements are a huge problem and more often than not constitute the majority of requirements set down - I have worked in environments with stone tablets for requirement templates. My comment originated from the colloquial developer predisposition that requirements, in any form, are an unnecessary burden and that the process needs to go away.
  • It's quite alright - I too once thought requirement were stupid. When I get a chance, I might work up a post on a project that I spearheaded (it was an internal one) where I outlined the requirements, wrote the code (badly) and then pushed it upon the users. It ended well - after much pain and time.
blog comments powered by Disqus