Software Development Methodologies - PowerPoint PPT Presentation

software development methodologies n.
Skip this Video
Loading SlideShow in 5 Seconds..
Software Development Methodologies PowerPoint Presentation
Download Presentation
Software Development Methodologies

play fullscreen
1 / 31
Software Development Methodologies
Download Presentation
Download Presentation

Software Development Methodologies

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Software Development Methodologies

  2. Software development lifecycle In the analysis phase we move from a vague description of the problem to be solved to a precise and unambiguous requirements specification. The requirements specification might be a precise, but informal description written in careful natural language text and diagrams. The requirements specification should be: • complete, • consistent, • readable by application domain experts and software developers, • independent of programming considerations. In the design phase, we move from a requirements specification to a design specification. The design specification gives the system structure. The design tasks are to: • Break the programming task into manageable parts. • Define the relationships among the parts. • Incorporate any required or appropriate pre-existing components. • Keep the design independent of implementation language and hardware details. In the implementation phase, we move from a design specification to a tested executable system. In the maintenance phase, we move from a complete "working" system to a modified system. The maintenance tasks are to: • Repair any errors in analysis, design, or implementation that have been found. • Adapt to the changes in requirements that have occurred. The cost of failure at different stages of the lifecycle

  3. Software development lifecycle These stages can be characterized and divided up in different ways, including the following: • Project planning, feasibility study: Establishes a high-level view of the intended project and determines its goals. • Systems analysis, requirements definition: Defines project goals into defined functions and operation of the intended application. Analyzes end-user information needs. • Systems design: Describes desired features and operations in detail, including screen layouts, business rules, process diagrams, pseudo code and other documentation. • Implementation: The real code is written here. • Integration and testing: Brings all the pieces together into a special testing environment, then checks for errors, bugs and interoperability. • Acceptance, installation, deployment: The final stage of initial development, where the software is put into production and runs actual business. • Maintenance: What happens during the rest of the software's life: changes, correction, additions, moves to a different computing platform and more. This, the least glamorous and perhaps most important step of all, goes on seemingly forever.

  4. Software development lifecycle (more detailed)

  5. Software development methodologies There are six more general categories/approaches, which are developed into several specific methodologies: • Waterfall: Linear framework type. • Prototyping: Iterative framework type • Incremental: Combination of linear and iterative framework type • Spiral: Combination of linear and iterative framework type • Rapid Application Development (RAD): Iterative Framework Type. • Agile Development: Based on iterative development, emphasis on teams

  6. Software development methodologies Another general classification is: • Data-centered Methodologies (e.g. DFDs and ERDs) • This approach focuses on defining the content of the data storage containersand how they are organized. • Data-centered methodologies utilize data models as the core of the system concept. • Object-oriented Methodologies (UML) • This approach attempts to balance the focus between processes and data. • The Unified Modeling Language (UML) is used to describe the system concept as a collection of objects incorporating both data and processes.

  7. Software development methodologies

  8. Waterfall development… With waterfall development- based methodologies, the analysts and users proceed sequentially from one phase to the next. Emphasis is on planning, time schedules, target dates, budgets and implementation of an entire system at one time. Tight control is maintained over the life of the project through the use of extensive written documentation, as well as through formal reviews and approval/signoff by the user and information technology management occurring at the end of most phases before beginning the next phase. • The two key advantages of waterfall development-based methodologies are: - The system requirements are identified long before programming begins.- Changes to the requirements are minimized as the project proceeds. • The two key disadvantages of waterfall development-based methodologies are: - The design must be completely specified before programming begins. - A long time elapses between the completion of the system proposal in the analysis phase and the delivery of the system.

  9. …Waterfall development

  10. Incremental development… • This methodology breaks the overall system into a series of versions that are developed sequentially. • The team categorizes the requirements into a series of versions, then the most important and fundamental requirements are bundled into the first version of the system. • The analysis phase then leads into design and implementation; however, only with the set of requirements identified for version 1. • As each version is completed, the team begins work on a new version.

  11. …Incremental development Alternatively: A general design for the entire system is performed and then the project is divided into a series of distinct subprojects.

  12. Iterative and Incremental Development

  13. Prototyping… Prototyping-based methodologies perform the analysis, design and implementation phases concurrently. All three phases are performed repeatedly in a cycle until the system is completed. A prototype (mock-up) is a smaller version of the system with a minimal amount of features. Tries to reduce project risk by breaking a project into smaller parts and providing more ease-of-change during the development process. User is involved throughout the process, which increases the likelihood of user acceptance of the final implementation. • Advantage: Provides a system for the users to interact with, even if it is not initially ready for use. • Disadvantage: Often the prototype undergoes such significant changes that many initial design decisions prove to be poor ones. There exist 2 types of prototyping: • Throw-away prototyping or Rapid Prototyping refers to the creation of a model that will eventually be discarded rather than becoming part of the finally delivered software. After preliminary requirements gathering is accomplished, a simple working model of the system is constructed to visually show the users what their requirements may look like when they are implemented into a finished system. • Evolutionary prototyping is quite different from Throwaway Prototyping. The main goal when using Evolutionary Prototyping is to build a very robust prototype in a structured manner and constantly refine it. "The reason for this is that the Evolutionary prototype, when built, forms the heart of the new system, and the improvements and further requirements will be built. When developing a system using Evolutionary Prototyping, the system is continually refined and rebuilt. "

  14. …Prototyping

  15. Spiral development… • This model of development combines the features of the prototyping model and the waterfall model. • The spiral model is intended for large, expensive and complicated projects. • Game development is an area where the spiral model is used and needed, because of the size and the constantly shifting goals of those large projects.

  16. …Spiral development… • “spiral” is used to describe the process that is followed as the development of the system takes place. • Each version of the system is carefully designed using the steps involved in the Waterfall Model • After each iteration around the spiral, progressively more complex versions of the system are built • Risk Assessment included during each phase • Should we continue or is the risk too great?

  17. …Steps of spiral development… The steps in the spiral model iteration can be generalized as follows: • The system requirements are defined in as much detail as possible. This usually involves interviewing a number of users representing all the external or internal users and other aspects of the existing system. • A preliminary design is created for the new system. This phase is the most important part of "Spiral Model". In this phase all possible (and available) alternatives, which can help in developing a cost effective project are analyzed and strategies to use them are decided. This phase has been added specially in order to identify and resolve all the possible risks in the project development. If risks indicate any kind of uncertainty in requirements, prototyping may be used to proceed with the available data and find out possible solution in order to deal with the potential changes in the requirements. • A firstprototype of the new system is constructed from the preliminary design. This is usually a scaled-down system, and represents an approximation of the characteristics of the final product. • A second prototype is evolved by a fourfold procedure: • evaluating the first prototype in terms of its strengths, weaknesses, and risks; • defining the requirements of the second prototype; • planning and designing the second prototype; • constructing and testing the second prototype.

  18. …Spiral development… The development spiral consists of four quadrants as shown in the figure on the left: Quadrant 1: Determine objectives, alternatives, and constraints. Quadrant 2: Evaluate alternatives, identify, resolve risks. Quadrant 3:Develop, verify, next-level product. Quadrant 4: Plan next phases.

  19. Agile Methods… • Agile Software Development refers to a group of software development methodologies based on iterative development, where requirements and solutions evolve through collaboration between self-organizing cross-functional teams. • The term was introduced in the year 2001. Examples are the XP (Extreme Programming) and SCRUMmethodologies.

  20. …Characteristics of Agile Methods… • Highest priority is to satisfy the customer through early and continuous delivery of valuable software. • Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage. • Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale. • Business people and developers must work together daily throughout the project. • Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done. • The most efficient and effective method of conveying information to and within a development team is face-to-face conversation. • Working software is the primary measure of progress. • Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely. • Continuous attention to technical excellence and good design enhances agility. • Simplicity - the art of maximizing the amount of work not done - is essential. • The best architectures, requirements, and designs emerge from self-organizing teams. • At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.

  21. …Agile development… Code refactoring is a "disciplined technique for restructuring an existing body of code, altering its internal structure without changing its external behavior",[1] undertaken in order to improve some of the nonfunctional attributes of the software. Advantages include improved code readability and reduced complexity to improve the maintainability of the source code, as well as a more expressive internal architecture or object model to improve extensibility. By continuously improving the design of code, we make it easier and easier to work with Test-driven development (TDD) is a software development process that relies on the repetition of a very short development cycle: first the developer writes an (initially failing) automated test case that defines a desired improvement or new function, then produces the minimum amount of code to pass that test, and finally refactors the new code to acceptable standards. Kent Beck, who is credited with having developed or 'rediscovered' the technique, stated in 2003 that TDD encourages simple designs and inspires confidence. Pair programmingis an agile software development technique in which two programmers work together at one workstation. One, the driver, writes code while the other, the observer or navigator, reviews each line of code as it is typed in. The two programmers switch roles frequently.

  22. …Limitation of Agile Methods… • Limited Support for distributed environments Face to face communication is an essential characteristic of agile processes. Development environments in which team members and customers are physically separated may not be able to accommodate the face-to-face communications advocated by agile processes. In such cases, one can approximate face-to-face communications using technologies such as video-conferencing, but these technologies are sometimes expensive and not as effective as one would hope. • Limited support for building reusable resources A case against agile processes is that they target specific problems in the software and are deficient in producing generalized solutions. • Limited support for developing safety-critical software It is said that agile quality control mechanisms like pair programming, informal reviews, refactoring, etc. are not sufficient to assure users of the safety of the final product. • Limited support for development involving large teams This is a well known limitation to agile processes. It is believed that agile process is more suitable for small collocated teams.

  23. Joint Application Development (JAD) • JAD (Joint Application Development) is a methodology that involves the client or end user in the design and development of an application, through a succession of collaborative workshopscalled JAD sessions. Chuck Morris and Tony Crawford, both of IBM, developed JAD in the late 1970s and began teaching the approach through workshops in 1980. • The JAD approach, in comparison with the more traditional practice, is thought to lead to faster development times and greater clientsatisfaction, because the client is involved throughout the development process. In comparison, in the traditional approach to systems development, the developer investigates the system requirements and develops an application, with client input consisting of a series of interviews. • A variation on JAD, rapid application development (RAD) creates an application more quickly through such strategies as using fewer formal methodologies and reusing software components.

  24. RAD (Rapid Application Development) RAD is an application development technique that incorporates the use of prototypes, iterative customization, and CASE Tools.

  25. RAD (Rapid Application Development) • Development of systems in a rapid time frameusing small teams of highly qualified, motivated and experienced staff • In certain situations, a usable 80% solution can be produced in 20% of the time that would have been required to produce a total solution. • In current times rapid application development has become a term that describes applications that can be designed and developed within 60-90 days.  • RAD is an evolution from the Spiral Model. • The main advantages of Rapid Application Development are speed and quality, where potentially the disadvantages are potentially the reduction in scalability and features. • To achieve this goal of speedy application delivery is addressed with the use of Computer Aided Software Engineering otherwise known as CASE Tools.  These focus on decreasing the time required in converting project requirements into code. • Another element used is Time Boxing, in which various extra features are pushed out to future released in order to complete a feature light version quickly. • Involves re-using software components. • Keeping review meetings and other team communication informal. • Iterations last between 1 day and 3 weeks • Uses focus groups, where users talk and developers listen. A facilitator keeps the users in focus. Sessions last about 2 hours. The facilitator creates a report afterwards. • Teams should consist of about 6 people, including both developers and full-time users of the system plus anyone else who has a stake in the requirements. • Developers chosen for RAD teams should be multi-talented people who are analysts, designers and programmers all rolled into one. • Initial meeting: JAD(Joint Application Development) MEETING: High-level end-users and designers meet in a brainstorming session to generate a rough list of initial requirements.

  26. RAD (Rapid Application Development) Rapid Application Development (RAD) is a software development methodology, which involves iterative development and the construction of prototypes. Rapid application development is a term originally used to describe a software development process introduced by James Martin in 1991. Basic principles: • Key objective is for fast development and delivery of a high quality system at a relatively low investment cost. • Attempts to reduce inherent project risk by breaking a project into smaller segments and providing more ease-of-change during the development process. • Aims to produce high quality systems quickly, primarily through the use of iterative Prototyping (at any stage of development), active user involvement, and computerized development tools. These tools may include Graphical User Interface (GUI) builders, Computer Aided Software Engineering (CASE) tools, Database Management Systems (DBMS), fourth generation programming languages, code generators, and object-oriented techniques.

  27. RAD (Rapid Application Development) • Key emphasis is on fulfilling the business need, while technological or engineering excellence is of lesser importance. • Project control involves prioritizing development and defining delivery deadlines or “timeboxes”. If the project starts to slip, emphasis is on reducing requirements to fit the timebox, not in increasing the deadline. • Generally includes Joint Application development (JAD), where users are intensely involved in system design, either through consensus building in structured workshops, or through electronically facilitated interaction. • Active user involvement is imperative. • Iteratively produces production software, as opposed to a throwaway prototype. • Produces documentation necessary to facilitate future development and maintenance. • Standard systems analysis and design techniques can be fitted into this framework.

  28. Othermethodologies • Unified Process (UP) is an iterative software development methodology approach, based on UML. UP organizes the development of software into four phases, each consisting of one or more executable iterations of the software at that stage of development: Inception, Elaboration, Construction, and Guidelines. There are a number of tools and products available designed to facilitate UP implementation. One of the more popular versions of UP is the Rational Unified Process(RUP).

  29. Comparison of methods, when to apply Poor Good Excellent

  30. Comparison of methods, when to apply

  31. Comparison of methods From <>