CS302: Software Engineering

2a. Summarize the software development life-cycle (SDLC)

• What is a software development life-cycle?
• How do methods and methodologies pertain to life-cycles?
• What is a methodology?
• What is a method?
• Why is the period from 1965 to 1985 in the history of computing called the Software Crisis?
• Why do we have methods and methodologies?
• What are the names of the life-cycle models?
• How do life-cycle models support decomposition and composition?

A software life-cycle (SLC) is a model that covers the entire period of a software system from beginning to end (or "retirement"). A SLC has two main parts: Development (SDLC) and Maintenance. These models are primarily software project management tools. They serve as frameworks for identifying and organizing project work products and activities and specifying the sequencing and repetition of activities performed. 

An SDLC identifies development activities (process work breakdown) and project work products (product work breakdown). Methods and methodologies guide how to perform the activities and create the representations, or forms, of the work products. Using an object-orientation method will guide you in performing the analysis to identify classes and objects and specify the requirements with use cases.

Terms used in discussing software engineering are often informal and used as synonyms for other terms with similar but different meanings. For example, "method" and "methodology" are often used as synonyms. However, a method is a tool for performing the steps of a process, while methodology refers to the reasons or justification for using the method. The methodology in software engineering often implies a collection of related methods and tools. For example, an object-oriented methodology is an integrated collection of object-oriented requirements, design, and programming methods and tools.

Software engineering was born during the "software crisis" of 1965-1985. Software methods were one response to the issues of that period. Driven by software development issues and challenges, methods, and methodologies guide building representations and models that support the transition from the problem to an effective and efficient software solution.

You may have heard of the waterfall life-cycle, the most popular early sequential SDLC model. It eventually evolved into an iterative SDLC. As experience in using SDLCs increased and new programming language features emerged, developers introduced newer SDLCs. These include Spiral and Agile. The methodology focuses on the phase methods to create the phase product, and the model focuses on the product built by the methods. 

An SDLC usually has levels or phases of abstraction: analysis, design, implementation, and test phases. The sequencing of SDLCs usually begins with decomposition (in the problem space) via early phases and proceeds with composition (in the solution space) via the latter phases. Composition is often called test, integration, or synthesis. Decomposition is addressed by methods for analysis and design and composition by methods for implementation, integration, and test. The decomposition and composition paradigm will appear again in sections on models for the SDLC phases.

To review, see:

• Software Development Approaches
• Software Development Models
• Introduction to Software Systems
• Software Development Life-Cycle Methodologies
• Software Engineering Methodology

2b. Compare categories of life-cycle models, such as waterfall, incremental, and iterative models

• Why do you think there are categories of life-cycle models?
• What is the key difference between the categories of SDLCs?

Categories of life-cycle models are sequential or waterfall, iterative, and incremental. The earliest life-cycle models were sequential models. These models present a linear path from requirements to a desired system. They work well in an appropriate context: if the requirements are frozen, each phase catches errors made in the previous phase, and the application is well understood. Sequential SDLCs provide a large body of experience identifying their strengths and weaknesses.

Further, as the scope of applications expanded to larger and more complex systems, the risks of a linear sequential model increased. New applications are usually poorly understood, lack fixed requirements, have more development problems, and are subject to frequent change. The essential problem is a change caused by an error or a new specification. To mitigate risk, a life-cycle model must quickly catch errors, identify changes, and repeat phase activities. The development process introduced early implementation (prototyping and spiral) and iteration. The team developed and released the software in stages or cycles until the completion of software development. 

Moreover, we decomposed requirements into smaller, independent modules that we could prioritize and develop concurrently to address complexity and achieve faster implementation. Thus, addressing requirements in increments - earlier and faster, enabled building the software incrementally until the software development was complete. Iterative and incremental both improve software quality; iterative by developing multiple software releases, each improving the software solution; incremental by developing a subsystem solution for each requirements module, each adding features until the software development is complete. 

We have mentioned activities and phase work products (documentation or prototype software). In SDLCs, "who" refers to roles and stakeholders, but only at a group or team level and not at a task or individual level. For SDLCs, we can consider the software engineering team and interacting teams (like system engineering), project management, and customers. "What" refers to the phases, work products, and processes. "When" refers to the ordering of the phases and activities - sequential, concurrent, or iterative, and the start and end of a phase (for example, does coding appear late or early in the development cycle; do the two phases overlap, or are they performed in parallel?). "Where" refers to the location of the activities. "Why" refers to the need or problem that an SDLC addresses. "How" is more applicable to the methods and procedures used to perform the activities, which an SDLC does not usually specify. Each of the pronouns, except for "how", identifies a characteristic of an SDLC.

Using these as characteristics, we can identify two key differences between sequential, on the one hand, and iterative and incremental SDLCs, on the other hand. These differences are "when coding is performed" and the ability to repeat or redo parts of the development as needed early on. Coding appears relatively late in a sequential SDLC but early in an iterative SDLC (as the prototype) and early in an incremental SDLC (as the implementation of a high-priority requirements module. In a sequential SDLC, coding occurs during the coding and testing phases, and we may not catch errors in a sequential SDLC until coding and testing. Sequential SDLCs have the capability for repetition only back to the preceding phase. Iterative and incremental SDLCs can prototype areas with the greatest risk and even build a prototype early in the development cycle. 

To review, see Software Development Models and Introduction to Software Engineering Methodologies.

2c. Describe the differences between software development phases, activities, and deliverables

• How is a software system developed?

Software development phases, activities, and deliverables are elements of an SDLC, a model for planning, managing, and building a software system. The SDLC model organizes the development as a set of phases, including requirements, design, code, and test phases, which evolve a requirements model of a problem into a software system model that satisfies the requirements and, thus, solves the problem and is the software system delivered to the customer. Each phase consists of activities that create artifacts that comprise the phase model and produce a phase product (an artifact delivered to the customer) that is the input to the next phase. 

To review, see Introduction to Software Systems.

2d. List different roles that professionals such as system analysts, developers, and project managers play in software development processes

• What roles and responsibilities could the software engineering team undertake on a software development project?
• What responsibilities might be assigned to external teams?

We assign many roles and responsibilities to a software development project, including technical, administrative, and management, representing the organization, the project, and the project teams. Technical roles are systems, hardware, software, human factors, and process engineering. Administrative roles are hiring, training, cost, and schedule. Management roles are at the enterprise project and team level. Teams correspond to the project and phase activities, such as requirements, design, code, test, risk, measurement, configuration management, quality, and process improvement. 

Furthermore, representatives of other teams working on related or interfaced systems, or at the enterprise or customer levels, also play a part.

To review, see Introduction to Software Systems.

2e. Explain the major methodologies and processes in software engineering, such as Agile, Lean, Spiral, and Unified

• How do we summarize the major methodologies and software development processes?

Spiral is an evolutionary model framework that produces short life-cycle incremental releases (concept, new, enhancement, maintenance) by iterating a linear sequential model (planning, risk, engineering, construction, evaluation).

Unified is an iterative methodology based on UML with four phases, each producing an executable software release at that development phase. 

Agile is an iterative model where each incremental release produces evolving requirements and solutions by self-organizing cross-functional teams.

Lean is an Agile methodology that maximizes software development efficiency by minimizing waste, reducing costs, streaming processes, delivering maximum value to end-users quickly, and maximizing effectiveness by increasing learning and authorizing the development to make decisions.

To review, see Software Development Life-Cycle Methodologies.

Unit 2 Vocabulary

This vocabulary list includes terms you must know to complete the final exam successfully.

• Agile
• composition
• decomposition
• Lean
• method
• methodology
• phases
• prototype
• software life-cycle (SLC)
• Spiral
• Unified
• waterfall