Analysis of conventional SDMs, their drawbacks and the current approaches

Conventional approaches for software development divide the projects into different sequential phases. In the Waterfall approach, each stage produces deliverables that are inputs to the following phase. The handing of the deliverables from one stage to another is considered a milestone in the project (Viehmeyer, 2015)

Figure 1 – shows the different sequential phases in a Waterfall approach (Powell-Morse, 2016).

Usually, different teams and departments are involved in each phase, and the project manager is responsible for keeping the project within the timeline and budget planned. The primary measure to track progress is milestones. Implementing Waterfall is relatively straightforward due to the step-by-step nature of the process (Powell-Morse, 2016).

Although Agile methodologies are taking over these traditional approaches, they still have many advantages:

  • It provides a structured organization. The Waterfall approach forces to build procedures to manage the different phases of the project, from design to testing and implementation. The structure of the project needs to be disciplined.
  • Easy to implement. As mentioned before, it is straightforward to apply, and it is well-known in the software industry.
  • Planning. It easy to set a timeline and to place a fixed budget to work on.
  • Known requirements. It works very well when the requirements are well-known and do not change throughout the implementation.

The following are the main disadvantages of using these conventional approaches to software development:

  • Design constraint. After the requirements gathering phase is done, changes are costly to implement. The Waterfall model lack adaptability across all stages of the software life cycle.
  • No user or client feedback. The user’s feedback is provided too late in the process. If something was missed or need changes, they are too expensive to implement jeopardizing the entire project.
  • Delayed testing. Most modern approaches attempt to perform testing from the beginning of the project. Conventional methods as Waterfall, the testing phase is too late in the lifecycle. This means that bugs or design flaws are going to be discovered in one of the last phases of the development process. 

Agile Software Development Methodologies – Principles and Philosophy

Agile Software methodologies were introduced to fill the gaps and overcome the challenges facing when using traditional methodologies like the Waterfall model. The benefits that Agile methodologies offer made it increasingly popular and led to widespread adoption. Agile Software methodologies are more adaptable to changes, and the planning is done every iteration rather than doing it only at the beginning of the project. Also, Agile uses an incremental and iterative approach for delivering the software. Overall, Agile is a framework, and there are several approaches to implement it. One of the approaches is Scrum.

Scrum is an agile software development methodology that aligns with the values of the agile manifesto and its principles. It is one of the most popular ways to implement agile (ReQtest, 2018). Its iterative approach allows delivering working software using iterations called sprint to provide value and satisfy the customers, and this is the first principle. Furthermore, at the beginning of each sprint, stakeholders and the team conduct a meeting to plan the development for the iteration allowing and embracing changes, another agile principle. Stakeholders are heavily involved in the project providing the requirements and feedback of the work that is being done every sprint.

Also, by the end of each iteration, the progress is measured using burndown charts that show the completed work, and there is a meeting called retrospective to discuss how the team could become more productive, one of the agile principles. If there is no constraint on the budget, Scrum allows you to iterate indefinitely.

Overview of the object-oriented methodology for software modelling in UML

The object-oriented methodology is a development strategy base on the concept that systems are a collection of reusable components interacting with each other. The main focus of the object-oriented methodology is to capture the structure and the behavior of systems into small pieces that combine data and processes. Also, it is used to improve the quality of the analysis and design because objects are reusable components.

It has the following advantages:

  • Changes in the software are not as expensive as other paradigms.
  • It promotes the reuse of components.
  • Designs are more straightforward than other paradigms.

The object-oriented approach uses Unified Modeling Language (UML) diagrams for documenting the analysis and design of the system to be developed. The main purpose of UML is to define a standard way to define and visualize the behavior of a system. It is a visual language rather than a programming language. Based on the version 2.2 UML diagrams can be classified as:

  • Structural. It shows the structure of the system. It includes components, objects, class and deployment diagrams.
  • Behavior. Shows the interaction and relationships between objects of the system. It includes use cases, state, activity and interaction diagrams.
Figure 2 – shows the structure of diagrams in UML 2.2 (GeeksforGeeks, no date)

How to adopt Agile Scrum framework and use UML modeling for a software design task

Based on Viola, 2019 there are seven steps that can be done to implement Scrum as a software development framework for any project. Also, it is fundamental to have support from leadership.

  1. Defining the scrum elements. It is fundamental to assign the different roles that scrum has to people and to define the elements such as sprint duration.
    1. Product Owner. It is responsible for the product. It has a vision of what needs to be implemented.
    1. Work team. It has to be a multifunctional and self-organized team that is going to perform the work. Typically, it is formed between four to nine people.
    1. Scrum Master. It is responsible to ensure that the team is effective. Also, it is responsible to remove any blockers.
    1. Sprint duration. It is crucial to pick the time window of each iteration. Usually is between one and four weeks depending on the complexity of the project.
  2. Prioritize a list of objectives or backlog. This list will define the requirements and the roadmap of the software to be produced.
  3. Plan the sprint. Every sprint begins with a planning meeting, to estimate the work that is going to be done during the iteration.
  4. Make work and daily meetings. These meetings should be quick, no more than fifteen minutes and provides a sense of the progress of the tasks. Usually, each member will present blockers and activities for the day.
  5. Sprint review or demonstration. After each iteration, it is fundamental to show the users what was delivered to get feedback and adjust what is necessary for the next iteration.
  6. Retrospective of the sprint. This meeting is the key to improve the work that was done during the sprint. It allows discussing within the team the things that could be done better.
  7. Immediately start the next cycle of sprints.

Regarding UML, it is fundamental to incorporate the different diagrams to document the design and behavior of the system. These diagrams can be incorporated in the design task during each iteration providing the developers and users a standard way to visualize the system functionality. Furthermore, in order to implement UML diagrams into the design, people have to be trained.

References

GeeksforGeeks (no date) Unified Modeling Language (UML) | An Introduction. Available at: https://www.geeksforgeeks.org/unified-modeling-language-uml-introduction (Accessed: 5 November 2019)

Powell-Morse, A (2016) Waterfall Model: What Is It and When Should You Use It? Available at: https://airbrake.io/blog/sdlc/waterfall-model (Accessed: 5 November 2019)

ReQtest (2018) What is Scrum and Agile? A quick guide to Agile and Scrum. Available at: https://reqtest.com/agile-blog/agile-scrum-guide/ (Accessed: 4 November 2019)

Bahill, T., & Daniels, J. (2003). Using objected‐oriented and UML tools for hardware design: A case study. Systems Engineering, 6(1), 28-48.

TutorialsPoint (no date) Object Oriented Approach. Available at: https://www.tutorialspoint.com/system_analysis_and_design/system_analysis_and_design_object_oriented_approach.htm (Accessed: 5 November 2019)

Viehmeyer, N (2015) Waterfall and why it’s not suitable for software development. Available at: https://www.boost.co.nz/blog/2015/10/waterfall-and-why-its-not-suitable-for-software-development (Accessed: 5 November 2019) Viola, P (2019) How to implement scrum in 7 steps and not die trying. Available at: https://www.hexacta.com/2019/01/21/how-to-implement-scrum-in-7-steps-and-not-die-trying/ (Accessed: 5 November 2019)

Leave a Reply

Your email address will not be published. Required fields are marked *