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. A wide variety of such frameworks have evolved over the years, each with its own recognized strengths and weaknesses. One software development methodology framework is not necessarily suitable for use by all projects. Each of the available methodology frameworks are best suited to specific kinds of projects, based on various technical, organizational, project and team considerations.
The methodologies can be divided into two main categories; i.e. Traditional and Structured. Both of which are discussed below.
Traditional software development
Traditional software methodologies are often called heavyweight methodologies because they are based on a sequential series of steps that has to be defined and documented in detail, they do not support changes of requirements and the complete system has to be known at the very beginning. Four main characteristics of these methodologies are
- Predictive Approach
- Comprehensive Documentation
- Process Oriented
- Tool Oriented
The main characteristic is the predictive approach. Approach is following the principle of system prediction. Before the beginning of the software development budgeting for the project has to be made. In the first phase, the phase of software specification, complete system is analysed and designed. Responsibility of the analyst or a group of analysts is to predict and create sustainable software architecture model. Model is documented using UML which is acronym for Unified Modeling Language. The generated model is then forwarded to another person or team whose job is to develop and build the model. Roles and responsibilities are divided and communication takes place over the documents. For that reason, all the process has to be documented in detail. Requirements have to be specified and signed by the customers and development team. The result of creating the document for each activity is comprehensive documentation of the system and processes. For each task there is a well-defined procedure of execution. The aim of the traditional methodologies is not to adopt methodology to the system but to adopt the system according to methodology. All the processes are the same no matter of the company size or team structure etc. Methodology dictates the tasks and procedures that has to be accomplished by the exact role; manager, designer, developer, tester, analyst, etc. All the processes are supported by usage of the tools. The entire project has to be documented through some of the project management tools. Each step, task or procedure is created, recorded and updated to its current state. Tracking of the processes is very simple but it demands additional time and effort on supporting activities.
Some of the common models are
Waterfall Model
In it development flows steadily through requirement analysis, design implementation, coding, testing, integration and maintenance. With every phase, one deliverable is compulsory. This is basically document driven model in which proper sequence is maintained.
Prototyping Model
Software prototyping is the development approach of activities during software development, the creation of prototypes, i.e., incomplete versions of the software program being developed. Small-scale mock-ups of the system are developed following an iterative modification process until the prototype evolves to meet the users’ requirements. While most prototypes are developed with the expectation that they will be discarded, it is possible in some cases to evolve from prototype to working system. A basic understanding of the fundamental business problem is necessary to avoid solving the wrong problem.
Incremental Development
Various methods are acceptable for combining linear and iterative systems development methodologies, with the primary objective of each being to reduce inherent project risk by breaking a project into smaller segments and providing more ease-of-change during the development process. A series of mini-Waterfalls are performed, where all phases of the Waterfall are completed for a small part of a system, before proceeding to the next increment.
Spiral Development
The spiral model is a software development process combining elements of both design and prototyping-in-stages, in an effort to combine advantages of top-down and bottom-up concepts. It is a meta-model, a model that can be used by other models. Focus is on risk assessment and on minimizing project risk by breaking a project into smaller segments and providing more ease-of-change during the development process, as well as providing the opportunity to evaluate risks and weigh consideration of project continuation throughout the life cycle. Each cycle involves a progression through the same sequence of steps, for each part of the product and for each of its levels of elaboration, from an overall concept-of-operation document down to the coding of each individual program. Each trip around the spiral traverses four basic quadrants:
- Determine objectives, alternatives, and constraints of the iteration
- Evaluate alternatives; Identify and resolve risks
- Develop and verify deliverables from the iteration
- Plan the next iteration
Structured Software Development
Despite the success of Traditional models, it has a number of drawbacks, like inflexibility in face of changing requirements. Structured Software Development methods deal with unstable and volatile requirements by using number of techniques, i.e. simple planning, short iteration, earlier release and frequent customer feedback. This enables them to deliver the product release in a much short period of time compared to traditional approach. The most commonly used structured software development methodology is Agile Methodology, which is discussed below.
Agile Methodology
In order to support high quality assurance agile methods include the following concepts and techniques
- Refactoring
- Test Driven Development (TDD)
- Tests replace traditional artifacts
- Agile model driven development (AMDD)
Refactoring: A disciplined way to make small changes to source code to improve its design and making it easier to work. The developers neither add nor remove any functionality or logic they merely improve its quality it affects the complete project life cycle by saving time and increasing quality.
Test Driven Development (TDD): An approach to programming where agile software developers must first write a test that fails before they write new functional code.
Tests replace traditional artifacts: Agile developers believe that tests are the artifacts that need to be developed and maintained throughout a project, they consider acceptance tests to be the first requirement artifact.
Agile Model Driven Development (AMDD): AMDD suggests that it’s a good idea to model before coding, with AMDD first a little bit of modeling is done and then a lot of coding, this is a iterative cycle. As a result design efforts are now spread out between modeling and coding activities, with the majority of design being done as part of implementation efforts.
Agile methods include many practices to support quality assurance, as mentioned below:
- On-site customer
- Pair programming
- Continuous integration
- Acceptance testing
The quality of software in agile framework is better than traditional framework because the Agilest developers ensure their code’s good design, quality and functionality through refactoring, TDD and other practices. Also the quality assurance and testing and bug fixing activities are more frequent and start at a very early stage in the agile process as compared to the traditional framework.
