1/50
Comprehensive vocabulary flashcards covering key definitions, principles, lifecycle models, testing stages, and team roles from Chapters 1 and 2 of Principles of Software Engineering.
Software
Computer programs and associated documentation that may be developed for a particular customer or for a general market.
Software Engineering
An engineering discipline concerned with all aspects of professional software production from early system specification through to maintaining the system after it has gone into use.
Software Costs Breakdown
Roughly 60% of software engineering costs are development costs, while 40% are testing costs; for custom software, evolution costs often exceed development costs.
Generic Products
Stand-alone software systems marketed and sold to any customer who wishes to buy them, where the product specification is owned and decided by the software developer.
Customized Products
Software commissioned by a specific customer to meet their own unique needs, where the product specification and change decisions are owned by the customer.
Maintainability
An essential attribute of good software dictating that software should be written so it can evolve to meet the changing needs of customers in an evolving business environment.
Dependability and Security
An essential attribute of good software encompassing reliability, security, and safety; it ensures the software does not cause physical or economic damage during system failure and prevents malicious access.
Efficiency
An essential attribute of good software requiring that the software does not make wasteful use of system resources, including memory utilization, processor cycles, and responsiveness.
Acceptability
An essential attribute requiring software to be acceptable to its intended users, meaning it must be understandable, usable, and compatible with other systems they operate.
Software Specification
The fundamental software process activity where customers and software engineers define the software to be produced along with the constraints on its operation.
Software Validation
The fundamental software process activity where the software is checked and tested to ensure that it conforms to its specification and meets customer requirements.
Software Evolution
The fundamental software process activity where the software is modified to reflect changing customer and market requirements.
Embedded Control Systems
Software control systems that control and manage hardware devices, numerically representing the most common type of software system.
Confidentiality (Ethics)
An ethical responsibility where software engineers must normally respect the confidentiality of their employers or clients regardless of whether a formal agreement was signed.
Competence (Ethics)
An ethical standard stating that software engineers should not misrepresent their qualifications or knowingly accept work that is outwith their competence.
Computer Misuse
The unethical use of technical skills to compromise others' computers, ranging from game playing on an employer's machine to the dissemination of viruses.
ACM/IEEE Code of Ethics
A standard code of practice containing eight principles governing the professional behavior and decisions made by software engineers, managers, educators, and students.
Software Process
A structured set of activities required to develop a software system, involving specification, design and implementation, validation, and evolution.
Process (ISO 9000:2015)
A set of interrelated or interacting activities which use inputs to deliver an intended result.
Activity (ISO/IEC 12207:2008)
A set of cohesive tasks within a software process.
Task (ISO/IEC 12207:2008)
A required, recommended, or permissible action intended to contribute to the achievement of one or more outcomes of a process; the smallest actionable unit of work.
Procedure (ISO 9000:2015)
The specified way to carry out an activity or a process.

Product (Software Process)
An outcome or deliverable produced by a process activity, such as a specification document, design model, source code, or testing report.
Role (Software Process)
A definition of the responsibilities assigned to people involved in the development process, identifying who is responsible for carrying out a particular activity or task.
Pre-condition
A statement of conditions that must evaluate to true before an activity can begin.
Post-condition
A statement describing the expected state that must be true after an activity has been completed successfully.
Plan-Driven Development
A software development approach where all process activities are planned in advance, requirements are identified upfront, and progress is measured against that plan.
Waterfall Model
A classical, sequential plan-driven lifecycle model described by Winston W. Royce (1970) that requires completing separate phases in order from requirements to maintenance.
V-Model
An extension of the linear lifecycle model, first described by Boehm (1979), that uses a V-shaped structure to map each development phase directly to an opposing verification and validation phase.

Incremental Development
A development approach that interleaves specification, development, and validation, delivering the software progressively in several smaller functional parts called increments.
Staged Delivery Model
A variant of the incremental model based on the sequential construction of only one part of the project at a time.
Parallel Development Model
An incremental development variant where different subsystems are built simultaneously by multiple teams to reduce overall Time to Market (TTM).
Integration and Configuration
A development model based on software reuse where systems are assembled and configured from existing COTS packages, components, or web services.

Spiral Model
A risk-oriented lifecycle model that breaks a project into miniprojects across repeated cycles (spirals), evaluating risks before each iteration and terminating like a waterfall model.
Rational Unified Process (RUP)
A modern process framework described as serial in the large and iterative in the small, structured across four phases: Inception, Elaboration, Construction, and Transition.
Agile Development
A development methodology that emphasizes iterative development, frequent software delivery, close collaboration with users, and adapting to changing requirements over extensive documentation.
Scrum
A popular agile framework that organizes work into short cycles termed sprints, utilizing defined roles, events, and artifacts to guide iterative development.

Sprint
The basic development cycle in the standard Scrum framework, having a recommended duration of less than one month and never exceeding 6 weeks.
Daily Scrum
A stand-up meeting with a maximum duration of 15 minutes where each team member reports what they accomplished, what they plan to do, and any impediments.
Product Backlog
An evolving, prioritized list of product requirements maintained and controlled by the Product Owner without excessive upfront detail.
Sprint Backlog
A set of priority requirements committed by the team for a specific sprint, broken down with enough detail to execute.
Rapid Application Development (RAD)
A rapid software development lifecycle model progressing sequentially through Requirements Planning, User Design (interactive prototyping cycles), Construction, and Cutover.

Software Prototype
An initial, simplified version of a software system built to demonstrate concepts, experiment with design options, and elicit user requirements.
Throwaway Prototyping
A prototyping technique where a prototype is constructed solely to clarify and confirm requirements, and is discarded once the real system is developed from scratch.

Evolutionary Prototyping
A prototyping technique where a basic prototype is continuously improved and expanded through user feedback across multiple iterations until it becomes the final deliverable system.
Component Testing
The stage of testing where individual units, functions, or modules of a system are tested independently to confirm they work correctly in isolation.
System Testing
The testing stage where integrated modules are tested as a complete whole to verify that all components work together and check emergent system properties.
Customer Testing
The validation stage (also known as Acceptance Testing) where client data is used by end users to evaluate the software and ensure it meets operational requirements before final acceptance.
Change Anticipation
A strategy to minimize the cost of rework by incorporating activities (such as prototyping) that identify potential system changes before significant development effort is expended.
Change Tolerance
A design strategy where a software process accommodates changes at relatively low cost, typically by implementing changes within unbuilt increments of an incremental process.
Pair Programming
An agile software development practice where two programmers work side by side at a single computer, sliding the keyboard and mouse back and forth to write all production code.