Revision approach
- Connected engineering workflow
- Requirements → models → design → testing
- Blueprint: six items
- Additional management, architecture and testing concepts
👁 Full explanation
Apply requirements, models, design and testing as one connected engineering workflow. The official blueprint allocates six items; this chapter covers software development, management, architecture and testing. - Scenario classification before choice
- Process, requirement type, model, test level
- Overlapping broad labels
👁 Full explanation
Classify the actual scenario before choosing a process, requirement type, model or test level. Broad labels often overlap. - Use-case-to-test practice
- Use case with exception flow
- Boundary/control/entity objects
- Service contract
- Tests derived from obligations
👁 Full explanation
Write one use case with an exception flow, derive boundary/control/entity objects and a service contract, then derive tests from those obligations. - Dependency-network calculations before choices
- Missing-context qualifications
- Weak keys require scrutiny
👁 Full explanation
Draw dependency networks and calculate times before inspecting choices; state any missing assumptions.
SE01
Engineering processes and work products
[Exam Focus]- Software engineering and process
- Systematic development, operation, maintenance
- Product: executable code plus artifacts
- Requirements, designs, test assets
- Configuration and user documentation
- Process: activities, ordering, roles, products
- Entry/exit conditions
- Specification → design/implementation → validation → evolution
👁 Full explanation
Software engineering applies systematic methods to development, operation and maintenance. A software product includes executable code and relevant requirements, designs, test assets, configuration and user documentation. A process defines activities, ordering, roles, products and entry/exit conditions. Its four broad activities are specification, design/implementation, validation and evolution. - Decomposition and programming approaches
- Procedural: functions
- Object oriented: state/behavior objects
- Either iterative or sequential
- OOP doesn't guarantee shorter projects
- Reuse, encapsulation, consistent models
- Reduced duplication, easier change
- Poor object design still complex
- Functional: function evaluation, controlled side effects
- Event-driven: reacts to events
👁 Full explanation
Procedural decomposition organizes functions; object oriented decomposition organizes objects with state and behavior. Either can use iterative or sequential development. OOP does not automatically shorten every project. Reuse, encapsulation and consistent models can reduce duplication and ease change; poor object design can still be complex. Functional programming emphasizes function evaluation and controlled side effects; event-driven programs react to events.
8 related practice questions
Blueprint: SE-LO1 · Note references: SE-M, SE-N, SE-G
- Software engineering and process
SE02
Lifecycle and process selection
[Exam Focus]- Lifecycle phases and design levels
- Requirements → design → implementation → testing
- Deployment → maintenance
- Analysis: clarify problem
- System design: architecture
- Object/detail design: interfaces, algorithms
- Implementation: code
- Testing: behavior evaluation
- Deployment: into service
- Activities overlap and repeat
👁 Full explanation
A common lifecycle names requirements, design, implementation, testing, deployment and maintenance. Analysis clarifies the problem; system design chooses architecture; object/detail design specifies interfaces and algorithms; implementation writes code; testing evaluates behavior; deployment puts it into service. These activities may overlap and repeat. - Contextual process selection
- Requirement stability and technical risk
- Delivery urgency, stakeholder availability
- Team skills and assurance needs
- Inexperience alone insufficient
- Risk-driven cycle, prototype, planned stages
- Choice depends on actual uncertainty
- Testing/documentation required in every process
👁 Full explanation
Select a process using requirement stability, technical risk, delivery urgency, stakeholder availability, team skills and assurance needs. “Team has little experience” alone does not uniquely identify a process. A risk-driven cycle, prototype or carefully planned staged process may each help, depending on the actual uncertainty. No process eliminates the need for testing or documentation.
4 related practice questions
Blueprint: SE-LO1 · Note references: SE-M, SE-N, SE-G
- Lifecycle phases and design levels
SE03
Waterfall and V-model
- Classical and modified waterfall
- Planned phases, reviewed deliverables
- Stable understood requirements, familiar technology
- Late feedback raises change cost
- Controlled revisiting remains possible
- Modified waterfall: explicit feedback
- Milestone visibility
- Risk of frozen incorrect assumptions
👁 Full explanation
Classical waterfall separates planned phases with reviewed deliverables. It fits well-understood, stable requirements and familiar technology; late feedback makes changes costly. It does not make change physically impossible: real projects revisit work under control, and modified waterfall explicitly includes feedback. Rigidity offers milestone visibility but can freeze incorrect assumptions. - V-model stage/test pairing
- Requirements → acceptance tests
- System design → system tests
- Component/detail design → integration/unit tests
- Coding at bottom
- Early test planning
- Stable requirements, strong assurance fit
- Shape/process guarantees neither safety nor correctness
👁 Full explanation
The V-model pairs specification/design stages with later test levels. Requirements inform acceptance tests; system design informs system tests; component/detail design informs integration/unit tests. Coding lies at the bottom. Test planning starts early. Stable requirements and strong assurance may favor this organization, but neither a V shape nor waterfall guarantees safety or correctness.
12 related practice questions
Note references: SE-M, SE-N, SE-G
- Classical and modified waterfall
SE04
Iteration and incremental delivery
- Iteration versus increment
- Iteration: revisit and improve
- Increment: add usable functionality
- Processes may combine both
- Registration → payments → reporting: incremental
- Registration-prototype feedback revisions: iterative
- Each increment: design, implement, test
👁 Full explanation
Iteration revisits and improves a solution; an increment adds usable functionality. A process may do both. Delivering registration first, then payments, then reporting is incremental; revising a registration prototype after feedback is iterative. Each increment still needs design, implementation and testing. - Incremental-delivery benefits and limits
- Prioritized partial capability delivered early
- Smaller changes: easier debugging, feedback
- Architecture/integration still planned
- Iteration needn't rebuild whole system
- Increments needn't be independent modules
- Early version: prototype/iterative/Agile possibilities
- Purpose determines classification
👁 Full explanation
Choose incremental delivery when prioritized partial capability must reach users early. Smaller changes can be easier to debug and permit feedback, though architecture and integration still require planning. Iteration need not rebuild the whole system every time, and increments need not be perfectly independent modules. Broad descriptions of early working software can fit prototypes, iterative or Agile processes; identify the purpose of that early version.
9 related practice questions
Note references: SE-M, SE-N, SE-G
- Iteration versus increment
SE05
Agile values and Scrum
- Agile values and work descriptions
- People/collaboration over rigid procedures
- Working results over exhaustive documents
- Customer participation over contracts
- Adaptation over fixed plans
- Right-hand values still matter
- Planning/documentation still needed
- User story: small need and value
- Acceptance criteria support story
- Epic: broader work grouping
👁 Full explanation
Agile favors people collaborating, useful working results, customer participation and adaptation over rigid adherence to procedures, exhaustive documents, contracts or fixed plans. The latter still have value. Agile does not mean no planning or no documentation. A user story states a small user need and value, supported by acceptance criteria; an epic groups broader work. - Scrum timeboxes and assurance
- Sprints: at most one month
- Sprint Goal, selected work, usable Increment
- Increment meets Definition of Done
- Scope discussion before/during planning allowed
- Fixed timebox, adapted content
- Sprint Goal protected
- Agile with assurance/documentation possible
- Safety-critical alone doesn't prove unsuitability
👁 Full explanation
Scrum uses timeboxed Sprints of at most one month, with a Sprint Goal, selected work and a usable Increment meeting a Definition of Done. Scope is discussed before and during planning; it is not forbidden to agree scope. Timeboxes tend to stay fixed while content is adapted without endangering the goal. Agile can be combined with required assurance/documentation; safety-critical context alone cannot prove it is unsuitable.
12 related practice questions
Note references: SE-M, SE-N, SE-AG, SE-SC
- Agile values and work descriptions
SE06
Spiral development and risk
- Risk-driven spiral cycle
- Objectives and alternatives
- Assess/reduce important risks
- Develop/verify appropriate next result
- Plan further commitment
- Prototype risky technology before large investment
- Risk determines work amount/type
👁 Full explanation
Spiral development is risk driven. Each cycle identifies objectives and alternatives, assesses and reduces important risks, develops/verifies an appropriate next result, and plans further commitment. A prototype may test a risky technology before a large investment. The amount and type of work depend on the risks. - Spiral selection and limitations
- Risk emphasis distinguishes spiral
- Changing requirements alone insufficient
- Incremental/prototyping/sequential activities incorporable
- Uniquely most-general: textbook convention
- Not universal theorem
- Risk analysis needs skill
- Low-risk small projects: excessive overhead possible
👁 Full explanation
Use risk emphasis to distinguish spiral from a generic changing-requirements scenario. Spiral can incorporate incremental, prototyping or sequential activities, but calling it the uniquely “most general” process is a textbook convention rather than a universal theorem. Risk analysis requires skill and may impose excessive overhead on a small low-risk project.
4 related practice questions
Note references: SE-M, SE-N, SE-G
- Risk-driven spiral cycle
SE07
Prototypes, RAD and reuse
- Prototyping purpose and lifecycle
- Requirements, usability, technical feasibility
- Throwaway: discard after learning
- Evolutionary: deliberately refine toward production
- Quick versions may omit robustness/security/architecture
- Evaluate before unchanged deployment
- Prototyping may include coding
- Construction label doesn't exclude coding
👁 Full explanation
A prototype explores requirements, usability or technical feasibility. A throwaway prototype is discarded after learning; an evolutionary prototype is deliberately refined toward production. A quick prototype may omit robustness, security or architecture, so do not deploy it unchanged without evaluation. Coding may occur during prototyping even if a diagram labels that activity construction rather than coding. - RAD and reuse-oriented development
- RAD: rapid construction, timeboxing
- User participation, reusable components
- Available users, skilled designers/developers
- Reuse: search components → evaluate fit
- Possible requirements adjustment
- Design around interfaces, build gaps
- Product-line requirements/architecture/components/tests reusable
👁 Full explanation
RAD uses rapid construction, timeboxing, user participation and often reusable components; it requires available users and skilled designers/developers. Reuse-oriented development searches components, evaluates fit, may adjust requirements, designs around interfaces and builds missing parts. Product-line assets may include requirements, architecture, components and tests; all are potentially reusable.
7 related practice questions
Note references: SE-M, SE-N, SE-G
- Prototyping purpose and lifecycle
SE08
Feasibility and requirement levels
[Exam Focus]- Feasibility versus system analysis
- Worth doing and deliverable?
- Technical, economic, operational, schedule constraints
- Existing limitations, organizational impacts
- Benefits, cost, available skills
- Integration risk
- System analysis: detailed problem/behavior
- Activities inform each other
👁 Full explanation
Feasibility asks whether a proposal is worth doing and can be delivered within technical, economic, operational and schedule constraints. Examine existing limitations, organizational impacts, benefits, cost, available skills and integration risk. System analysis studies the problem and needed behavior in more detail; the activities inform each other. - Requirement levels and SRS
- Business: purpose and goals
- User: high-level stakeholder needs
- System: detailed services and constraints
- Software Requirements Specification: agreed requirements
- Module natural language: client communication
- Analysis models: technical formalization
- Real specifications may include diagrams
👁 Full explanation
Business requirements explain why the project exists and its goals. User requirements describe stakeholder needs at a useful high level; system requirements specify detailed services and constraints. The Software Requirements Specification (SRS) organizes the agreed requirements. A natural-language specification communicates with clients while analysis models formalize it for technical discussion; real specifications can also contain diagrams.
11 related practice questions
Blueprint: SE-LO1 · Note references: SE-M, SE-N, SE-G
- Feasibility versus system analysis
SE09
Functional rules and prohibitions
[Exam Focus]- Functional obligations and prohibitions
- Observable service or behavior
- Input/error reactions
- Forbidden actions included
- Intrusion sensor → alert
- Manager-only refund approval: functional
- Negative statement ≠ automatically nonfunctional
👁 Full explanation
A functional requirement states an observable service or behavior, including reactions to inputs, errors and forbidden actions. “When the sensor detects intrusion, send an alert” is functional. “Only a manager may approve refunds” also specifies permitted/prohibited behavior. A negative statement is not automatically nonfunctional. - Precise requirement formulation
- Actor/trigger, action, observable result
- Generate PDF report: functional
- No other-customer balance disclosure: functional security
- Broad security quality versus implementing functions
- Must/should/not-work wording: classification may remain ambiguous
👁 Full explanation
Write one clear obligation with an actor/trigger, action and observable result. “The system shall generate a PDF report” is functional. “The system shall not reveal another customer’s balance” can be a security-related functional rule. Security as a broad quality goal and the functions implementing it must be distinguished. Words such as must, should and not work do not by themselves determine a requirement’s classification.
6 related practice questions
Blueprint: SE-LO1 · Note references: SE-M, SE-N, SE-G
- Functional obligations and prohibitions
SE10
Nonfunctional qualities and constraints
[Exam Focus]- Nonfunctional attributes and constraints
- Performance: response time/throughput/resource use
- Reliability: failure-free service
- Availability: ready for use
- Usability: task success/ease of learning
- Security: protection
- Compatibility: cooperating environments
- Portability: moving environments
- Maintainability/supportability: change, diagnosis, evolution
👁 Full explanation
Nonfunctional requirements include quality attributes and constraints. Performance concerns response time, throughput and resource use; reliability concerns failure-free service; availability concerns being ready for use; usability concerns task success and ease of learning. Security concerns protection; compatibility concerns cooperating environments; portability concerns moving environments; maintainability/supportability concern change, diagnosis and evolution. - Measurable qualities and classification traps
- Search ≤2 seconds, 100 concurrent users
- Performance requirement
- New-user checkout ≤1 minute, unaided
- Usability requirement
- Use Java: technology/pseudo-requirement
- Often separately classified system constraint
- Dependability: reliability, safety, robustness
- Portability not usual central dependability category
- Peak-load degradation: primarily performance
- Not automatically reliability
👁 Full explanation
“Search responds within two seconds under 100 concurrent users” is measurable performance. “New users finish checkout within one minute without help” is usability. “Use Java” is a technology/pseudo-requirement, often separately classified as a system constraint. Dependability includes reliability, safety and robustness; portability is not its usual central category. Performance degradation at peak load primarily concerns performance, not automatically reliability.
13 related practice questions
Blueprint: SE-LO1 · Note references: SE-M, SE-N, SE-G
- Nonfunctional attributes and constraints
SE11
Requirement quality and traceability
[Exam Focus]- Requirement quality criteria
- Correct: actual stakeholder needs
- Complete: agreed scope, normal/exceptional behavior
- Consistent: no contradictions
- Clear/unambiguous: one intended interpretation
- Feasible/realistic: achievable within constraints
- Verifiable: objective fulfillment evidence
- Replace vague fast/most users
- Defined metric, workload, threshold
👁 Full explanation
Correct requirements reflect actual stakeholder needs. Complete requirements address the agreed scope, normal and exceptional behavior. Consistency excludes contradictions. Clarity/unambiguity gives one intended interpretation; feasibility/realism means achievable within constraints. Verifiability means objective evidence can check fulfillment. Replace “fast for most users” with a defined metric, workload and threshold. - Traceability and conflict negotiation
- Backward: source/rationale
- Forward: design, code, tests
- Requirement dependencies recorded
- Traceability matrix links artifacts
- Impact analysis support
- Not merely cost/schedule ledger
- Negotiate incompatible stakeholder demands
- Independent incompatible approvals insufficient
- Elicitation difficulties: scope, understanding, volatility
👁 Full explanation
Trace each requirement backward to its source/rationale and forward to design, code and tests. Record dependencies among requirements. A traceability matrix links these artifacts and helps impact analysis; it is not just a cost/schedule ledger. Stakeholders must negotiate conflicting requirements rather than independently approving incompatible demands. Scope, understanding and volatility are distinct elicitation difficulties.
11 related practice questions
Blueprint: SE-LO1, SE-LO3 · Note references: SE-M, SE-N, SE-G
- Requirement quality criteria
SE12
Elicitation, FAST and QFD
[Exam Focus]- Elicitation techniques
- Interviews: stakeholder needs
- Document analysis: manuals, contracts, records
- Observation/ethnography: actual daily work
- Prototypes: tacit expectations
- Workshops/JAD: users, managers, developers
- Facilitator and recorder
- Consensus-building
- Multiple sources, observed-work assumption checks
👁 Full explanation
Interviews ask stakeholders about needs; document analysis examines manuals, contracts and current records; observation/ethnography studies actual daily work. Prototypes reveal tacit expectations. Workshops/JAD bring users, managers and developers together with a facilitator and recorder to build consensus. Use several sources and check assumptions against observed work. - FAST, QFD and brainstorming
- FAST: environment elements, outputs, inputs lists
- Consolidate lists → smaller specifications
- QFD: customer-value prioritization
- Normal needs: explicit
- Expected needs: assumed
- Exciting needs: unanticipated benefit
- Brainstorm ideas before evaluation/prioritization
- Not every idea becomes committed requirement
👁 Full explanation
In the taught FAST technique, participants list environment elements, outputs and inputs, consolidate lists and develop smaller specifications. QFD prioritizes customer value: normal needs are explicitly stated, expected needs are assumed, and exciting needs provide unanticipated benefit. Brainstorm first to generate ideas, then evaluate and prioritize; do not confuse that with letting every idea become a committed requirement.
3 related practice questions
Blueprint: SE-LO1 · Note references: SE-M, SE-N, SE-G
- Elicitation techniques
SE13
Scenarios and analysis objects
[Exam Focus]- Scenarios, models and analysis objects
- Scenario: one concrete execution
- Use case: related success/alternative scenarios
- Functional model: use cases/scenarios
- Structural/object model: classes
- Dynamic model: states/interactions
- Entity: domain information, Incident
- Boundary: interaction mediation, ReportForm
- Control: use-case coordination
- UI form normally boundary, not entity
👁 Full explanation
A scenario is one concrete execution; a use case abstracts the related successful and alternative scenarios. Analysis integrates functional (use cases/scenarios), structural/object (classes) and dynamic (states/interactions) models. Entity objects represent domain information such as Incident; boundary objects mediate interaction, such as ReportForm; control objects coordinate a use case. A UI form is normally boundary, not entity. - Object identification and CRC
- Nouns → candidate objects
- Possessives → candidate attributes
- Verbs manages/reports-to → candidate associations
- Heuristics, not automatic parsing rules
- CRC: Class, Responsibilities, Collaborators
- Control per use-case/actor: starting heuristic
- Not mandatory UML rule/fixed lifetime
👁 Full explanation
Use nouns as candidate objects, possessive descriptions as candidate attributes, and verbs such as manages/reports-to as candidate associations. These are heuristics, not automatic parsing rules. CRC means Class, Responsibilities, Collaborators. A control per use case or participating actor can be a useful starting point, not a mandatory UML rule or fixed object lifetime.
9 related practice questions
Blueprint: SE-LO1, SE-LO2, SE-LO3 · Note references: SE-M, SE-N, SE-G
- Scenarios, models and analysis objects
SE14
Actors, goals and system scope
[Exam Focus]- Actors and external roles
- Person, device or another system
- One person: multiple roles
- Multiple people: one role
- Primary actor: seeks goal
- Supporting actor: provides service
- Identify main-function user groups
- Administration/maintenance roles
- External information-exchanging systems
👁 Full explanation
An actor is an external role interacting with the system; it can be a person, device or another system. A person may play several roles, and several people may play one role. A primary actor seeks a goal; a supporting actor provides a service. Ask which user groups perform main functions, administer or maintain the system, and which external systems exchange information. - Use-case diagram scope
- Actors outside boundary rectangle
- Use-case ovals inside
- Goal name: verb plus noun
- Roles, goals, relationships
- No full algorithm/UI layout
- Internal component versus external actor
- Chosen system boundary determines role
👁 Full explanation
Draw actors outside the system boundary rectangle and use-case ovals inside. Name a goal with a verb and noun. The diagram shows roles, goals and relationships, not the full detailed algorithm or UI layout. Being an internal component is different from being an external actor; the chosen boundary determines which role applies.
11 related practice questions
Blueprint: SE-LO3 · Note references: SE-M, SE-N, SE-G
- Actors and external roles
SE15
Use-case flows and guarantees
[Exam Focus]- Complete use-case specification
- Name/goal, actors, trigger
- Preconditions
- Main success flow
- Alternatives/exceptions
- Postconditions
- Active subject–verb steps
- Consistent abstraction level
- Errors separated from normal flow
👁 Full explanation
Record name/goal, actors, trigger, preconditions, main success flow, alternatives/exceptions and postconditions. Use active subject–verb steps at one abstraction level; separate errors from the normal flow. - Submit Incident scenario
- Precondition: authenticated officer
- Officer supplies location/description
- System validates → records → returns ID
- Missing location: problem and correction request
- Failure: save nothing
- Success: incident and ID persist
- Failure guarantee: no partial record
- Alternate flow: conditional variation
- Exception flow: failure
- Preconditions before entry, trigger starts execution
👁 Full explanation
Example: Submit Incident. Precondition: officer authenticated. 1 Officer supplies location and description. 2 System validates details. 3 System records the incident. 4 System returns its ID. Alternative 2a: location missing → report the problem and request correction; save nothing. Success postcondition: incident and ID persist; failure guarantee: no partial record. An alternate flow is a conditional variation; an exception flow handles a failure. Preconditions hold before entry, while a trigger starts the use case.
4 related practice questions
Blueprint: SE-LO3 · Note references: SE-M, SE-N, SE-G
- Complete use-case specification
SE16
Include, extend and generalization
[Exam Focus]- Include versus extend
- Include: required reused behavior
- Submit Order includes Validate Order
- Dashed include arrow: base → included
- Extend: conditional extension-point behavior
- Apply Discount extends Checkout
- Extend arrow: extension → base
- Base meaningful independently
- Withdrawal extends Print Receipt: reversed example
👁 Full explanation
Include factors required reused behavior: Submit Order includes Validate Order, with the dashed arrow from the including/base use case to the included one. Extend adds conditional behavior at extension points: Apply Discount extends Checkout, with the arrow from the extension to the base. The base is meaningful independently. For an extension, draw the arrow from the extending use case to the base use case. - Generalization and abstract use cases
- Specialized actor/use case → general
- Hollow triangle toward general
- Abstract: behavior for specialization
- Not directly instantiated complete use case
- Reuse alone insufficient definition
- No direct actor line insufficient definition
- Included behavior executes when inclusion reached
- Base conditional branches not necessarily all executed
👁 Full explanation
Generalization relates a specialized actor/use case to a more general one, with a hollow triangle toward the general element. An abstract use case specifies behavior for specialization and is not directly instantiated as a complete use case. It is not defined merely by reuse or lack of a direct actor line. Included behavior is incorporated where the inclusion is reached; do not infer every conditional branch in the base always executes.
6 related practice questions
Blueprint: SE-LO3 · Note references: SE-M, SE-N, SE-G
- Include versus extend
SE17
UML classes and multiplicity
[Exam Focus]- Class diagrams and UML
- Class name, attributes, operations
- + public, - private, # protected
- ~ package visibility
- Class diagram: static types/relationships
- Object diagram: particular instances/links
- OMG maintains/standardizes UML
- Modeling language, not lifecycle process
- Structural things: conceptual/physical structural elements
👁 Full explanation
A class box lists name, attributes and operations; + public, - private, # protected and ~ package indicate visibility. A class diagram shows static types and relationships, while an object diagram shows particular instances/links. UML is maintained and standardized by OMG; it is a modeling language, not a lifecycle process. Structural things describe conceptual or physical structural elements. - Multiplicity interpretation
- One end: objects per opposite-end object
- 1: exactly one
- 0..1: optional
- 0..*: any nonnegative number
- 1..*: at least one
- Read each end separately
- One-to-many doesn't imply composition
👁 Full explanation
Multiplicity at one end counts how many objects there may correspond to one object at the opposite end: 1 exactly one, 0..1 optional, 0..* any nonnegative number, 1..* at least one. A one-to-many association does not automatically mean composition. Read each end separately before choosing cardinality.
9 related practice questions
Blueprint: SE-LO1, SE-LO2 · Note references: SE-M, SE-N, SE-G
- Class diagrams and UML
SE18
Association, aggregation and composition
- Association, dependency and aggregation
- Association: related instances
- Dashed dependency: client uses supplier
- Generalization: solid line, hollow triangle
- Triangle toward superclass/general element
- Shared aggregation: hollow diamond
- Diamond at whole end
- Weak whole-part meaning
- No detailed lifecycle policy implied
👁 Full explanation
Association connects related instances. A dashed dependency arrow means a client uses a supplier. Generalization uses a solid line and hollow triangle pointing to the superclass/general element. Shared aggregation uses a hollow diamond at the whole end and weak whole-part meaning; it does not by itself define a detailed lifecycle policy. - Composition ownership and diamond placement
- Filled diamond at whole end
- At most one composite per part
- Owned parts destroyed with composite
- Defined detachment/transfer possible
- Never-independent claim oversimplified
- Car composing Engine: diamond beside Car
- Points-to-Engine wording imprecise
- Bank intended relationship: composition
👁 Full explanation
Composition uses a filled diamond at the whole end and strong ownership: a part is in at most one composite at a time, and parts still owned are destroyed with that composite. Parts may be detached/transferred under a defined model. Thus “cannot ever exist independently” is an oversimplification. For Car composing Engine, the diamond belongs beside Car; saying it points to Engine is imprecise. The Car–Engine example describes composition.
6 related practice questions
Note references: SE-M, SE-G, SE-U
- Association, dependency and aggregation
SE19
Sequence diagrams and emergency reporting
[Exam Focus]- Sequence diagram semantics
- Interactions across lifelines
- Order/time generally downward
- Messages between participants
- Activation rectangles: execution
- Creation message starts lifeline
- X: modeled destruction
- No garbage-collector timing guarantee
- Synchronous call: wait
- Asynchronous message: sender proceeds
👁 Full explanation
Sequence diagrams show interactions across lifelines, with order/time generally downward. Messages cross between participants; activation rectangles show execution. A creation message starts a lifeline; an X marks modeled destruction, not a guarantee about when a garbage collector runs. Synchronous calls wait for completion; asynchronous messages permit the sender to proceed. - Emergency-report interaction example
- Module heuristic: actor → boundary → control
- Entities follow
- Not mandatory UML column order
- FieldOfficer → ReportEmergencyButton
- EmergencyReportForm: enter details
- AcknowledgmentNotice: later response
- DispatcherStation: dispatcher side
- Initiating element: ReportEmergencyButton
👁 Full explanation
One interaction-diagram layout heuristic puts the initiating actor first, boundary second, control third, then entities. This is not a required UML column order. In ReportEmergency, FieldOfficer activates ReportEmergencyButton, enters details through EmergencyReportForm, and later sees AcknowledgmentNotice; DispatcherStation belongs to the dispatcher side. Choose the button for initiating this particular scenario.
4 related practice questions
Blueprint: SE-LO1, SE-LO2 · Note references: SE-M, SE-N, SE-G
- Sequence diagram semantics
SE20
Activity, state and data-flow models
[Exam Focus]- Activity and state-machine notation
- Activity: workflow
- Filled circle: start
- Rounded actions
- Guarded diamond: decision/alternative merge
- Thick bars: fork/join
- Partitions/swimlanes: responsibility
- Join synchronizes concurrent flows
- State machine: object lifecycle
- Event-triggered transitions
- Optional guards/actions
👁 Full explanation
An activity diagram models workflow: filled circle start, rounded actions, guarded decision diamond, thick fork/join bars and partitions/swimlanes for responsibility. A diamond can also merge alternative flows; a join synchronizes concurrent flows. A state machine models states and transitions triggered by events, often with guards/actions, for one object’s lifecycle. - Diagram selection
- Sequence: participant message order
- State machine: event-dependent state changes
- Activity: workflow
- Sequence/state both temporal behavior
- Significant-state objects: entity or control
- DFD: data stores, flows, transformations
- Inputs → outputs
- DFD isn't UML
👁 Full explanation
Choose a sequence diagram for message order between participants, a state machine for event-dependent state changes, and activity for workflow. Both sequence and state diagrams describe behavior over time. State machines are useful for objects with significant states, whether entity or control. A DFD shows data stores/flows and transformations from inputs to outputs; it is not a UML diagram.
8 related practice questions
Blueprint: SE-LO1 · Note references: SE-M, SE-N, SE-G
- Activity and state-machine notation
SE21
System design and subsystem decomposition
[Exam Focus]- System versus detail design
- Analysis model → architecture
- Design goals, subsystem responsibilities/dependencies
- Hardware mapping, data management
- Access control, control flow
- Startup/shutdown/error policies
- Detail design: APIs, parameter/return types
- Exceptions, components, algorithms
- Subsystem: manageable logical collection
- Services and interface
- Not necessarily physical replaceable artifact
👁 Full explanation
System design turns the analysis model into architecture: design goals, subsystem responsibilities, dependencies, hardware mapping, data management, access control, control flow and startup/shutdown/error policies. Detail/object design refines APIs, parameter/return types, exceptions, component choices and algorithms. A subsystem is a manageable logical collection with services and an interface; it need not be a physical replaceable artifact. - Subsystem decomposition and architecture documentation
- Group related objects/functionality
- Minimize cross-boundary associations
- Isolate communication infrastructure where useful
- Workflows inform, don't dictate internals
- Analysis: domain needs
- Subsystem decomposition: principally design result
- Architecture documents: communication, major decisions
- Not every source execution step
👁 Full explanation
Group closely related objects and functionality, minimize associations crossing boundaries, and isolate communication infrastructure where useful. User workflows inform decomposition but do not alone dictate the internal structure. Analysis describes domain needs; subsystem decomposition is principally a design result. Architecture documentation supports communication and records major decisions, not every source-level execution step.
8 related practice questions
Blueprint: SE-LO1, SE-LO2 · Note references: SE-M, SE-N, SE-G
- System versus detail design
SE22
Cohesion, coupling and refactoring
- Cohesion, coupling and hiding
- Cohesion: related purpose within module
- Coupling: dependencies between modules
- Seek high cohesion, low coupling
- Shared mutable data increases coupling
- Internal-representation knowledge increases coupling
- Stable operations hide changeable decisions
👁 Full explanation
Cohesion measures how well elements inside a module serve a related purpose; coupling measures dependency between modules. Seek high cohesion and low coupling. Shared mutable data and knowledge of another module’s internal representation increase coupling. Information hiding exposes stable operations while concealing changeable decisions. - Cohesion types and modularity trade-offs
- Logical: similar-category operations, often flag-selected
- Temporal: same-time operations
- Functional: one task
- Split unrelated three-purpose component
- Modularity improvement
- Behavior-preserving restructuring: refactoring
- Answers needn't be mutually exclusive
- Smaller modules: understanding, independent work
- Reuse and maintenance benefits
- Too many interfaces increase complexity
👁 Full explanation
Logical cohesion groups similar-category operations, often selected by a flag; temporal cohesion groups operations done at the same time; functional cohesion focuses on one task. Splitting an unrelated three-purpose component improves modularity. If behavior is preserved, the restructuring is refactoring; the words are not mutually exclusive answers. Smaller modules can aid understanding, independent work, reuse and maintenance, but too many interfaces also create complexity.
12 related practice questions
Note references: SE-M, SE-N, SE-G
- Cohesion, coupling and hiding
SE23
Layers, tiers and architecture views
- Layers versus tiers
- Layer: logical abstraction level
- Tier: deployment separation
- Closed: only immediately lower calls
- Open: approved layer skipping
- A,B,C,D top-to-bottom
- A→B closed-compliant, A→C skips
- Lower→upper violates simple dependency rule
- Explicitly defined mediation exception
👁 Full explanation
A layer is a logical abstraction level; a tier is a deployment separation. A closed layered architecture permits calls only to the immediately lower layer; an open one permits approved skipping. For top-to-bottom A,B,C,D, A→B obeys closed layering, A→C skips, and lower-to-upper calls violate the simple dependency rule unless explicitly mediated by a defined mechanism. - Structures, views and architectural concerns
- Structure: elements/relations themselves
- View: selected-aspect representation
- Module: code organization
- Component-and-connector: runtime interaction
- Allocation: software→hardware/teams/environment
- Concurrency views: processes/threads
- Quality attributes/scenarios evaluate architecture
- Processor allocation, decomposition, style selection
👁 Full explanation
A structure is the elements/relations themselves; a view represents selected aspects. Module structures show code organization, component-and-connector structures runtime interaction, and allocation structures map software to hardware, teams or environment. Processes/threads belong in concurrency views. Evaluate architectures against quality attributes and scenarios; processor allocation, decomposition and style selection can all be architectural concerns.
8 related practice questions
Note references: SE-M, SE-AR
- Layers versus tiers
SE24
Architecture styles and integration
- Architecture styles and trade-offs
- Repository: shared central data
- Common access versus bottleneck/schema dependence
- MVC: model, view, controller
- Domain, display, interaction separation
- Client–server: requester/provider roles
- Peer-to-peer: both roles
- Pipe-and-filter: successive data-stream transformations
- Three-tier: presentation/application logic/storage
- Four-tier variant: split presentation client/server
👁 Full explanation
Repository style shares central data, simplifying common access but creating bottleneck/schema dependencies. MVC separates domain model, display view and interaction controller. Client–server separates requesters from service providers; peer-to-peer permits both roles. Pipe-and-filter applies successive transformations to data streams. Three-tier separates presentation, application logic and storage; some four-tier variants split presentation client/server. - Integration boundaries and architecture diagrams
- API gateway: single entry
- Routes/combines service calls
- Hides service boundaries from clients
- Central policies versus bottleneck risk
- Component diagram: components/interfaces/dependencies
- Deployment diagram: artifacts on nodes
- Required interactions/qualities guide style
- No universally best architecture
👁 Full explanation
An API gateway presents one entry point and routes/combines calls to services, hiding service boundaries from clients. It can centralize policies but also become a bottleneck. A component diagram shows components/interfaces/dependencies; a deployment diagram places software artifacts on nodes. Choose the style for the required interactions and qualities rather than selecting a universally best architecture.
4 related practice questions
Note references: SE-M, SE-N, SE-G
- Architecture styles and trade-offs
SE25
Design principles and operation contracts
[Exam Focus]- Design principles
- Abstraction/decomposition manage complexity
- Consistency, traceability, clear responsibilities
- Top-down: high-level refinement
- Bottom-up: existing-component assembly
- Hybrid: combine both
- SOLID: Single Responsibility
- Open–Closed: compatible extensions
- Liskov substitution
- Interface Segregation: avoid unused operations
- Dependency Inversion: depend on abstractions
- DRY: limit duplicated knowledge
- KISS: avoid unnecessary complexity
- YAGNI: avoid speculative work
👁 Full explanation
Use abstraction and decomposition to manage complexity; preserve consistency, traceability and clear responsibilities. Top-down design refines high-level structure; bottom-up design assembles existing components. A hybrid combines both. SOLID includes Single Responsibility, Open–Closed, Liskov substitution, Interface Segregation and Dependency Inversion. Depend on abstractions; add compatible extensions; avoid forcing unused operations. DRY limits duplicated knowledge, KISS avoids unnecessary complexity, and YAGNI avoids speculative work. - Operation contracts and full features
- Preconditions, postconditions, invariants
- withdraw requires amount>0
- Also amount<=balance
- Ensures balance=oldBalance-amount
- Invariant: balance>=0
- Validation: input checks
- Implementation: enforce transition
- UI/API plus persisted behavior required
- Diagram alone insufficient
👁 Full explanation
A contract states preconditions, postconditions and invariants. For withdraw(amount): require amount>0 and amount<=balance; ensure balance=oldBalance-amount; preserve balance>=0. Validation checks inputs; implementation enforces the transition. A complete feature needs both UI/API and persisted behavior, not only a diagram.
8 related practice questions
Blueprint: SE-LO1, SE-LO2 · Note references: SE-M, SE-N, SE-G, SE-SOLID
- Design principles
SE26
Analysis-to-implementation example
[Exam Focus]- Submit Incident implementation responsibilities
- Boundary: input
- Service: validation/coordination
- Repository: save Incident entity
- require authenticated
- missing(location) → validationError
- new Incident(input) → repository.save
- Return incident.id
- Save and ID assignment atomic
- Failure requires rollback
👁 Full explanation
For Submit Incident, let a boundary read input, a service validate and coordinate, and a repository save an Incident entity. Pseudocode: submit(input){require authenticated; if missing(location) return validationError; incident=new Incident(input); repository.save(incident); return incident.id;}. Save and ID assignment must succeed together, or roll back. - Model-derived tests and traceability
- Missing location: saves nothing
- Valid input: saved ID returned
- Storage failure: error, no partial record
- Unauthorized input rejected
- Requirement → use-case step → service operation
- Repository effect → test
- Analysis/design made actionable
- Implementation-practice gap closed
👁 Full explanation
Derive tests from the model: missing location saves nothing; valid input returns a saved ID; a storage failure yields an error without a partial record; unauthorized input is rejected. Trace requirement→use-case step→service operation→repository effect→test. Use the implementation exercise to connect analysis and design tools to working code.
Blueprint: SE-LO2 · Note references: SE-M, SE-N, SE-G
- Submit Incident implementation responsibilities
SE27
Patterns, variability and testability
- Design patterns
- Factory Method: subclass-selectable creation operation
- Reduced concrete-constructor coupling
- Simple factory: centralized creation
- Not identical to Factory Method
- Singleton: controlled one-instance access
- Observer: notify subscribers
- Memento: store/restore state, representation hidden
- Iterator: traversal
- Decorator: behavior through wrapping
- Bank Momento means Memento
👁 Full explanation
Factory Method lets subclasses choose a concrete product through a creation operation, reducing coupling to concrete constructors. A simple factory centralizes creation but is not identical to Factory Method. Singleton controls access to one instance; Observer notifies subscribers; Memento stores/restores state while hiding representation; Iterator traverses; Decorator adds behavior through wrapping. The pattern name is Memento, not Momento. - Variability and testability
- Selectable features, omission/inclusion, extension points
- Overloading: alternate code signatures
- Not every variability mechanism
- Controllable inputs, observable outputs
- Replaceable dependencies, limited structural complexity
- Sandbox: execution isolation
- Self-referential A-and-B option B
- No unique answer established
👁 Full explanation
Variability can use selectable features, omission/inclusion and extension points; overloading supplies alternate signatures in code but is not every variability mechanism. Testability improves with controllable inputs, observable outputs, replaceable dependencies and limited structural complexity. A sandbox can isolate execution. Assess each design claim independently before evaluating a combined statement.
5 related practice questions
Note references: SE-M, SE-N, SE-G, SE-PAT
- Design patterns
SE28
Planning, WBS, estimation and tools
- Continuous planning and WBS
- Scope/deliverables identification
- Work decomposition
- Effort/duration/cost estimation
- Resources assigned, dependencies sequenced
- Revise using new evidence
- WBS: hierarchical project-scope coverage
- Exclude unrelated work
- Tools coordinate ownership/dependencies/progress
- Judgment not replaced
- No automatic bug repair
👁 Full explanation
Planning is continuous: identify scope/deliverables, decompose work, estimate effort/duration/cost, assign resources, sequence dependencies and revise as evidence changes. A WBS is hierarchical and covers project scope without adding unrelated work. Tools help coordinate ownership, dependencies and progress; they do not replace judgment or automatically fix bugs. - Functional size and development tools
- Function points: inputs, outputs, inquiries
- Internal logical files
- External interface files
- Weights depend on chosen method
- Not merely lines of code
- Not exact direct complexity measure
- Git: version tracking
- Jira: work/defect tracking
- Jenkins: automated CI checks
- Docker: application/runtime dependency containers
👁 Full explanation
Function points estimate functional size using inputs, outputs, inquiries, internal logical files and external interface files, weighted under the chosen method. They are not just lines of code and are not a direct exact measure of complexity. Git tracks versions; issue trackers such as Jira track work/defects; CI tools such as Jenkins automate checks; Docker packages application/runtime dependencies into containers.
7 related practice questions
Note references: SE-M, SE-N, SE-G
- Continuous planning and WBS
SE29
Critical-path forward and backward passes
- Critical-path network calculations
- ES=max(predecessor EF)
- EF=ES+duration
- Start ES=0 unless constrained
- Earliest project finish=max(terminal EF)
- Backward LF=min(successor LS)
- LS=LF-duration
- Backward pass starts required finish
- Float=LS-ES=LF-EF
- Critical path: longest total duration
- Normally zero float, unconstrained schedule
👁 Full explanation
In a dependency network, ES=max predecessor EF and EF=ES+duration; start tasks have ES=0 unless another constraint applies. Project earliest finish is the maximum terminal EF. Backward, LF=min successor LS and LS=LF-duration, starting from the required finish. Total float/slack=LS-ES=LF-EF. A critical path has the longest total duration and normally zero float in an unconstrained schedule. - Parallel tasks and multiple critical paths
- A=5; B=3,C=4 follow A
- Duration=5+max(3,4)=9 days
- B finishes day8, C day9
- Project waits for C
- Paths B5+C6 and D8+E3
- Shared zero-duration start/end
- Both 11 days: two critical paths
👁 Full explanation
If A takes 5 days and B=3,C=4 both follow A, project duration is 5+max(3,4)=9 days. B finishes at 8, but the project waits for C at 9. If paths B5+C6 and D8+E3 share a zero-duration start/end, both total 11; there are two critical paths, not one.
3 related practice questions
Note references: SE-M, SE-N, SE-G
- Critical-path network calculations
SE30
Slack assumptions and PERT
- Slack requires network context
- ES/EF alone insufficient
- Successor relationships required
- Project completion constraint required
- C3→D6 parallel A4→B5
- Both complete paths finish day9
- Then C float=0
- Four unrelated rows don't establish network
👁 Full explanation
Early start/finish values alone do not determine slack without successor relationships and the project completion constraint. If C3→D6 is a complete path parallel to A4→B5 and both finish at day9, C has zero float. That network cannot be silently inferred from four unrelated ES/EF rows. - CPM versus PERT
- CPM: point durations
- PERT: uncertain durations
- a optimistic, m most-likely, b pessimistic
- TE=(a+4m+b)/6
- Variance=((b-a)/6)^2
- a=3,m=6,b=15 days
- TE=42/6=7 days
- Variance=4 days²
- Weighted estimate, not simple average
- Approximation, not guaranteed completion
👁 Full explanation
Traditional CPM uses point durations; PERT models uncertainty with optimistic a, most-likely m and pessimistic b. The classic estimate is TE=(a+4m+b)/6 and variance=((b-a)/6)^2. For 3,6,15 days, TE=42/6=7 days and variance=4 days². Do not replace the weighted estimate by a simple average. These formulas are approximations, not guaranteed actual completion times.
4 related practice questions
Note references: SE-M, SE-PT
- Slack requires network context
SE31
ROI, risks and resource optimization
- ROI and risk management
- Common-date discounted benefits/costs assumed
- ROI=(benefits-costs)/costs*100%
- Birr120000 benefits, Birr100000 costs
- ROI=20%, not 120%
- Project risks: resources/schedule
- Product risks: quality
- Business risks: organization
- Likelihood/impact analysis
- Plan responses and monitor
👁 Full explanation
With benefits and costs already discounted to a common date, ROI=(benefits-costs)/costs*100%. Birr120000 benefits and Birr100000 costs give 20%, not 120%. Identify project risks to resources/schedule, product risks to quality, and business risks to the organization. Analyze likelihood and impact, plan responses and monitor. - Risk responses and resource optimization
- Avoidance: remove risk through plan change
- Mitigation: reduce likelihood/impact
- Transfer: contractual consequence assignment
- Retention/acceptance: keep risk
- Passive acceptance: possibly no action
- Leveling: dates adjusted for resource availability
- May alter project finish
- Smoothing: float within schedule constraints
- Neither creates extra staff
👁 Full explanation
Avoidance changes the plan to remove a risk, mitigation reduces likelihood/impact, transfer assigns consequences contractually, and retention/acceptance keeps the risk; passive acceptance may take no action. Resource leveling adjusts dates to respect resource availability and can change project finish; smoothing uses available float within schedule constraints. Neither magically creates extra staff.
3 related practice questions
Note references: SE-M, SE-RES
- ROI and risk management
SE32
Teams, organizations and process maturity
- Organization, teams and development stages
- Functional organization: discipline specialists
- Project organization: project grouping
- Specialization: staffing/knowledge continuity
- Possible handoff barriers
- Democratic team: shared decisions
- Chief-programmer team: centralized technical coordination
- Different classification dimensions
- Tuckman: forming→storming→norming→performing→adjourning
- Orientation → conflict → norms
- Effective work → closure
👁 Full explanation
Functional organizations group specialists by discipline; project organizations group people around projects. Functional specialization helps staffing and knowledge continuity but may create handoff barriers. Democratic teams share decisions; chief-programmer teams centralize technical coordination. These are different classification dimensions. Tuckman’s sequence is forming→storming→norming→performing→adjourning: orientation, conflict, norms, effective work and closure. - Historical Software CMM maturity
- 1 Initial, 2 Repeatable
- 3 Defined, 4 Managed
- 5 Optimizing
- Level2: basic project discipline
- Requirements management and project planning
- Quality assurance and configuration management
- Historical labels ≠ modern CMMI terminology
- Process capability focus
- No defect-free-product guarantee
👁 Full explanation
Historical Software CMM levels are 1 Initial, 2 Repeatable, 3 Defined, 4 Managed, 5 Optimizing. Level2 establishes basic project discipline including requirements management, project planning, quality assurance and configuration management. These historical labels must not be silently replaced by modern CMMI terminology. A maturity model concerns process capability, not a guarantee that every product is defect free.
4 related practice questions
Note references: SE-M, SE-CMM, SE-TEAM
- Organization, teams and development stages
SE33
Configuration, change and version control
[Exam Focus]- Configuration management and controlled items
- Items, versions/baselines
- Change procedures, status, audits
- Source, requirements, manuals
- Test plans, environments, build configurations
- Ordinary team browser: usually tool
- Controlled test-browser version: possible environment CI
👁 Full explanation
Configuration management identifies controlled items, versions/baselines, change procedures, status and audits. Items may include source code, requirements, manuals, test plans, environments and build configurations. A team’s ordinary browser is usually a tool rather than product CI, but a controlled test-browser version may be an environment CI. - Change workflow and distributed Git
- Request → impact assessment → decision/prioritization
- Implementation → validation
- Configuration management: consistent affected versions
- Each clone: local history
- Independent branches then merging
- Conflicts/approvals remain possible
- Plan test configuration management early
- Apply throughout testing
- No single exclusive phase
👁 Full explanation
Change management handles request, impact assessment, decision/prioritization, implementation and validation; configuration management keeps all affected versions consistent. Distributed Git gives each clone local history and supports independent branches followed by merging; it does not eliminate merge conflicts or approvals. Plan test configuration management early and apply it throughout testing, not at just one exclusive phase.
5 related practice questions
Blueprint: SE-LO1, SE-LO2 · Note references: SE-M, SE-N, SE-G
- Configuration management and controlled items
SE34
Quality, verification and validation
[Exam Focus]- Assurance, control, verification and validation
- QA: processes/standards established and checked
- QC: work-product evaluation
- SQA plan: standards/responsibilities/evaluations
- Reviews, audits, assurance records
- Conformance: follow design/specification
- Poor specification can still be followed
- Verification: correct specified-obligation implementation
- Validation: intended stakeholder needs met
- Both: reviews, analysis, execution
- Human-only/computer-only distinction false
👁 Full explanation
Quality assurance establishes and checks processes/standards; quality control evaluates work products. An SQA plan identifies standards, responsibilities, evaluations, reviews, audits and assurance records. Quality of conformance means following the design/specification; a product can conform to a poor specification. Verification asks whether specified obligations are implemented correctly; validation asks whether the product meets intended stakeholder needs. Both can use reviews, analysis or execution, so “human-only versus computer-only” is false. - Defect, error, failure and evidence
- Fault/defect: underlying problem
- Error: possibly incorrect internal state
- Failure: externally observed service departure
- Reliability: product quality
- Low cost/short development: project outcomes
- Tests reveal defects, increase confidence
- No general all-input correctness guarantee
👁 Full explanation
A fault/defect is an underlying problem; an error may be an incorrect internal state; a failure is an externally observed departure from required service. Reliability is a product quality attribute; low cost or short development time are project outcomes. Tests increase confidence and reveal defects but cannot generally guarantee correctness over every possible input.
10 related practice questions
Blueprint: SE-LO1 · Note references: SE-M, SE-N, SE-G
- Assurance, control, verification and validation
SE35
Testing levels and acceptance
[Exam Focus]- Unit, integration and system testing
- Unit: function/class/small component isolation
- Mocks/stubs replace dependencies
- Driver invokes unit
- Stub replaces called dependency
- Integration: combined-part interfaces/interactions
- System: complete integrated system
- Functional/nonfunctional requirements
- Representative environment
👁 Full explanation
Unit testing isolates a function, class or small component, often replacing dependencies with stubs/mocks; a driver invokes the unit and a stub substitutes a called dependency. Integration testing exercises interfaces and interactions among combined parts. System testing checks the complete integrated system against functional and nonfunctional requirements in a representative environment. - Acceptance, alpha, beta and techniques
- Acceptance: customer/user decision support
- Agreed needs/criteria
- Alpha: controlled developer setting, selected users
- Beta: external users, own environments
- No universally longest level
- Unit: level; white-box: technique
- Black-box unit cases possible
👁 Full explanation
Acceptance testing supports the customer/user’s acceptance decision against agreed needs and criteria. Alpha typically happens in a controlled developer setting with selected users; beta uses external users in their environments. None of these levels is universally the longest. Unit is a level, while white-box is a technique; a unit can be tested using black-box cases too.
10 related practice questions
Blueprint: SE-LO1, SE-LO2 · Note references: SE-M, SE-N, SE-G
- Unit, integration and system testing
SE36
Test types, regression and exploration
- Test types and workload context
- Functional: SRS/acceptance behavior
- Performance: speed/throughput/resources under workload
- Load: expected demand
- Stress: beyond normal limits
- Usability/security/compatibility/reliability: respective qualities
- Normal conditions alone: insufficient classification
- Functional versus performance still unresolved
👁 Full explanation
Functional tests check required behavior against the SRS and acceptance criteria. Performance tests assess speed, throughput and resources under a specified workload; load uses expected demands and stress exceeds normal limits. Usability, security, compatibility and reliability tests target their respective qualities. “Normal operating conditions” alone does not distinguish functional from performance testing. - Techniques, regression and exploration
- Black-box: specified behavior
- White-box: internal structure
- Grey-box: partial internal knowledge
- Regression: unintended change effects
- Confirmation: specific defect repair
- Exploratory: learning/design/execution combined
- Experience-based testing
- Manual/automated: execution support
- No compulsory black-/white-box classification
👁 Full explanation
Black-box techniques derive cases from specified behavior; white-box techniques derive them from internal structure; grey-box uses partial internal knowledge. Regression testing checks for unintended effects after change; confirmation testing checks the particular defect repair. Exploratory testing combines learning, design and execution and is experience based. Manual/automated describe execution support, not a compulsory black-/white-box classification.
13 related practice questions
Note references: SE-M, SE-N, SE-G
- Test types and workload context
SE37
Equivalence, boundaries and decision tables
- Equivalence partitions and boundaries
- Expected-similar behavior groups
- Sample valid and invalid groups
- Allowed age18..60
- Partitions: below18,18..60,above60
- Edges and neighbors
- 17,18,19,59,60,61
- Exact boundary set: stated coverage scheme
👁 Full explanation
Equivalence partitioning groups inputs expected to behave alike, then samples valid and invalid groups. For allowed age18..60, useful partitions are below18,18..60,above60. Boundary tests target edges and neighbors, such as 17,18,19,59,60,61, with the exact set chosen under the stated coverage scheme. - Decision tables and state-transition cases
- Conditions/combinations → actions
- validCard, enoughFunds
- TT,TF,FT,FF
- Dispense only TT
- Proper rejection otherwise
- Cover feasible rules
- Impossible combinations needn't be blindly covered
- Specification-based techniques
- Already-closed incident: reject dispatch
👁 Full explanation
A decision table lists condition combinations and resulting actions. For validCard and enoughFunds, enumerate TT,TF,FT,FF; specify dispense only for TT and the proper rejection for others. Cover feasible rules rather than blindly using every impossible combination. These are specification-based techniques. Test requirements can also define state-transition cases, such as rejecting dispatch from an already closed incident.
2 related practice questions
Note references: SE-M, SE-TEST
- Equivalence partitions and boundaries
SE38
Statement, decision and branch coverage
- Structural coverage and limitations
- Statement coverage=distinct exercised statements/total executable statements
- Declared test scope determines denominator
- Unreachable statements can prevent 100%
- Document justified exclusions/adjusted scope
- Decision coverage: decision outcomes
- Branch coverage: control-flow edges
- Unconditional edges under stated convention
- Nested decisions may need >2 tests
- Exercised structure ≠ behavioral proof
👁 Full explanation
Statement coverage is the number of distinct executable statements exercised divided by the total executable statements in the declared test scope. Unreachable statements can prevent100%; any justified exclusions must be documented with the adjusted scope. Decision coverage counts decision outcomes; branch coverage counts control-flow edges, including unconditional edges under the stated convention. Testing both true and false of each decision may need more than two overall test cases when branches nest. Coverage is evidence of exercised structure, not proof of all behavior. - Nested-decision coverage example
- Outer true: inner true and false
- Outer false: inner true and false
- Four tests required
- (w,l,h)=(3,2,4),(3,2,1)
- Also (2,3,4),(2,3,1)
- One run can't cover both outer branches
- All paths may be infeasible
- Loops may create infinite paths
- State chosen coverage target
👁 Full explanation
In the width/length/height program, the outer if has separate inner decisions in each branch. Need outer true with inner true and false, and outer false with its inner true and false: four tests, for example (w,l,h)=(3,2,4),(3,2,1),(2,3,4),(2,3,1). One run cannot exercise both outer branches. All paths may be infeasible or infinite with loops; specify the chosen coverage target.
2 related practice questions
Note references: SE-M, SE-N, SE-G, PRIMARY-ISTQB
- Structural coverage and limitations
SE39
Test process, plans and defect reports
- Test process and monitoring
- Plan objectives/scope/resources/schedule/risks
- Entry/exit criteria
- Analyze basis: testable features, defects
- Design cases and expected results
- Implement data/scripts/environment
- Execute, compare, report defects
- Evaluate completion
- Analysis: what/testability
- Design: how
- Monitoring/control throughout
👁 Full explanation
Plan objectives, scope, resources, schedule, risks and entry/exit criteria. Analyze the test basis for testable features and defects; design cases/expected results; implement data, scripts and environment; execute and compare; report defects; evaluate completion. Analysis asks what to test and assesses testability; design asks how. Monitoring/control run across these activities. - Test plans and defect reports
- Plan: intended work
- Incident/defect reports: normally execution outputs
- Report build/environment
- Reproduction steps
- Expected versus actual behavior
- Evidence and severity
- Anyone finding fault should record
- Testers often coordinate, no exclusive permission
- Configuration control: reproducible tested version
👁 Full explanation
A test plan describes intended work; incident/defect reports are normally execution outputs. A defect report should identify build/environment, steps, expected versus actual behavior, evidence and severity. Anyone finding a fault should record it; testers often coordinate reporting, but it is not their exclusive permission. Configuration control makes the tested version reproducible.
4 related practice questions
Note references: SE-M, SE-TEST
- Test process and monitoring
SE40
Maintenance and software evolution
- Maintenance categories and cost
- Corrective: fix faults
- Adaptive: environment changes
- Perfective: useful capability/performance improvement
- Preventive: reduce future risk
- Fragile-code restructuring example
- Motive determines category
- Refactoring: preventive or perfective support
- Years of legacy-code understanding
- Regression effort
- Maintenance may dominate lifecycle cost
👁 Full explanation
Corrective maintenance fixes faults; adaptive maintenance responds to environment changes; perfective maintenance improves useful capability/performance; preventive maintenance reduces future risk, such as restructuring fragile code. Motive determines category; refactoring can support preventive or perfective work. Maintenance often lasts years and includes understanding legacy code and regression effort, so it may dominate lifecycle cost. - Evolution workflow and restructuring
- Request → impact analysis → release planning
- Implementation/testing → release
- Request absent: impact analysis earliest listed
- Major restructuring: reengineering
- Architecture changed: architectural transformation more specific
- Markets/technology/stakeholders/funding change scope/priorities
👁 Full explanation
A typical evolution sequence is change request→impact analysis→release planning→implementation/testing→release. Among a list lacking the request step, impact analysis may be the earliest listed technical activity. Major restructuring is reengineering; if the architecture itself changes, architectural transformation is the more specific description. Markets, technology, stakeholders and funding can all change scope or priorities.
7 related practice questions
Note references: SE-M, SE-N, SE-G
- Maintenance categories and cost
SE41
Numerical and option defects
- Scheduling question defects
- Earliest finish: 9 days
- Correct answer absent
- Slack: latest time − earliest time
- Zero slack requires supplied completion-path assumption
- Equal critical paths: 11 days
- Both corresponding options true
- Network rules before supplied key
👁 Full explanation
The earliest-finish example yields 9 days. Zero slack follows only from an explicit completion-path assumption when latest times or the full network are unavailable. In the path-duration example, two paths each total 11 days. Use the network rules to justify the calculation before comparing it with an answer key. - Multiple-answer and invalid-choice defects
- Architectural structures and views
- Evaluate each statement independently
- Reusable requirements, tests, and architecture
- Requirements/tests/architecture: reusable product-line assets
- Correct options or multiple-answer instruction needed
- Defective options don't justify false rules
👁 Full explanation
Evaluate descriptions of architectural structures and views separately; both can be true. Evaluate the individual claims before considering a combined option, especially if the option refers to itself. Requirements, tests and architecture can all be reusable product-line assets. When several choices satisfy the rules, identify the needed distinction rather than selecting a false rule.
6 related practice questions
Note references: SE-M, SE-N, SE-G
- Scheduling question defects
SE42
Context-dependent claims and model limitations
- Missing context and classification limits
- No always-most-time-consuming test level
- Team inexperience doesn't determine process
- Waterfall doesn't make later changes impossible
- Requirements include required/prohibited behavior
- Interface functions versus usability qualities
- Exact interface obligation needed
- Functional/nonfunctional classification depends on obligation
👁 Full explanation
Context matters: no test level is always most time consuming; no process is determined by team inexperience alone; no waterfall rule makes every later change impossible. Requirements may describe required and prohibited behavior, including interface functions as well as usability qualities. Identify an interface requirement’s exact obligation before classifying it as functional or nonfunctional. - Model and process qualifications
- Sequence/state both dynamic behavior
- Composition: diamond placement plus ownership
- Safety-critical government Agile unsuitability claim
- Assumes lightweight process without required assurance
- Not universally true
- Guide conventions: scenario hints
- Stronger engineering rules explicit
👁 Full explanation
Sequence/state diagrams both show dynamic behavior. Composition needs the diamond’s placement and ownership semantics. “Agile least suitable for safety-critical government work” assumes a particular lightweight process without required assurance; it is not universally true. Treat the guide’s conventions as scenario hints and keep the stronger engineering rules explicit.
66 related practice questions
Note references: SE-M, SE-N, SE-G
- Missing context and classification limits
SE43
Design trade-offs and economical improvement
- Goal-based design trade-offs
- Fine-grained self-contained components
- Producer/consumer separation
- Limited shared mutable data
- Often improve maintainability
- Interfaces may add latency
- Isolation may complicate transactions
- Global state: local simplicity, wider coupling
- Measurable quality scenarios
- Component counts alone insufficient
👁 Full explanation
Choose designs by their effect on stated goals. Fine-grained self-contained components, separation of producers/consumers and limited shared mutable data often improve maintainability. Trade-offs remain: interfaces can add latency, isolation can complicate transactions, and global state can simplify one operation while coupling many others. Prefer measurable quality scenarios to counting components alone. - Pareto and economical improvement
- 80/20: prioritization heuristic
- Few causes may dominate observed impact
- No exact 80%-defects/20%-effort guarantee
- Refactoring: behavior preserved, structure improved
- Optimize against measured needs
- Record rationale
- Update traceability/regression evidence after change
👁 Full explanation
Pareto’s 80/20 rule is a prioritization heuristic: a small subset of causes may account for much of the observed impact. It does not guarantee 80% of defects can be fixed with exactly 20% effort. Refactor to preserve behavior while improving structure; optimize only against measured needs; record rationale and update traceability and regression evidence after change.
4 related practice questions
Note references: SE-M, SE-N, SE-G
- Goal-based design trade-offs
No matching topics. Clear the search or change the filter.
Blueprint learning outcomes
- SE-LO1 · Understand software analysis, design and development techniques and tools
SE01, SE02, SE08, SE09, SE10, SE11, SE12, SE13, SE17, SE19, SE20, SE21, SE25, SE33, SE34, SE35 - SE-LO2 · Demonstrate conceptual and technical skills in the analysis, design and implementation of a software system
SE13, SE17, SE19, SE21, SE25, SE26, SE33, SE35 - SE-LO3 · Create requirements using use case modeling concepts
SE11, SE13, SE14, SE15, SE16