Software Engineering + AI > Software Engineering Basics > Flashcards

Software Engineering Basics Flashcards

(171 cards)

Study These Flashcards
1
Q

What is the classic V in systems engineering?

A
  • Stakeholder needs & concept of operations
  • System requirements
  • Architecture & high-level design
  • Detailed design
  • Implementation (hardware/software build, integration)
  • Unit/component verification
  • Subsystem verification
  • System verification
  • System validation against stakeholder needs

Each level on the left has a mirror verification activity on the right.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
2
Q

What does Agile emphasize?

A
  • Iterative, incremental delivery
  • Evolving requirements (backlog refinement)
  • Frequent integration and feedback
  • Working software (or functionality) over big up-front design

Agile methodologies include Scrum, Kanban, etc.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
3
Q

True or false: The V should be treated as one giant, once-per-program waterfall.

A

FALSE

Instead, the V should be kept as a logical structure with Agile cycles running inside and across multiple small Vs.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
4
Q

What is the mental model for combining Agile with the V?

A

The V is the spine, Agile is how you walk along the bottom and right side.

This model helps in visualizing the integration of Agile practices within the V framework.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
5
Q

Describe the Pattern A of integrating Agile with the V.

A
  • Systems engineering V is used at the system level
  • Implementation on the bottom of the V is done using Agile
  • Software teams use an Agile backlog for requirements
  • Implementation happens in sprints with continuous integration
  • Verification & validation events trace back to the V

This pattern is most common for software development.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
6
Q

What is the Pattern B approach in Agile and the V integration?

A
  • Define a top-level system architecture and key constraints
  • Structure work as increments, each with its own mini-V
  • Clarify increment-level objectives
  • Implement/integrate using Agile sprints
  • Maintain requirements hierarchy and traceability

This pattern allows for incremental and evolutionary systems engineering.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
7
Q

What does Pattern C involve in the context of Agile and the V?

A
  • Use Agile/Lean discovery on the left side
  • Feed learning into system requirements and architecture
  • Use Agile delivery for continuous integration and testing
  • Update requirements and design for future increments

This pattern emphasizes continuous learning loops around the V.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
8
Q

How do Agile artifacts map onto the V?

A
  • Stakeholder needs → Themes / Vision
  • System requirements → Epics / Capabilities
  • Subsystem/software requirements → Features / User Stories
  • Interface requirements → Definition of Done constraints

This mapping helps in aligning Agile practices with systems engineering processes.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
9
Q

What are the roles of the systems engineering team in a project?

A
  • Establish mission needs
  • Define system requirements and top-level architecture
  • Build/maintain an MBSE model
  • Define verification strategy

The systems engineering team ensures that the foundational aspects of the project are well-defined.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
10
Q

What do Agile software teams do in a project?

A
  • Pull traceable requirements into a backlog
  • Implement features in sprints
  • Frequent integration on target-like hardware
  • Demo incrementally to stakeholders

Agile software teams focus on iterative development and stakeholder engagement.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
11
Q

What is the core takeaway regarding Agile and the systems engineering V?

A
  • The V gives you structure, traceability, and assurance
  • Agile gives you the way you move through that structure iteratively and incrementally

This highlights the complementary nature of Agile and the V in systems engineering.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
12
Q

What is the goal of the Discovery & Vision phase in Agile?

A

Understand why we’re building something and for whom

Turn fuzzy intent into an initial product vision and high-level scope.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
13
Q

Name the action types in the Discovery & Vision phase.

A
  • Stakeholder & user research
  • Vision & value definition

These actions help clarify the product vision and its value.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
14
Q

What is a use case for stakeholder interviews?

A

Product Owner interviews mission ops engineers about needing a faster way to see out-of-bound telemetry values

This helps gather requirements directly from stakeholders.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
15
Q

What is a Product Vision statement?

A

A statement that defines the overarching goal of the product

Example: “Provide a real-time, zero-click dashboard for detecting and responding to anomalous spacecraft telemetry during ground tests.”

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
16
Q

What is the goal of the Backlog Definition & Refinement phase?

A

Turn vision into a prioritized, actionable backlog of work

This phase ensures that the team has clear tasks to work on.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
17
Q

What are the action types in the Backlog Definition & Refinement phase?

A
  • Requirement decomposition → backlog items
  • Backlog refinement (grooming)
  • Prioritization

These actions help create and maintain a clear backlog.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
18
Q

What is a use case for epic definition?

A

Defining a large feature that spans several sprints, like “Real-time Anomaly Detection”

This helps organize related tasks under a common goal.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
19
Q

What is the goal of the Iteration / Sprint Planning phase?

A

Decide what will be delivered this sprint and how the team will approach it

This phase sets the direction for the upcoming sprint.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
20
Q

What are the action types in the Iteration / Sprint Planning phase?

A
  • Sprint scope selection
  • Task breakdown

These actions help define the work for the sprint.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
21
Q

What is a use case for capacity-based planning?

A

Team knows they can typically deliver 25 story points and selects stories totaling that amount

This helps ensure the team commits to a manageable workload.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
22
Q

What is the goal of the Design (UX & Technical) phase?

A

Decide how to build the selected stories with just enough design to move forward safely

This phase focuses on planning the implementation.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
23
Q

What are the action types in the Design (UX & Technical) phase?

A
  • UX / interaction design
  • Technical design

These actions help create a blueprint for development.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
24
Q

What is a use case for wireframing?

A

Designer sketches a simple table UI for telemetry channels

This helps visualize the user interface before development.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
25
What is the **goal** of the **Implementation (Coding & Build)** phase?
Turn backlog items into working, tested software increments ## Footnote This phase is where actual coding happens.
26
What are the **action types** in the **Implementation (Coding & Build)** phase?
* Coding * Version control & branching * Build & continuous integration (CI) ## Footnote These actions ensure code is developed and integrated properly.
27
What is a **use case** for **automated builds**?
Every push triggers CI to run builds for backend and front-end ## Footnote This ensures that the code compiles successfully in a clean environment.
28
What is the **goal** of the **Testing & Quality Assurance** phase?
Get fast feedback that changes are correct, safe, and meet acceptance criteria ## Footnote This phase ensures the quality of the software.
29
What are the **action types** in the **Testing & Quality Assurance** phase?
* Automated testing * Exploratory & manual testing * Definition of Done (DoD) enforcement ## Footnote These actions help verify that the software meets requirements.
30
What is a **use case** for **unit tests**?
A unit test checks that a channel with value 101 and upper threshold 100 is flagged as “out-of-bound” ## Footnote This ensures individual components work as expected.
31
What is the **goal** of the **Integration, Release & Deployment** phase?
Deliver working software into an environment where real users can benefit from it ## Footnote This phase focuses on making the software available.
32
What are the **action types** in the **Integration, Release & Deployment** phase?
* Environment management * Release management ## Footnote These actions ensure smooth deployment and release of the software.
33
What is a **use case** for **continuous delivery pipeline**?
On merge to `main`, the system automatically deploys to a staging environment ## Footnote This allows for system-level testing before production.
34
What is the **goal** of the **Monitoring, Feedback & Continuous Improvement** phase?
Learn from usage, detect problems, and improve both the product and the process ## Footnote This phase focuses on ongoing enhancement.
35
What are the **action types** in the **Monitoring, Feedback & Continuous Improvement** phase?
* Operational monitoring * Feedback collection * Process improvement (retrospectives) ## Footnote These actions help gather insights for future improvements.
36
What is a **use case** for **user feedback sessions**?
Team runs a retrospective with test engineers after a test campaign ## Footnote This helps gather insights on the product's effectiveness.
37
In Agile, the phases are not big sequential blocks; they are **sets of actions** that show up every sprint, but with different emphasis. What is emphasized early on?
More **discovery and design** actions ## Footnote This helps clarify the product vision and design before implementation.
38
What is the **mental model** used to describe Agile inside the V?
Systems V = logical structure ## Footnote Left: stakeholder needs → system/software requirements → design; Bottom: implementation & integration; Right: verification & validation vs those requirements.
39
What is the goal of the **Discovery & Vision** phase?
Understand why you’re building the software, the context in the system, and the key outcomes ## Footnote This phase involves stakeholder and user research.
40
Name the **action types** involved in the Discovery & Vision phase.
* Stakeholder & user research * Requirements derivation * Software safety * Software security * Version control * Documentation * TDD ## Footnote Each action type contributes to clarifying stakeholder objectives and constraints.
41
What is an example of a **stakeholder interview** use case?
Product Owner interviews mission ops and test engineers ## Footnote Example question: What pain points exist with current telemetry tools?
42
What does the **requirements derivation** process clarify?
* Stakeholder objectives * High-level constraints ## Footnote These turn into early epics and themes.
43
What is a **safety goal** example in the context of software development?
System shall clearly indicate out-of-limit conditions within X seconds ## Footnote This addresses potential hazards identified upfront.
44
What is the purpose of **version control** in the early phases of development?
Start a repo for initial notes, diagrams, ADRs ## Footnote This establishes a history from day one.
45
What is the goal of the **Backlog Definition & Refinement** phase?
Turn fuzzy needs into a prioritized, implementable backlog ## Footnote This involves requirement decomposition into backlog items.
46
What are the **subtypes** of action types in Backlog Definition & Refinement?
* Epic definition * Feature / capability definition * User stories * Backlog refinement (grooming) * Prioritization ## Footnote Each subtype helps in structuring the backlog effectively.
47
What is an example of an **epic definition** use case?
Real-time Anomaly Detection as an epic encompassing UI + backend + performance ## Footnote This helps in organizing related features.
48
What does **story slicing** refer to in backlog refinement?
Breaking down a larger story into smaller, manageable parts ## Footnote Example: “Build anomaly dashboard” becomes multiple smaller tasks.
49
What is the **Definition of Ready (DoR)**?
A story is not allowed into a sprint until acceptance criteria written, test data examples identified, and external dependencies understood ## Footnote This ensures stories are well-prepared for implementation.
50
What prioritization method is mentioned in the document?
WSJF / cost-of-delay ## Footnote This method helps prioritize tasks based on their impact on risk reduction.
51
What are **non-functional requirements** examples mentioned?
* Latency * Throughput * Reliability ## Footnote These become story-level constraints during backlog refinement.
52
What does TDD stand for?
Test-Driven Development ## Footnote This approach involves defining testable acceptance criteria before coding.
53
What is a **safety-critical behavior** example in software stories?
Enter safe mode when data stale ## Footnote This ensures safety measures are integrated into the software.
54
What is a **security requirement** example mentioned?
Only authenticated users can acknowledge alarms ## Footnote This ensures that security measures are in place for system integrity.
55
What does **documentation** in the backlog phase involve?
* Living architecture overview * Interface contracts ## Footnote This helps maintain clarity and structure in the development process.
56
What is the **goal** of Iteration / Sprint Planning?
Decide what to deliver in the next sprint and how you’ll approach it ## Footnote This involves selecting the scope of the sprint and defining tasks.
57
What is the **action type** for Sprint scope selection?
Sprint scope selection ## Footnote This includes capacity-based planning and sprint goal definition.
58
What is a **use case** for capacity-based planning?
Team has ~25 points of capacity; they pull: * Basic anomaly highlighting * A spike on streaming performance * Minimal config loading ## Footnote This helps in determining what can be realistically achieved in the sprint.
59
What is a **sprint goal definition** use case?
Enable engineers to see real-time highlighting of out-of-limit channels for a selectable set of telemetry points ## Footnote This defines the primary objective for the sprint.
60
What is the **action type** for Task breakdown?
Task breakdown ## Footnote This includes implementation tasks and test & quality tasks.
61
List the **implementation tasks** for highlighting out-of-limit channels.
* Parse threshold config * Calculate out-of-limit conditions * Render highlight in UI ## Footnote These tasks are essential for the feature's development.
62
What are the **test & quality tasks** for the project?
* Create representative test dataset * Write unit tests for threshold logic * Add UI snapshot/behavior tests ## Footnote These ensure the quality and reliability of the implementation.
63
What might the **Definition of Done** require?
* Unit tests written and passing * Security checks run * Documentation updated * Code merged via PR with review ## Footnote This ensures that all necessary criteria are met before considering a task complete.
64
What is a **cross-cutting** concern in this phase?
Requirements derivation ## Footnote This involves clarifying assumptions and potentially splitting or rewriting stories.
65
What does **TDD** stand for?
Test-Driven Development ## Footnote This approach emphasizes writing tests before implementation.
66
What are some **safety tasks** to add?
* Add sanity checks for impossible sensor values * Validate all input coming from streaming feed; log suspicious patterns ## Footnote These tasks help ensure the safety and security of the software.
67
What is the **goal** of the Design (UX & Technical) phase?
Decide how to build selected stories with enough design to move forward safely ## Footnote This involves both UX and technical design considerations.
68
What is an **action type** in UX / interaction design?
UX / interaction design ## Footnote This includes creating wireframes, low-fidelity mockups, and proto models.
69
What is a **use case** for wireframes / low-fidelity mockups?
Designer sketches table layout: channels as rows, latest values as cells, red highlight for anomalies ## Footnote This helps visualize the user interface before implementation.
70
What is an **action type** in Technical design?
Technical design ## Footnote This includes API & data model design and architecture decisions.
71
What is a **use case** for API & data model design?
Define: * GET /telemetry/anomalies * TelemetryChannel, AnomalyEvent schemas ## Footnote This establishes the structure for data interactions.
72
What is a **spike** in technical design?
Simulate 5,000 channels and measure latency with and without compression ## Footnote This is a technical experiment to assess performance.
73
What might design trigger in terms of **requirements derivation**?
* We need a max channel count * We need a heartbeat for telemetry feed ## Footnote These new requirements may go back into the backlog as refined stories.
74
What does **software safety** architecture include?
* Safe states and fallbacks * Watchdogs that detect stalled UI or backend loops ## Footnote These measures help ensure the system operates safely under various conditions.
75
What are some **design security mechanisms**?
* Authentication & authorization * Encryption of telemetry and commands * Logging strategy for security incidents ## Footnote These mechanisms protect the system from unauthorized access and ensure data integrity.
76
What should be included in **documentation** during the design phase?
* Architecture overview updated or created * Component diagrams * Sequence diagrams for telemetry processing ## Footnote This documentation aids in understanding the system's structure and flow.
77
What is the goal of **Implementation** in coding and build?
Turn stories into working, testable code ## Footnote This includes various action types such as coding, version control, and build & CI.
78
Name the **subtypes** of action type **Coding**.
* Feature implementation * Refactoring * Pair / mob programming ## Footnote Each subtype has specific use cases for improving code quality and collaboration.
79
What is a use case for **Feature implementation**?
Implement threshold comparison and UI highlight ## Footnote This involves adding new features to the software.
80
What does **Refactoring** involve?
Combine various parsing functions into one robust config loader ## Footnote This improves code maintainability and efficiency.
81
What is the purpose of **Pair / mob programming**?
Two devs pair on new anomaly logic, cross-checking for edge cases ## Footnote This enhances code quality through collaboration.
82
What are the **subtypes** of action type **Version control & branching**?
* Feature branches * Pull requests / merge requests * Trunk-based with feature flags ## Footnote These practices help manage code changes and collaboration.
83
What is a use case for **Pull requests / merge requests**?
Dev opens PR; reviewer checks: correctness, test coverage, performance, safety/security adherence ## Footnote This ensures code quality before merging.
84
What does **Trunk-based with feature flags** allow?
Incomplete features are merged behind a flag ## Footnote This enables deployment without exposing unfinished features.
85
What is the goal of **Build & CI**?
Fast feedback that changes are correct, safe, secure, and meet requirements ## Footnote This involves automated processes to ensure code quality.
86
What triggers **Automated builds**?
Every push ## Footnote This includes building the backend, bundling the frontend, and running tests.
87
What is a use case for **Static analysis / linting**?
Tools catch potential overflow or unsafe calls ## Footnote This helps identify issues before runtime.
88
What does **Unit test execution in CI** ensure?
CI fails if new unit test for threshold logic fails ## Footnote This blocks merges until tests pass.
89
What is a key aspect of **Software safety** during implementation?
Defensive coding around external inputs ## Footnote This helps prevent vulnerabilities from user inputs.
90
What is the purpose of **Input validation** in software security?
Ensure only valid data is processed ## Footnote This protects against malicious inputs.
91
What should every change in version control be committed with?
Meaningful messages ## Footnote This aids in traceability and understanding of changes.
92
What is the goal of **Automated testing**?
Fast feedback that changes are correct, safe, secure, and meet requirements ## Footnote This includes various types of tests to validate functionality.
93
What is a use case for **Unit tests**?
test_thresholds.cpp validates: Value below lower limit → 'LOW', Between limits → 'OK', Above upper → 'HIGH' ## Footnote This ensures individual components work as intended.
94
What is the purpose of **Exploratory & manual testing**?
To discover issues through hands-on testing ## Footnote This complements automated testing by exploring edge cases.
95
What does the **DoD checklist** ensure?
Story not closed until: unit & integration tests passing, safety/security criteria checked, docs updated, feature demoed ## Footnote This enforces quality standards before completion.
96
What is a key aspect of **TDD**?
Write a failing test first for each new behavior ## Footnote This approach ensures that new features are validated before implementation.
97
What is the goal of **Documentation** in the context of testing?
Update docs in the same PR: README changes for setup, API docs for new endpoints ## Footnote This keeps documentation current with code changes.
98
What does **lean meaning** refer to in the context of eliminating waste?
Anything that doesn’t add value to the customer is waste: * Partially done work * Extra features * Unnecessary paperwork * Waiting * Handoffs * Defects ## Footnote Lean principles focus on maximizing value by minimizing waste.
99
During **discovery & backlog**, what should you focus on to cut vague/low-value ideas early?
Focus on the few workflows that matter most ## Footnote Example: Anomaly triage during tests instead of every 'nice to have.'
100
What is the purpose of **requirements derivation** in lean methodology?
Shapes small, high-value stories, avoiding 'overproduction' of requirements ## Footnote This prevents creating features that no one will use.
101
What does **WSJF** stand for in backlog refinement?
Weighted Shortest Job First ## Footnote This prioritization method stops teams from building low-impact features while critical needs are unmet.
102
What is meant by **just-enough design**?
Avoid spending weeks on a giant architecture that might never be fully implemented ## Footnote Focus on practical and necessary design elements.
103
What does **TDD** stand for and what does it eliminate?
Test-Driven Development; eliminates defect waste early ## Footnote This leads to fewer bug-hunt cycles later.
104
What is the purpose of **automated tests in CI**?
Reduce: * Manual regression testing overhead * Waiting for QA to find obvious breakages ## Footnote Continuous Integration (CI) enhances testing efficiency.
105
What does **docs-as-code** mean?
Just enough, always current documentation maintained in the repo ## Footnote This approach avoids giant dead PDFs.
106
What are **feature flags** used for in deployment?
Avoid big-bang deployments that cause massive rework if they fail ## Footnote They allow for controlled feature releases.
107
What is the lean meaning of **amplifying learning**?
Software development is discovery; tight feedback loops, many small experiments, and explicit knowledge capture ## Footnote This fosters continuous improvement.
108
What is the role of **spikes** in backlog and refinement?
Spikes serve as 'learning stories' ## Footnote Example: 'Spike: WebSocket performance under lab conditions.'
109
What does **living documentation** refer to?
ConOps, troubleshooting guides, and 'known issues' updated after each test campaign ## Footnote This ensures documentation remains relevant.
110
What does **decide as late as possible** mean in lean methodology?
Keep options open; make irreversible decisions as late as possible ## Footnote This allows for decisions based on real data instead of guesses.
111
What is the benefit of keeping stories **small and independent**?
You don’t commit to a huge up-front scope; adapt based on feedback ## Footnote This enhances flexibility in project management.
112
What are **AB/canary experiments** used for?
Decide on UX, thresholds, or algorithm variants based on live data ## Footnote This approach reduces speculation in decision-making.
113
What is a **concrete example** of deferring commitment in design?
Initially support static thresholds from config; design data model for future dynamic thresholds ## Footnote This allows for adaptability based on real-world behavior.
114
What does **Lean** mean in the context of workflow?
Shorten cycle time for faster learning and adaptation ## Footnote Speed refers to fast validated learning, not reckless hacking.
115
What are the **sprints/iterations** in an integrated workflow?
* 1–2 week iterations * Each delivers a potentially shippable increment ## Footnote Even if behind a flag, each iteration aims for a deliverable product.
116
What does **CI/CD** stand for?
* Continuous Integration * Continuous Deployment ## Footnote Every commit is built automatically, with tests run and deployable artifacts created.
117
What are the benefits of **TDD + automated tests**?
* Clear acceptance criteria * Reduces manual regression time * Minimizes firefighting ## Footnote This leads to less back-and-forth in requirements derivation.
118
What are **pre-baked patterns** in safety and security?
* Standard safety mechanisms (state machines, watchdogs) * Standard security patterns (auth middleware, encryption libraries) ## Footnote These patterns prevent delays caused by starting from scratch each time.
119
What is the purpose of **release notes templated and partially generated**?
Faster communication ## Footnote This helps streamline the documentation process.
120
In a single sprint, what can you implement and test?
* Basic anomaly highlighting * Ship it behind a flag to one test rig * Get real feedback from one test campaign ## Footnote This approach contrasts with waiting six months for a full dashboard.
121
What does **Empower the Team** mean in Lean methodology?
Authority, information, and support for decision-making ## Footnote This principle emphasizes respect for people doing the work.
122
Who is involved in **refining stories** in the integrated workflow?
* Developers * Testers * Systems engineers * Operations ## Footnote Collaboration helps identify risks and edge cases.
123
What is the role of **management** in the context of team empowerment?
Remove blockers, not dictate every move ## Footnote Management supports the team's autonomy in decision-making.
124
What does **pair/mob programming** promote?
Shared ownership and collective code stewardship ## Footnote This practice encourages collaboration among team members.
125
What happens during **retrospectives & improvement**?
Teams choose their own process improvements ## Footnote Examples include adopting TDD or adding a pre-merge security checklist.
126
What is an example of a team-driven improvement?
Creating a simulator to avoid waiting for test data ## Footnote Management supports this initiative even if it doesn't ship visible features.
127
What does **Lean meaning** imply about quality?
Quality isn’t inspected in at the end; it’s built in at every step ## Footnote Integrity is both conceptual and perceived.
128
What are the components of **requirements derivation**?
* Non-functional requirements (latency, safety, reliability, security) ## Footnote These requirements are essential for a comprehensive system design.
129
What should the architecture be designed for?
* Clear boundaries * Minimal coupling * Clear states ## Footnote These design principles enhance system integrity.
130
What are considered **first-class** in the integrated workflow?
* Safety * Security ## Footnote Hazard/threat analysis should start from the beginning.
131
What does **TDD** stand for?
Test-Driven Development ## Footnote Unit tests define correct behavior locally.
132
What types of tests validate the system as a whole?
* Integration tests * End-to-End tests ## Footnote These tests ensure the system behaves correctly as a complete entity.
133
What are essential tests that should not be optional?
* Safety/security tests (fault injection, negative tests) ## Footnote These tests are crucial for maintaining system integrity.
134
What do **code reviews** check for?
* Correctness * Readability * Test coverage ## Footnote Safety and security aspects are also reviewed.
135
What is the purpose of **continuous verification**?
CI running tests on every change ## Footnote This prevents regressions from sneaking in.
136
What does **static analysis** help catch?
Common errors early ## Footnote This is part of maintaining code quality.
137
Why is it important to keep **documentation and models** aligned with the code?
Ensures conceptual integrity ## Footnote This alignment helps maintain clarity and coherence in the system.
138
What is the goal of **user docs and training**?
Ensure perceived integrity ## Footnote The system should behave as operators expect.
139
In the concrete example, what is derived for **safe mode**?
Precise software requirements ## Footnote This includes implementing TDD at the function level.
140
What does **Lean meaning** imply about optimizing teams?
Don’t locally optimize a single team or stage and harm the overall system ## Footnote Look at the full value stream.
141
What does the **V** in systems engineering represent?
The whole-system view ## Footnote It connects stakeholder needs to system requirements and beyond.
142
What is important for **requirements derivation + traceability**?
Understanding how a single story relates to mission level safety ## Footnote This includes hardware constraints and ground operations.
143
What should cross-functional collaboration involve?
Systems, software, test, and ops working together ## Footnote This prevents local 'perfect but useless' solutions.
144
What is measured from a **value stream perspective**?
* Lead time from idea to running in test/ops * Defect escape rates ## Footnote This helps identify process improvements.
145
What should process improvements target?
The biggest bottlenecks, not just the easiest ones ## Footnote This ensures effective optimization.
146
What is a **lean behavior** when facing blocked integration tests?
Invest in better simulation tools ## Footnote This improves overall testing efficiency.
147
What are the **three core ideas** of Kanban in software?
* Visualize the work * Limit Work In Progress (WIP) * Measure and manage flow ## Footnote These ideas help in managing workflow effectively.
148
In Kanban, what does it mean to **visualize the work**?
Use a board with columns representing states in your process ## Footnote Each piece of work is represented as a card, allowing visibility into current tasks and bottlenecks.
149
What is the purpose of **limiting Work In Progress (WIP)** in Kanban?
Forces the team to finish work before starting more ## Footnote This reduces context switching and surfaces bottlenecks in the process.
150
How does Kanban help to **measure and manage flow**?
* Track cycle time * See where cards pile up * Adjust process to improve flow ## Footnote Monitoring these aspects helps in optimizing the workflow.
151
True or false: Kanban replaces the **V-model** or agile workflow.
FALSE ## Footnote Kanban sits on top of existing workflows as a flow-management layer.
152
What are the **phases** that Kanban can be mapped onto in an existing workflow?
* Discovery & Vision * Backlog Definition & Refinement * Sprint Planning / Commit * Design * Implementation (with TDD) * Testing & QA * Integration & Release * Monitoring & Improvement ## Footnote These phases can integrate Kanban practices without abandoning existing methodologies.
153
What is a **Kanban board** used for?
To mirror your end-to-end flow in the workflow ## Footnote It visually represents the status of tasks and helps manage the flow of work.
154
Fill in the blank: A **Kanban board** includes columns such as **Discovery**, **Ready for Derivation**, and __________.
Deriving Requirements ## Footnote These columns represent different states in the workflow.
155
What does the **'Ready for Test'** column indicate in a Kanban board?
Feature implemented, unit tests passing, deployed to test environment ## Footnote This signifies that the feature is ready for testing.
156
What are some **swimlanes or tags** that can be used in a Kanban board?
* Safety-critical * Security-related * Infrastructure / test harness * Documentation/traceability ## Footnote These tags help categorize tasks and ensure visibility of important work.
157
What is the significance of having a **safety story** and a **doc story** on the Kanban board?
They are first-class citizens on the board, not invisible 'side work' ## Footnote This ensures that all types of work are visible and prioritized.
158
What is the purpose of **dedicated columns** in Kanban for requirements derivation?
* Make it obvious how many items are currently undergoing derivation * Help identify bottlenecks in the process ## Footnote Columns like “Ready for Derivation”, “Deriving Requirements”, and “Ready for Design” enhance visibility.
159
What do **WIP limits** on derivation help with?
* Forces focus on finishing a few items well * Prevents multiple items from being half-done ## Footnote An example limit could be a maximum of 3 cards in “Deriving Requirements”.
160
How can **safety/security tags or swimlanes** be beneficial in Kanban?
* Quickly identify if safety/security derivation is lagging behind functional derivation ## Footnote This helps prioritize critical safety/security tasks in the workflow.
161
What is a common problem in the **design phase** that Kanban addresses?
* UX and technical design get overrun or skipped ## Footnote This can lead to incomplete or poorly designed features.
162
What does a **design-specific column** with a WIP limit help to manage?
* Keeps design focused and thorough * Prevents too many features from entering design at once ## Footnote An example limit could be 2 design items at a time.
163
What are the **work policies** for the design phase in Kanban?
* Design is done only when: ADR written, APIs defined, safety/security considered, testability reviewed ## Footnote These policies ensure comprehensive design before moving to development.
164
What issue does Kanban help with in the **implementation phase**?
* Developers multitask across 5+ stories ## Footnote This can lead to stories lingering partially implemented.
165
What is the purpose of a **Dev + TDD column** with a WIP limit?
* Ensures each developer ideally works on one story at a time ## Footnote This helps maintain focus and quality in development.
166
What must be done before moving a card to **'Ready for Test'**?
* Tests must be written and passing * PR must be merged ## Footnote This ensures that code quality is maintained before testing.
167
What does having separate **'Ready for Test'** and **'Testing in Progress'** columns achieve?
* Helps identify bottlenecks in testing * Ensures safety-critical items receive proper testing ## Footnote WIP limits can be applied to the 'Testing in Progress' column.
168
What is a common problem in the **integration and release phase** that Kanban addresses?
* Work stuck in limbo between testing and actual deployment ## Footnote This can delay the release of completed features.
169
What do the columns **'Ready for Release'**, **'Released to Test/Flight'**, and **'Validated & Done'** provide?
* Visibility into deployment status * Tracking of what is currently in production vs staging ## Footnote This helps manage the release process effectively.
170
How does Kanban help with **documentation and traceability**?
* Makes documentation tasks explicit cards * Ensures traceability tasks are visible ## Footnote This can include tasks like updating SysML models or V&V matrices.
171
What is the **Definition of Done** in Kanban documentation?
* Card has a checklist: tests written and passing, safety/security impacts updated, docs updated ## Footnote A card cannot move to 'Done' until all checklist items are completed.
Software Engineering + AI
flashcards
Decks in class (43)
# Cards
Brainscape helps you reach your goals faster, through stronger study habits.
© 2026 Bold Learning Solutions. Terms and Conditions