Software is part of modern society for over 50 years. Software development began as a chaotic business and is often cited as the code and fix. The software program was written without much of the plan and design of the system. Also, it was set with many short term decisions. That’s fine for small systems, but as systems grow it turned out as increasingly difficult to add new features and bugs were harder to fix. This style of development was used for many years until this was replaced by an alternative: Methodology. This imposed a disciplined process for software development in order to make software development more predictable and efficient.
If you need assistance with writing your essay, our professional essay writing service is here to help!Essay Writing Service
Traditional methods are based on the work plan and begin to extract a complete set of documentation requirements, the architectural and high level of project development and control. Because of these serious aspects of this method has become known as heavy. Some practitioners realized this software development process frustrating. As a result, several consultants have independently developed methodologies and practices to adopt and respond to inevitable changes they have experienced. These methods and practices are based on multiple components, a technique that was introduced in 1975 and which became known as an agile methodology.
Agile methodology is gaining popularity in the industry, although they compromise a mix of accepted and controversial software engineering practices. Software industry is likely to prove that the specific features of the project, such as the purpose, scope, requirements, resources, architecture and size will determine the methodology that fits those best. Dynamic and heavy or perhaps a hybrid of the two. In the past few years, anecdotal evidence and success of practicing professionals suggests that effective methods are effective and suitable for a variety of situations and environments. However, empirical studies are urgently needed to assess the effectiveness and possible use of agile software development methods.
Heavyweight methodologies are considered the traditional way of software development. These methods are based on the following series of steps such as defining requirements, solution building, testing and deployment. Heavyweight methodology requires defining and documenting a stable set of requirements at the beginning of the project.
Waterfall approach emphasizes a structured progression between certain phases. Each stage consists of a term set of activities and tasks that must be met before the next stage can begin. The phases are always named in different ways, but the basic idea is that in the first phase tries to capture what the system will do, its system and software, in the second phase determines how it will be designed. The third stage is where developers start writing the code; the fourth step is testing the system and final phase focuses on tasks such as training and documentation. However, in engineering practice, the term waterfall is used as the generic name for all subsequent methods of software engineering.
Waterfall Model Life Cycle
All activities, including modeling, is divided into workflows in the Unified Process (UP) and takes place in an iterative and incremental manner. In this process the process is divided into four phases. The below diagram depicts the stages of this process:
Inception – By the end of the process a business case should be prepared, the project should be assessed and the scope of the project should be set.
Elaboration – In this phase, the basic architecture should be produced and agreed a plan to build. Furthermore, risk analysis takes place, and those considered to be major threats should be addressed.
Construction – This process creates a system of beta-version. System of work should be available and sufficient for a preliminary examination in real terms.
Transition – The system is introduced to the stakeholders and users intended. It is crossed when the project team and stakeholders agree that the targets agreed in the phase formation are met, and the user is satisfied.
There are approximately 50 work items are to be completed. All of this documentation and a rigid approach adds a lot of the complexity of the UP. As well, UP predefines roles to the project team making it less flexible.
Another heavy software development model is a spiral model, which combines elements of both design and prototyping-in-stages, trying to combine the advantages of the concept of top-down and bottom-up.
Determination of objectives – The specific objectives of the project phase are identified
Risk assessment and limitations – The main risks are identified, analysis and information obtained in order to reduce this risk
Development and validation – an appropriate model was chosen for the next phase of development.
Planning – The project is reviewed and plans for the next round spiral
Characteristics of Heavyweight methodologies
Heavyweight methodology is known for a long time. They impose a disciplined process for software development in order to make software development more predictable and efficient. Few characteristics of heavyweight methodologies are as follows:
Predictive approach: Heavyweight methodology tends to first plan out a large part of the process of software development in great detail over a long period of time. This approach follows the field of engineering, where the development is predictive and repeatable. Strong emphasis is placed on the drawings focusing on the needs of the system and how to address these needs effectively. Drawings determine how to build the system, acts as the basis for the construction process. As well, the plan provides for the delegation of responsibility for team building and provides a reasonable timetable and budget for construction.
Inclusive Documentation: Traditional software development requirements to view the document as a key element of the documentation. Main process method in the heavyweight division is a major project in advance (BDUF) process in which the belief that it is possible to collect all the customer requirements, in advance, before writing code.
Process orientation: The purpose of this method is to determine the process that will work well for whoever happens to be using it. This process consists of some tasks that must be performed by managers, designers, developers, testers, etc. For each of these tasks is not well-defined procedure.
Agile process concentrates on adding lightness to its processes leading to high quality of software and customer satisfaction. Few of the agile models are as follows
Extreme Programming (XP): This has evaluated out of problems raised from traditional systems. This process is known for short cycles of development, incremental planning and continuous feedback, communication leading to evolutionary designing. This method’s life cycle is divided into 6 phases i.e. Exploration, Planning, Iterations to release, Production, Maintenance and Death.
During the Exploration stage, the client creates story boards about his needs. This leads to the planning phase in which the order of priority for each user and the history of the first edition of the schedule is developed. Next in Iteration to release stage, the responsibility of development team is to create the first iteration of the architecture of the whole system then continuously integrating and testing code. Additional research and testing of the system before the system can be issued to the customer is done in the production phase. Postponed ideas and suggestions found at this stage are documented for later execution in the update releases made during the maintenance phase. At the end of phase death is near, when the customer has no more stories to be implemented and all the necessary documentation of the system is written as no more changes in the architecture, design or code is.
Our academic experts are ready and waiting to assist with any writing project you may have. From simple essay plans, through to full dissertations, you can guarantee we have a service perfectly matched to your needs.View our services
Scrum: Scrum is an iterative, incremental process of product development or managing any work. Scrum focuses on how team members should act in order to produce flexibility in a constantly changing environment. At the end of each iteration produces a set of potential features. The term “mill” is derived from the strategy in the game of rugby, which means “getting out-of-play ball back into the game with teamwork. The stages in this method are Product Backlog, Sprints, Sprint Planning Meeting, Sprint backlog and Daily Scrum.
Dynamic System Development method:
This is a mixture, and extension for rapid application development and iterative development practices. This method has five stages :
Feasibility Study: A decision is made about usage of DSDM. This decision is based on project type, organization requirement and people.
Business Study: A business study to understand the business aspect of the project. This forms the base for prototype.
Functional Model Iteration: In this phase an analysis of coding and prototypes is made. Results are used in analysis stage.
Design and build iteration: Main system is built in this stage.
Implementation: This is the final stage where the project is handed over to the user. Appropriate training is also provided.
Characteristics of agile methodologies
People oriented: All the stakeholders. i.e. customers, developers, users and end users are very important in this methodology.
Adaptive: This methodology is preferred by those who are open to change and are flexible.
Balancing Flexibility and Planning: Though planning is important, a trial and error method is followed in this approach as it is hard to predict the right things in the initial stage of software development.
Both the methodologies i.e. (agile and heavy weight) have their advantages and disadvantages. People usually use one of these methods. A Summary of difference in agile and heavyweight is shown in the following table.
There are important factors influencing the decision and selection methodology, which is suitable for different conditions. These factors can be divided into the size of the project, people and risk
A major limitation of agile methods is the size of the project. Main elements of the same are budget, duration of projects and organization of the project team. The larger unit or a larger budget, you need the larger project. Thus, requires a compilation of more demands, requirements of more people and better coordination. Heavyweight support this methodology by providing planning, documentation and processes for better communication and coordination in large groups. According to Alistair Cockburn, “fewer people are needed if the methodology used is lighter. However, more people will be needed if the heavier methodology”. The larger group also has an impact on communication in the design and performance per person. Cockburn states that the methodology is a matter of coordination and management of human communication, therefore, the level of methodology must be increased if the numbers of people increase. This makes it more difficult to use agile methods with groups larger than 40 while it emphasizes the need for usage of heavyweight methodologies. However, Ken Schwaber (one of the developers of SCRUM) argues that large groups can be broken down into small teams using the dimensions of the scrums. The project duration is another factor in the choice of methodology. Heavyweight methodology includes a lot of “wasting time” output, such as documentation, design documentation, writing, analysis etc. Therefore, it can be concluded that when time is limited, using agile development methodologies would be better.
Half of the Agile Manifesto value of dealing with the human factor. Having the skills and experienced people in the group is a key factor for agile methodologies. Supporting experts in this area is part of the team gives developers quick feedback on the impact to the user of the selection of the project. Adaptive customers are another huge factor, the customer receives the right to check progress and change the direction of software development at each iteration. Achieving this level of customer engagement makes agile methodology more attractive than a heavy process.
Organizational culture is an important factor when choosing a method. If an organization is solid, which is not adapted to the changes and has many rules and procedures it cannot be established using agile methodologies. Otherwise, if the organization is flexible, must accept the adaptability to changes in their culture, if you want to use agile methods.
The most important risk factors for software processes are criticality of the project and responsiveness to change. Agile methods are used in applications that can be built quickly and does not require a large amount of quality assurance. Critical, reliable and secure systems are better suited to a heavy methodology. If the project is critical, all requirements must be clearly defined before the development of software. Poor definition may cause more damage from undetected defects. Responding to change can be solved using agile methods. Practices set out in agile methods allow us to better serve the changes, such as their customer reviews, and short development times.
I would like to end it by saying that heavy methodology consisted of severe methods of comprehensive planning, design documentation.. Heavy thoughts that accompany them will be taken over by the agile movement not in the distant future. The need for Heavyweight approaches still prevails in large, long-lived projects that have specific security, reliability and security requirements. However, business needs to respond quickly to the environment in innovative, cost-effective and efficient manner is increasing the need to use agile methods of software development.
Cite This Work
To export a reference to this article please select a referencing stye below:
Related ServicesView all
DMCA / Removal Request
If you are the original writer of this essay and no longer wish to have your work published on UKEssays.com then please: