Over the last few years we’ve developed some pretty strong feelings about how to build software correctly. We turned our best ideas into The 5D Methodology, our popular secure software development life-cycle (SDLC). By the way, 5D stands for Define, Design, Develop, Debug and Deliver.
Okay, so what is this mystical 5D Methodology? Let’s step back a minute and define what a software methodology actually is. From Wikipedia…
A software development methodology or system development methodology in software engineering is a framework that is used to structure, plan, and control the process of developing an information system.
In a nutshell, when you follow a proven software methodology, you are no longer winging it. Now that’s not to say following a software methodology guarantees success. In the wrong hands, it won’t make a bit of difference. Furthermore, even the most talented software professionals can find themselves knee deep if they don’t have a plan. So you need both, really.
Okay, let’s briefly review our 5D Methodology.
Before you try to design and create your custom software application, you really need to define the basic nature of your project. It makes no sense to rush out designing the perfect solution before you’ve even defined the problem. Otherwise, how do you know we’ve even satisfied your requirements? Just as importantly, how would you measure the success of the project? You can’t. So we make our first objective defining exactly what it is you need to do, and setting up a plan to accomplish it. Specifically, we focus on the following activities during this stage:
- Project Planning
- Requirements Definition
- Conceptual System Design
Now that you have a better idea about what we need to do, we summon our great designers and formulate an appropriate solution. Now you might be thinking…”great, I’m off the hook now”. Sorry, you aren’t getting off that easy. We work with you and/or your team to craft the best solution. It’s a team effort. We use neat prototyping tools like Serena Composer, and a host of other aids, to make sure we are all on the same page. Our goal is to build the right solution, not cover our butts with complex technical docs you sign off on. So what are we doing during the design stage? Here’s a brief list:
- Functional Design
- Technical Design
- System Architecture
- Training Plan
- Test Plan
One clarification before we dive into this stage. Software development is a highly iterative process. This isn’t a waterfall approach. It is common for parts of an application to go through the 5D’s several times, until we get it exactly right. For example, we might discover that a billing module doesn’t work exactly as intended while in the develop stage. This would cause us to clarify the requirements (define stage) and revisit the design, before making the required coding changes. Bottom line: it’s a dynamic process. Don’t let the linear structure of our methodology fool you.
The develop stage is usually the most time-consuming. During this stage we are involved with activities pertaining to the assembly, testing and documentation of your new software. Other activities that we perform during this stage include:
- Application Coding
- Testing/Quality Assurance
- User Documentation
- Program Documentation
- Change Management
With the rise of mobile devices, web development and debugging is more complex than ever. We have more browsers and platforms to support. We have more screen sizes and resolutions. And we’re building in-browser applications instead of the flat, brochure-ware sites of yore.
Debugging code on a mobile device is still one of our biggest pain points. But, again: now we have tools. Opera Dragonfly and its remote debug feature provides developers a way to debug mobile sites from their desktop. WebKit recently added remote debugging to its core and Google Chrome has already folded it into its developer tools.
As the web has evolved, so have our tools. Code injection, error throwing and catching, and remote debugging services are all helping us ship better, less buggy apps.
So what is the deploy stage all about, anyway? After all, don’t we just send you the code on CD, and wish you good luck? In a word, no. The deployment of your software is possibly the most important aspect of the whole process. After all, in many respects, this is when the project really begins. Your people are using it, and that means it better be installed, configured, and performing up to snuff. What exactly do we do during this final stage?
- Hardware/Software Installation
- Data Conversion
- User Training
- Support Training
- Post Implementation Review