12 Aug 2006 at 04:25
Over the past 30+ years, the way we investigate, analyze, capture and
communicate requirements has changed at a much slower rate than the way we do the rest of software development. Use cases shifted things a bit and the more recent user stories have had some impact, but while the productivity of design and development activities have improved dramatically over the last 30 years, comparatively, requirements activities are still stuck in the quill pen era.
Improving requirements activities means adopting different ideas about what it means to investigate requirements, to reappraise what it means to communicate requirements and to fundamentally rethink the role of requirements in software development projects.
Being aware of the distinction between explicit and implicit constraints helps, but it is not enough.
- Some requirements can just be documented, they are well known
and understood (the explicit constraints)
- Some requirements emerge as part of conversations (the implicit constraints)
- Some requirements do not really exit yet, they have to be invented
11 Aug 2006 at 15:31
An article of faith in the software engineering community is that it is possible to document the requirements for a system before it is built.
I beg to differ. Sure, we can capture some of the obvious transactions that a system needs to support, and Use Cases are a great way of capturing this aspect of requirements. But, by definition, implicit constraints only really surface when someone is surprised by the difference between what they expected and what they got.
It is hard work to probe and question early on in a project to attempt to discover the implicit constraints, and my experience is that most projects don’t do very well at this. All seem to suffer from a nasty surprise or two just when everyone (except possibly the quality assurance people) is starting to think that the project is starting to really look like it is going to deliver a good system this time.
08 Aug 2006 at 15:00
One way I used to think about requirements was by making a distinction between facts imposed on the developers and design choices that were left to the developers. The facts were a way of thinking about the requirements.
Since then I have started to think more in terms of Constraints and Design Choices, mainly because the word constraints allows for more nuanced thought.
- Constraints are negotiable
- Some constraints are explicit
- Some constraints are implicit - and lots of problems arise from these culturally known items
- Constraints change over time, sometimes being relaxed, other times firming up
- New information can totally blow away existing constraints while imposing others
The implicit side of constraints are the most interesting for me currently, since these are the ones that are never written down. Not because people do not take the time to write them down, but because it never occurs to anyone that they need to be written down - after all it is just the way we do things around here. Since everyone know it, there is no thought that there is anything to write down.
The problem shows up however when someone form outside the culture gets involved with the development team. Now the outsider gets a whole lot of surprises as these implicit constraints get surfaced as disconnects and contradictions.
04 Aug 2006 at 14:35
Why do technologies and programming languages catch on? My guess is that I make the effort to learn those technologies that give me reasonably immediate gratification.
Yes, I can do delayed gratification, and I’m not all that into instant gratification, but I notice that the tools and technologies I know best are those that enabled me to do somethin useful fairly quickly. Interestingly that set includes 8080 assembler because it enabled me to do something interetsing on a MPM machine when I was starting out as a paid software developer back in 1983
20 Jul 2006 at 02:15
Republished What to do when the estimate is wrong article on this site.
19 Jul 2006 at 09:46
This is a follow up to my Software Craftsmanship and Questioning XP books, further exploring the way that we develop software.
Technology is never the issue
Ok I did make the case that Java could be but even it has stabilized enough that as a technology it is unlikely to be the cause of a project failure. The real cause of Java projects failing is the way that the team used the various parts of the Java platform.
Similarly for the .Net platform, it would be hard to pin a project failure of the .Net technology. How people have mis-used it could account for a lot of projects however.
So what are the issues?
I don’t know, but I’suspect it is the way we think about and talk about software.
Hence we need to improve our own wetware
Admittedly wetware can have some visceral images associated with it, but maybe that is an advantage in engaging our emotions with the issues.