Agile software development methodologies: Modern Software Development Process

August 25, 2021

iauro Team

Contributing immensely to the global software solutions ecosystem. DevOps | Microservices | Microfrontend | DesignThinking LinkedIn
Agile methodology is used as an alternative to the traditional document-based project management, heavy software development process, to help businesses respond to unpredictability and guide an iterative and people-centered approach to the software development process.
The goal of the ASD methodology is to reduce overhead costs in the software development process, as well as create small chunks of project progress, as well as the ability to quickly respond to changing requirements without undue rework. The ASD methodology assumes the need for flexibility and applies the level of desirability to the finished product. In particular, this process helps you keep your code simple by testing frequently and delivering functional parts of your application as soon as they are ready. There are 15 such methodologies and 6 processes in total. Shocked? There are quite a few of them.
Manifesto of all agile processes:
1
People and interactions are more important than processes and tools
2
software is more important than exhaustive documentation
3
Collaborating with customers instead of contract negotiations
4
Reacting to changes according to plan Popular processes: Scrum: Let’s quickly check Scrum – it is the term “rugby” (sport).

 

The literal meaning of this word:

“Ordered the formation of players used to restart a game in which the attacking teams line up with their arms crossed and their heads down.” This is what it looks like. Each participant in the fight has a specific role. Scrum is the most popular process in the agile software development community because of its simplicity, proven performance, and ability to act as a wrapper around various engineering practices promoted by other agile methodologies. Its focus is on managing iterative development rather than specific agile development methods. The three phases in Scrum are:

  • The inception phase is the overall plan phase in which you set the overall project goals and develop the software architecture.
  • This is followed by a series of sprint cycles, each developing the system.
  • The project closure phase completes the project, completes the necessary documentation such as the system reference framework and user manuals, and evaluates the lessons learned from the project. Using the Scrum methodology, the Product Owner works closely with the team to define and prioritize the functionality of the system in the form of a Product Backlog.

The product backlog is comprised of features, bug fixes, non-functional requirements, and so on — everything that needs to be done to successfully deliver a working software system. With priorities determined by the product owner, cross-functional teams evaluate and subscribe to deliver “Potentially Shippable Pieces” of software during sequential sprints, typically lasting 30 days. Once the sprint product backlog is committed, no additional functionality can be added to the sprint except by the team.

After a sprint is delivered, the product backlog is analyzed and prioritized as needed, and the next set of features is selected for the next sprint. Lean Manufacturing: Lean software development is based on the core principle of eliminating unnecessary actions and increasing customer value. He focuses the team on delivering Value to the customer and on the effectiveness of the Value Stream, the mechanisms that deliver that Value.

 

7 Key Principles of Lean Software Development:

1. Eliminate Waste:

Learn to see and reduce waste, such as:

  • Partly done
  • unnecessary code and functionality
  • Extra documentation
  • defects
  • I’m waiting for information
  • Unnecessary management activities
    • Additional features
    • Task switching and process
    • Slow communication

    2. Leveraging Learning

    This is the best way to improve your software development environment. Run tests as soon as the code is written to stop the growth of defects. Try different ideas by writing and writing code instead of documentation.

    Present the screen to the end-user and get their opinion to simplify the process of collecting requirements take 3 of the best tools and rate them increase customer feedback for further improvement Implement a set-based development process that focuses on communicating the constraints of a future solution.
     

    3. Decide as late as possible

    Better results should be achieved using an options-based approach. Delay a decision until it is made based on facts rather than predictions, but provides the necessary flexibility to decide at a later stage. Postpone fulfilling your obligations until the client is better aware of their needs remain flexible until the uncertainty is removed because you cannot predict the future

     

    4. Deliver as quickly as possible:

    The sooner a defect-free final product is delivered, the faster feedback can be obtained and incorporated into the next iteration.
    Follow the Pull system, which allows people to determine for themselves what needs to be done, and the work becomes independent.
    The JIT approach allows decisions to be made in real-time rather than in advance Queuing theory to reduce cycle times.

    By releasing a small package of work that allows you to evenly distribute it across the team
     

    5. Empowering the team:

    Empower the people who do the work to make decisions
    let the team develop their work procedures, commitments and avoid micromanagement
    Create a sense of purpose in your work. People care more about the goal.
    Give the developer access to clients

     

    6. Integrity construction:

    Two types of integrity, perceived and conceptual.
    Perception is influenced by the entire customer experience in the system The individual components of the concept system work well together as a coherent whole with a balance between flexibility, maintainability, efficiency, and responsiveness.

    Refactoring is one of the healthy ways to create a coherent architecture. It retains simplicity, clarity, ease of use, and no code repetition or additional functionality.
     

    7. A vision of the whole:

    A software system is not just the sum of its small parts, it is a product of these interactions, and when systems start to fail, more consistent rules are usually set, and this process can cure one symptom, but not the root cause. It will become increasingly difficult to keep up with changing needs. Kanban: It emphasizes consistent delivery without overwhelming the development team. Like Scrum, Kanban is a process designed to help teams work together more effectively.

    Kanban is based on 3 basic principles:

    1. Visualize what you are doing today (workflow): seeing all the elements in the context of each other can be very informative
    2. Limit the amount of work in progress (WIP): it helps balance the approach based on a thread so that teams don’t start and do too much work at once
    3. Improve the flow: when something is complete, the next highest backlog item is included in the game

    Extreme Programming (XP):

    The original XP recipe is based on four simple values ​​- simplicity, communication, feedback, and courage – and twelve assistive techniques:

    • The Planning Game: Business and DevOps Services Company to maximize business value as quickly as possible Maybe. The planning game comes in different sizes, but the basic rules are always the same: The company offers a list of desirable features for the system. Each function is recorded as a user story, which gives the function a name and describes in general terms what is required.Development estimates how much effort each story will require, and how much effort the team can put in in a given amount of time.The business then decides which stories to deploy, in which order, and when and how often to release a production version of the system.
    • Minor Versions: A minimum useful set of features that deliver business value are primarily developed. System releases are frequent and gradually add functionality to the first release.
    • Customer Acceptance Tests: Also known as functional tests, assigned by the customer to verify that the system as a whole function as specified. Acceptance tests usually test the entire system or a large portion of it. When all acceptance tests for a given user story are passed, that story is complete. At the very least, an acceptance test can consist of a script of user interface actions and expected results that a person can run.
      Ideally, acceptance testing should be automated using either a unit test framework or a separate acceptance test framework.
    • Simple design: there is enough design to meet current requirements and nothing more.
    • Pair programming: Developers work in pairs, checking each other’s work and providing support to always do their job well.
    • Test Driven Development: An automated unit testing framework is used to write tests for a new piece of functionality before that functionality is implemented.
    • Refactoring: All developers are expected to continually refactor their code as soon as possible improvements to the code are found. This makes the code simple and maintainable.
    • Continuous Integration: Once a task is completed, it is integrated into the entire system. After any such integration, all unit tests on the system should pass.
    • Shared Code Ownership: Developers pairs work on all areas of the system so that no islands of experience arise and all developers take responsibility for all the code. Anyone can change anything.
    • Coding standards: everyone uses the same standards. Ideally, looking at it, you cannot tell which team member touched a particular piece of code.
    • Metaphor: Each project has an organizational structure that helps new people to contribute quickly and also ensures consistent class and method names.
    • Sustainable Pace: Projects do not follow “critical time” in XP because development cycles are short continuous integration cycles that occur more frequently. On the other hand, it gives better performance and more creativity from the developers. Crystal: Crystal includes teamwork, communication, and simplicity, as well as reflection for frequent process adjustments and improvements.
      Crystal promotes early and frequent delivery of working software, active user engagement, adaptability, and the elimination of red tape or distractions.
    Dynamic System Development Method (DSDM): It primarily deals with business needs/values, active user participation, empowered teams, frequent delivery, integrated testing, and stakeholder engagement. DSDM specifically refers to suitability for business purposes.

    DSDM projects are prioritized using MoSCoW rules:

    M
    Must have requirements
    S
    Must have, if at all possible
    C
    May have, but not critical
    W
    There won’t be this time, but potentially later Function driver development: FDD is a model-driven, short iterative process. It starts by defining the overall shape of the model. It then continues with a series of two-week design-by-function, build-by-function iterations. Possibilities are small, the results are “useful in the eyes of the client.” FDD designs the rest of the development process around feature delivery using the following eight techniques.
    1. Modeling a domain object: it consists of researching and explaining the domain of the problem being solved. The resulting model provides a common basis for adding functionality.

    2. Design by feature: Any feature that is too complex to implement in two weeks is further broken down into smaller features until each sub-task is small enough to be called a feature. This makes it easier to provide the correct functionality and expand or modify the system.

    3. Component / Class Ownership: Owning an individual class means that individual parts or groups of code are assigned to the same owner. The owner is responsible for the consistency, performance, and conceptual integrity of the class.

    4. Functional Teams: Functional Teams are a small, dynamically formed team that develops a small event. In this way, multiple minds are always applied to each design decision, and also multiple design options are always evaluated before choosing one.

    5. Inspections: carried out to ensure good quality design and code, primarily by detecting defects.

    6. Configuration Management: Helps identify the source code for all features that have been completed to date and maintains a history of class changes as functional groups improve.

    7. Regular Builds: Regular builds ensure there is always an up-to-date system to showcase to the customer and help catch source code integration errors for features early on.

    8. Visibility of progress and results: Frequent, relevant, and accurate progress reports at all levels inside and outside the project, based on the work performed, help managers to properly manage the project.

    0 Comments

    Submit a Comment

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

    Subscribe for updates