Software Engineering

Discover how the software engineering course presents concepts with illustrations, animations, and examples, provides pdfs and video resources, and supports flexible viewing at 1.5x or 2x.

Software engineering follows a systematic engineering approach to software development. The unit covers the software development lifecycle, software development models, software processes, and Purdue techniques.

Explore the software development lifecycle, or SDLC, and its six to eight phases from planning and analysis to maintenance, with coding, testing and integration, designing, and deployment as core steps.

Explore the software development lifecycle by detailing initiation, requirements planning, design with data flow diagrams and flowcharts, coding with APIs, testing, release to playstore, and maintenance.

Illustrate the software development life cycle with a shopping app example, detailing requirements gathering, feasibility, planning, design prototypes, development with api libraries, testing, deployment, and maintenance.

Explore the waterfall model, a linear software engineering approach with phases: analysis, requirements, design, development, testing, integration, and implementation.

Explore how software development models provide a framework to plan and execute software lifecycles, applying coding and testing across models such as waterfall, iterative waterfall, rad, spider, prototype, and incremental.

The integrated waterfall model adds feedback loops to each phase, except analysis, but maintains no parallelism and single-phase execution, enabling cost-effective, iterative corrections with limited early customer deliveries.

Explore the prototype model, a throwaway-and-iterate approach that quick-designs a prototype for customer feedback, enabling early delivery and flexible design, but higher cost and confusion for uncertain clients.

Explore the incremental model, a successive virgin approach that divides requirements into versions, delivering a basic library module first, then add features like sign up and payments.

The spiral model cycles four phases—objectives and constraints, risk analysis, development, and next-iteration planning—using radius and angular dimension to show progress and cost, highlighting its flexibility.

Explore rapid application development by leveraging concurrent prototypes, modeling (business, data, process, application), Fuji technique automated code generation, and iterative unit and system testing.

Identify four core software processes: specification, development, validation, and evolution—and their roles in requirements, coding, testing, and maintenance. See how updates and releases respond to changing customer needs and market requirements.

The v-shaped model directs verification downward and validation upward, with unit, integration, system, and acceptance testing. It offers proactive error tracking but is rigid and hard to change.

Discover how fourth generation techniques use 4G languages to specify software characteristics and automatically generate source code, streamlining data manipulation, screen interaction, and report generation.

Compare software lifecycle models by formal versus informal and sequential versus evolutionary, noting waterfall and V-model as sequential, while spiral and agile methods like XP and Scrum are iterative.

Examine three key factors—size, cost, and quality—and how they shape software size categories, drive cost, and influence overall software quality.

Explain physical versus logical lines of code, how statements, comments, and declarations are counted, and contrast LLC and DC delivery source instructions, noting generated code and included files exclusions.

Classify software by size into organic, semi-detached, and embedded, from small application software to large system level software such as operating systems, with code size ranges guiding cost estimations.

Examines the evolving distribution of software and hardware costs, initially hardware costly, from 1955 to 1985, highlighting the shift to software development and maintenance.

this lecture explains how development effort, time, and complexity shape software size, and reviews size categories from trivial to extremely large, with effort distribution, cost implications, and lines of code.

Measure effort as labor invested in person months (people times months). Define development time as the total months needed to develop the software.

Compare two software size measures: lines of code and functional point analysis. LC counts total lines, while FP measures functionality via external/internal inputs and logical files, focusing on data flow.

This lecture identifies the cost factors in software development, including programmer ability, product complexity, size, available time, and required specifications. It outlines software classes (organic, semi-detached, embedded) and their complexities.

Navigate management issues in software engineering by organizing and monitoring projects, ensuring communication and customer interaction, and applying cost estimation, resource allocation, budgeting, and quality assurance.

Learn to estimate software cost using empirical, heuristic, and analytical methods, and explore Delphi, expert judgment, the Kokomo model, and Halstead's approach.

Develop quality and productivity by focusing on endogenous ability, team communication, management, product complexity, technology level, reliability, problem understanding, time, goals, training, and resources.

Explore the basic COCOMO model, including how effort, development time, average staff, and productivity are estimated from KLOC using type-specific constants, illustrated with a semi-detached example.

Explore the intermediate Cocomo model, extending the basic Cocomo with 15 cost drivers and the effort adjustment factor (eaf) to estimate effort and staffing for embedded system projects.

Apply advanced cocomo across all development phases to derive the effort adjustment factor from 15 cost drivers and compute total effort and development time.

Estimate software staffing using the Norden curve to identify peak efficiency and plan teams. Learn to compute full-time software personnel from programmer months and development time.

Explore non-technical and technical factors that influence maintenance costs, including staff, stability, lifetime, external environment, hardware, module independence, language, style, validation, documentation, and configuration management.

Master requirement engineering by learning how to elicit, analyze, validate, and document functional and non functional requirements, and prevent exponential error propagation through early, complete, and pertinent problem analysis.

Describe the software requirements specification as the document outlining what the software will do and how it will perform, including functional, nonfunctional, user, and system requirements.

Ensure the SRS document remains correct, complete, and consistent, with unambiguous, testable statements. Build for modifyability, verifiability, and design independence, while providing the right level of abstraction.

Explore formal specification as a precise alternative to informal requirements, using algebraic and model-based notations to declare a system's behavior with concise, unambiguous language.

Explore algebraic and model based formal techniques for interfaces, state, and behavior; compare property oriented and behavior oriented approaches, and preview Z notation, VM, DMP, CSP, and Petri nets.

Explore software testing as a core part of the software development lifecycle, evaluating and verifying that an application behaves as intended, and identifying errors through static and dynamic testing.

Compare static and dynamic testing in software engineering by reviewing artifacts and preventing defects before deployment, then executing code to validate functionality and uncover issues after deployment.

Explore four types of software review: informal review, walkthrough, peer review, and inspection, and how formality rises from early defect detection to formal approval.

Explore static analysis that identifies dead code, undefined or unused variables, and security vulnerabilities using data flow and control flow analyses and psychosomatic complexity.

Learn cyclomatic complexity as static analysis of a program’s control flow, using edges, nodes, and connected components to compute M = E - N + 2P and reveal independent parts.

Master dynamic black box testing by evaluating inputs and outputs without code access. Identify features, define domain boundary inputs, and generate and apply test cases, manually or with a model.

Explore white box testing that probes the internal structure and coding behavior with automated tools, covering statements, branches, conditions, and modified condition and decision coverage and data flow coverage.

Explore testing granularity across unit, integration, and system testing, and trace how developer testing, alpha testing, beta testing, and end user testing shape product quality and assurance.

Explore software quality by examining its definition as standard of excellence, fitness of purpose, correctness, and efficiency, and identify the factors that affect software quality.

Unpack the software quality factors model, categorizing 11 factors into operation, revision, and translation, and covering correctness, reliability, efficiency, integrity, usability, maintainability, flexibility, testability, reusability, interoperability, and portability.

Develop quality software by implementing a software quality assurance management plan, checkpoints, and a multi testing strategy, while measuring impact of changes and fostering collaborative team relations.

Master the quality control process, planning, doing, checkpoints, and acting, to verify parameters meet quality goals and continually improve software quality, and contrast it with quality assurance.

Quality management coordinates customer-focused processes for continuous improvement, while quality assurance ensures requirements are met and quality control, a subset of QA, applies exact measures to guarantee the product.

Explore ISO, the international organization that develops and promotes global standards. See how the ISO 9000 family supports quality management and certification.

Explore ISO 9001 within the quality management system framework, demonstrating the ability to consistently deliver products meeting customer and regulatory requirements and driving continual improvement to boost customer satisfaction.

Explore ISO 9126, an international standard for software quality, detailing the quality model, external and internal matrices, and quality in use, with factors like maintainability, portability, reliability, functionality, and usability.

The capability maturity model is a framework, not a software process model, for analyzing how organizations develop software. It defines five levels—from initial to optimizing—that guide process maturity.

Adopt total quality management to improve quality and performance across all functions and processes, delivering quality service that exceeds customer expectations through the plan-do-check-act cycle and data-driven decisions.

Explore the eight principles of total quality management, including customer satisfaction, total involvement, process focus, integrated systems, strategic and systematic approaches, continual improvement, effective communication, and fact-based decision making.

Six Sigma follows two phases: identify and eliminate defects to reduce variation and improve quality by applying define, measure, analyze, improve, and control steps.

Define risk in software engineering as a not-yet-happened problem that could affect cost, schedule, technical success, or quality, and note that risk types and management are explored next.

Identify, analyze, plan, control, and review risks to keep projects on track. Classify risks into project, technical, and business, and manage known, predictable, and unpredictable risks.