SDLC in the Real World

SDLC - System Development Life Cycle (SDLC) - a methodology used to develop, maintain, and replace information systems.

I've run into more than a few project managers, developers, testers, and product managers that have caught the SDLC buzz word fever. They've either latched onto the newest, latest, coolest, hippest methodology, or they read in a book that you can't succeed without one, or (most likely) their manager said that they need to have one. However they get to this state of mind, they usually follow the same course of action.

1. 
   
2. Go to bookstore and buy 1 book
   
3. Read at least the first few chapters of said book. Some even make it all the way through
   
4. Go to their next team meeting, and declare that they are implementing an SDLC. No one else can ask questions or offer input, because the book says it will work exactly as its written
   
5. Meetings are called with subjects that mysteriously match the book's chapter headings
   
6. The rest of the team has no idea what is going on, but they are following their enlightened SDLC leader blindly. It still seems like they're writing and testing code, so at a granular level, most everything seems to be the same
   ...... The Project Continues .....
   
7. Utter chaos ensues, the product is late, the quality suffers, and it is deemed that SDLC's are worthless
   
8. Team reverts to prior process, and ships with previous efficiency, tracking, quality issues, and date slips. While that may sound bad, they still ship and shipping software is a key test of success or failure in commercial software.
   

So where does the value from using a methodology come from? For me, it all comes down to one thing: change management. If there was only one programmer, and he knew the customers, wrote the requirements, wrote the code, tested the code, fixed the code so it was bug free, packaged the product, and shipped it, there would be no need for an SDLC. OK, now back to the real world. Requirements change. Team members quit. Testers miss bugs. Developers write more bugs when they fix the bugs QA already found. Customers can't articulate what they want. The list goes on and on. This is where having a defined methodology helps. It gets your entire team on one page. When someone falters, everyone knows, and everyone understands the impact of what that means and can adapt. It is not a blame issue, but one of good communication. When you have a team driving toward a common goal, working in a common way, helping each other succeed, then you have a team with a shared vision. A team with a shared vision can do amazing things. They can have requirements change at the last minute, and everyone knows where to help, who is impacted, and how to react. The same scenario goes into effect when someone on your team leaves. Normally, the team is lost for a bit. Some piece of critical information or a critical process lived only in that person's head, and now that they are gone, the team is lost. Again, common steps, common process, common knowledge, shared vision, and teamwork. All of this leads a team to be adaptable to change, and having a team that can adapt and manage change, rather than letting the changes manage them is key to large scale success in software.

Having a team that can adapt and manage change, rather than letting the changes manage them is key to large scale success in software

Then how does all of this apply to me? I've been through a handful of projects, and I've learned the most important lesson about SDLC: No SDLC is perfect. All of those books look really good in print, but they are all based on best case scenarios and case studies. The key is to learn as much as possible, study many methodologies, and adapt a methodology to your team. I have a personal methodology that I usually try to follow, with parts taken from a few different communities, but with each new team and each new project, the process is adapted. The value of a process is to help organize your team, not to organize your team according to the process. There is always pain, resistance, and adaptation when implementing change, but it should be for the betterment of the team, not because you are trying to fit the team to something from a book.

This is the general methodology that I have used successfully in the past. It is a combination of a traditional waterfall development cycle, but focuses on short term, iterative deliverables during the development cycle. These are similar in principal to sprints from the SCRUM methodology (my personal term is protocycles), but with a different up front planning process. There are also aspects of XP and MSF woven throughout, but I won't get into that many details in this post.

1. Establish high level requirements. These need to be detailed enough that the technical design can be built from these requirements. This deliverable essentially drives the vision for the release. A 3 release roadmap is also required, so that the development team can understand what the future product plans are, with as much clarity as possible.
   
2. Define the detailed requirements. This task takes the high level release requirements, and drills down to a sufficient level of detail required for the development team. As each detailed requirement document is completed, it is sent for peer review and acceptance by a representative from development, quality assurance, architecture, product management, and development management. This task happens in parallel with the technical design.
   
3. Define the technical design (Architecture). Based on the high level requirements, establish a product architecture taking all three releases requirements into account. The architecture deliverables for version 1 should be at sufficient detail for the development team to use, and mock architectures should be vetted in order to validate feasibility for the version 2 and version 3 requirements. This task happens in parallel with defining the detailed requirements.
   
4. Product Development. The development team executes the detailed requirements and the technical architecture. This process is somewhat agile in nature, since features can be started once the specification for that component is complete, rather than waiting on an entire requirements package.
   
5. Quality Assurance. The QA team validates the software created by the development team meets the defined requirements. Test cases are created for each completed requirements document, following its peer review acceptance. For a test engineer, the requirements should read like a contract, validating that development met their end of the contract. As is typical during a development cycle, requirements will change. These will be handled as requirements addendums or modifications.
   
6. Release to Manufacturing. This is the final step in the process. Once a product is ready to be delivered to market, this step represents the processes preparing for general availability. Depending on the organization, this could include source code escrow, marketing coordination, gold CD creation, retail packaging, etc... The timing for this process is generally organizationally dependent.
   

There it is, how to ship software in 250 words or less. I'm not trying to demean what any of us do, but at the end of the day, it all sounds so simple, doesn't it? Define what you want, research it, document it, code it, test it, give it to people who will pay you for it.

Technorati : Development Management, Management, Methodology, Program Management, SDLC, Software, Software Development, Software Development Lifecycle, Software Management