COMP23311 Software Engineering Review

0.0(0)
Studied by 0 people
call kaiCall Kai
learnLearn
examPractice Test
spaced repetitionSpaced Repetition
heart puzzleMatch
flashcardsFlashcards
GameKnowt Play
Card Sorting

1/382

flashcard set

Earn XP

Description and Tags

Comprehensive practice flashcards covering software complexity, system definitions, Brooks's 'No Silver Bullet', V&V concepts by Boehm and Ryan & Wheatcraft, unit testing, and design trade-offs.

383 Terms

1
New cards
what does it mean that a component is a coherent part of a software system
Coherent means it hangs together as one thing and has a reason to be treated separately. This is slightly circular, so you're expected to use judgement.
2
New cards
what is a unit
Unit: a component with no subcomponents, the smallest thing you'd bother to treat as a part.

What counts as a unit depends on your notion of component. In Python you might say a function is a unit, but you could also drill into its lines.
3
New cards
What is granularity
Granularity: components nest. A system contains components, which contain components, down to units. Where you stop is your choice, and you should be able to justify it.
4
New cards
The FizzBuzz script alone is one component. To actually run it you also need: Python runtime (e.g. CPython 3.12), OS and system calls, CPU/memory, a terminal or IDE, a display, perhaps a file system, and a person to run it.

What is wide scope versus narrow scope
Wide scope: include all of those. Narrow scope: consider just the script.

Usually the surrounding parts behave identically every time, so you can ignore them. But sometimes they matter (e.g. a different Python version, a full disk, a different OS).
5
New cards
what is a critical skill in terms of a wide and narrow view
judging when you must widen your view and when a narrow view is safe.

The scope also changes the execution path. With a narrow scope, a path is something like a Python trace; with a wide scope it could be CPU and memory state changes. Both are valid, but you need to say which you mean.
6
New cards
what is an execution path
An execution path is one complete way the system can run, from start to finish. Think of it as a recording of a single run: step 1 happened, then step 2, and so on. The behaviour of the system is the collection of all the different recordings it could produce.
7
New cards
Complexity of software
No two parts are alike, if they are then we make them in to one
8
New cards
static and dynamic definition of a software system
Static definition: Arrangement of components
• Dynamic definition: Set of execution paths
9
New cards
what is a static view of a software sysrtem
“A “system” is

• a construct or collection of different elements that together

• produce results not obtainable by the elements alone.”

The elements, or parts, can include

• people,

• hardware,

• software,

• facilities,

• policies,

• and documents;

• that is, all things required to produce system-level results.
10
New cards
what is a dynamic view of a software system
This is the system as behaviour over time.

Chain of definitions (in order):

State: the condition of a component at a moment (e.g. variable values, what's on screen).

Event: a state of a component (as the slides put it).

Execution path: a sequence of events, i.e. one possible run.

Behaviour: the set of all execution paths.

The set is typically infinite. A program that takes arbitrary input can run in infinitely many ways, which is why we describe behaviour as a set rather than listing it.
11
New cards
For the plain FizzBuzz script, there's only one recording. It loops 100 times, takes the same branch each time for each i, and prints the same thing. Run it a thousand times and you get the same trace.
Does this FizzBuzz script mean there is more than one execution path?
Why the if/elif/else inside doesn't count as multiple paths

The branches (Fizz, Buzz, FizzBuzz, number) all happen within one run, and they happen identically every time. A path is a whole run, so the question to ask is: "Could two runs of this differ?" If not, there's one path.
12
New cards
what actually creates new execution paths?
User input. Version B asks y/n. Type y and you get the FizzBuzz run; type anything else and you get "FizzBuzzkill!". That's 2 paths, because the runs differ.

How the code is used. Once the code is a function in a module, it can be run directly or imported by something else. Those are different situations, so the slides count them as different paths.

The __main__ guard. Now importing does nothing at all, running with y does FizzBuzz, and running with anything else does the kill message. That's 3 paths.
13
New cards
Each count is a claim about the system, and what does the execution path depend on?
you should be able to justify your number. It's not a trick question with one hidden answer.

The count depends on scope. With a narrow scope (just the script), you count Python-level runs. With a wide scope (including the OS, hardware, person running it), there are far more possible event sequences. You choose the level that's useful and say which one you chose.
14
New cards
structure induces (to some degree) behaviour
2 "components"
a "unit" (the function)
the module
1 "component"
which calls the function
1 path
2 paths
1 output
run (and print the output)
Import as module
makes the function available
print the output"
run and type anything else
1 output
15
New cards
programming languages encode ideas about software engineering
• Especially about components
• Python has functions, models, classes, objects, and methods (among other
things) as first class, native "components of a software system"
• Python is designed around these
• Python's design inflects how you structure your systems
16
New cards
what is the unit versus the module here
The function fizzbuzz() is a unit. It's a coherent chunk with a name that you could call from elsewhere, and nothing inside it can be pulled out as a separate part.

The module is the file as a whole, containing the def and the call fizzbuzz() at the bottom. It is a component but not a unit, because it has a subcomponent (the function).

Why this differs from the plain script (1 component): in the plain script, the lines were one inseparable lump. Wrapping them in a function creates a boundary. The function is now a named, reusable thing, and the code outside it (the module-level call) is something else. The logic is identical, but the structure is different
17
New cards
how many components and paths does this have
The two paths are two ways the code can be used:

Run it directly (python3 fizzbuzz.py). Python executes the file top to bottom: it defines the function, then hits fizzbuzz(), which prints the 100 lines.

Import it as a module (import fizzbuzz from some other program). Python still executes the file top to bottom. This makes the function available to the importing program, and it also prints the output, because the call at the bottom runs on import too.

So both paths print the same thing. They count as different paths because they are different situations: one is a person running a script, the other is another program pulling in the code. The importer also ends up holding the fizzbuzzfunction, which it can call again later.

2 “components”

a “unit” (the function)

the module

1 “component”

which calls the function
18
New cards
how many components and paths does this one have
2 "components" -more stuff in the module!
3 paths:
Import as module (no output!)
run and type "y"
run and type anything else

2 outputs
19
New cards
2 reasons we cant expect to see the same growth in software capability as we do with hardware (brooks)
the anomaly isnt that software progress is slow, but that hardware progress is so fast
building software is also difficult
20
New cards
specification testing and design can be harder than representing software (Brooks)
We will make syntax errors, but they are much lower than the conceptual errors present in systems
21
New cards
software systems have orders of magnitude more states than computers do, as well as this, why is it hard to scale up a software system (Brooks)
it isnt just a repetition of the same elements in larger size; we have to increase the number of different elements as well. not only this but elements interact with each other in a none linear fashion
22
New cards
most problems with developing software come from its complexity, what are some example of these problems (Brooks)
difficulty in communicating between team members leading to flaws, cost overruns and schedule delays. its difficult to enumerate and understand all the possible states and from that comes unreliability. it is also hard to create new functions without causing side effects
23
New cards
What are management problems in software development (Brooks)
The complexity makes overview hard, impeding conceptual integrity. It also makes finding and controlling loose ends hard, as well as a learning and understanding gap which makes personnel turnover a disaster
24
New cards
what is an issue with software development in terms of conformity(Brooks)
there are no written rules or reasons by humans and institutions to which software must conform.
25
New cards
how is changeability an issue in software development (Brooks)
Software is constantly subject to pressures for change.
The first change usually comes from users inventing new functions for the software
The second from the fact that software outlives the life of the machine and has to be updated for new machines and peripherals
26
New cards
what does it mean that software is invisible (Brooks)
It isnt embedded in space, so there is no geometric representation that can be studied and critiqued. This not only impedes progress from an individual, but also makes collaboration hard.
27
New cards
how do high level languages help in software development (Brooks)
they free the program of its accidental complexity - the developer does not have to be concerned with bits and registers etc. They eliminate a whole layer of complexity that was never inherent
28
New cards
How does time sharing help improve software development (Brooks)
Time-sharing in is the rapid switching of the CPU)between multiple tasks, programs, or users, giving each one a tiny fraction of time.

Before time-sharing, programmers submitted batch jobs and waited a long time for the compile and run to come back.

During that wait you forget the details, and sometimes the point, of what you were thinking. You have to refresh your memory each time.

The worst effect is that you lose your grasp of everything going on in a complex system.

Time-sharing gives fast responses, which preserves immediacy. That helps the programmer keep the whole picture in their head.
29
New cards
how do unified programming environments such s unix improve software development efficiency (Brooks)
They attack the difficulty in using programs together by providing integrated libraries and unified file formats.
This breakthrough simulated the development of whole tool benches
30
New cards
how did object oriented programming remove another accidental difficulty form the software development process (Brooks)
They allow the designer to express the essence of their design without the needs of large amounts of syntactic material
31
New cards
what is an expert system(Brooks)
a program containing a generalised inference engine and a rule based, designed to take input data and assumptions and explore the logical consequences yielding conclusions and advice.

the most powerful contribution of this would be to service inexperienced programmers
32
New cards
what is automatic programming (Brooks)
self explanatory.
They have favourable properties such s they are characterised by few parameters, there are many known solutions to provide a library of alternatives
33
New cards
what is graphical programming (Brooks)
also visual programming; the application of graphical to software design. This approach is sometimes justified by suggesting flow charts are the ideal programming medium.
This was critiqued in the past due to the limiting size of desktop monitors, and also due to the fact that software is difficult to visualise
34
New cards
what is a suggestion around program verification and software development productivity(Brooks)
much of the effort in progrAmming goes into testing and bug repair, what if there was a way to eliminate errors at the system design phase.
Program verification is powerful for secure things but it does not save labour; verification is lots of work.

It also doesnt mean error proof programs - mathematical proofs can also be faulty

Also verification can only establish that a program meets its specification - the hardest part of software is arriving at a complete and consistent specification`
35
New cards
what is the biggest gain in productivity from environments (Brooks)
the use of integrated database systems to keep track of details that must be recalled acurratly to ensure collabartion is efficient
36
New cards
what are the benefits and difficulties in using generic software as opposed to creating bespoke software (Brooks)
Most of the cost of software comes from the development. However the issue is applicability,
37
New cards
What is the issue in terms of the client in the development of software and what does this induce (Brooks)
The client does know what they want, they know what questions need to be answered but have rarely thought of the problem in much detail.
Therefore rapid prototyping systems to realise the conceptual structure that is specified becomes more and more important
38
New cards
how do the designers themselves play a part in the efficiency of software development (Brooks)
having an intelligent team that all follow the same practice, alongside a good managerial team ensures the highest efficiency.
39
New cards
How does brooks suggest we grow good designers
identify top designers as soon as possible, assign career mentors and develop and maintain a development plan for the prospect, provide opportunities for growing designers to interact with each other
40
New cards
Why did Margaret Hamilton choose to call it software engineering
"I fought to bring the software legitimacy so that it—and those building it—would be given its due respect and thus I began to use the term 'software engineering' to distinguish it from hardware and other kinds of engineering, yet treat each type of engineering as part of the overall systems engineering process. When I first started using this phrase, it was considered to be quite amusing. It was an ongoing joke for a long time. They liked to kid me about my radical ideas. Software eventually and necessarily gained the same respect as any other discipline,"
41
New cards
why does dan luv suggest that if it were better, someone would've outcompeted it is false
Markets don't reliably weed out bad products or inefficient firms, so "if it were better, someone would've outcompeted it" is false. Most buy decisions end up with products that don't really work.
42
New cards
why does dan luu suggest market pressure is weak
Information asymmetry: buyers can't tell good from bad (a "market for lemons"), even experts and credentialed people can give bad advice.

Price ≠ quality: paying more doesn't reliably get better quality (e.g. big-brand accountants had more errors).

Marketing beats quality: people choose on PR and marketing, so a better product doesn't necessarily win.

No way to profit from spotting the inefficiency: unlike a mispriced asset, you can't turn the observation into money, so nobody corrects it.

Noisy feedback for vendors: it's hard for producers to tell why sales rose or fell, and customer feedback is sporadic and unreliable.

Vendor incentives: false claims plus the "fog of war" can be about as good as a working product, and much cheaper (e.g. Mongo's bogus correctness claims).
43
New cards
"Focus on core competencies and outsource the rest" is a slogan, not a rule. Dan Luu
In-house can be cheaper, faster and more reliable than outsourced support or vendor products.
Companies adopting the slogan made migrations for vague reasons, and costs often went up.
Vendor products often don't work and can't work because of design flaws.
44
New cards
Why does dan Luu suggest trust and culture matter
Outsourcing only works if you can trust the other firm's promises.
If firms exploit contracts to the letter, enforcing them is too costly, so you bring work in-house.
Low trust inside a company causes empire building and similar problems.
Cultural norms (e.g. leaving a laptop in a cafe in Korea vs the US) feel like facts of nature but are arbitrary.
Trust isn't inevitable at scale: Intel and Google enforced honesty under strong leaders, then lost it when leadership changed.
45
New cards
What does dan luu suggest the role of 'unusually unreasonable' people is
Quality often depends on rare individuals or firms willing to spend their own capital on getting things right (Kyle Kingsbury, Volvo).
Systems that depend on such people will produce mostly products that are good at marketing rather than at working.
46
New cards
What does dan luu suggest are the downsides to building in house
Internal designs can be just as broken, especially in dysfunctional teams.
Warnings from engineers during design are often ignored.
Monopoly (even team-level) can push out product-focused people and lead to worse products.
47
New cards
The bottom line of dan luu's 'market vs product' equality
Don't assume a product, vendor or company is good because it's popular, expensive or recommended. Evaluate on the specifics, and consider building in-house when you can't trust or verify what you'd buy.
48
New cards
what does brooks claim about software
the hard part of software is deciding what to build, not writing it
49
New cards
What does brooks split the work of software engineering in to
essence (specifying, designing and testing the conceptual construct) and accident (expressing it in a language and on a machine). His argument is that a 10x gain needs accident to be about 90% of the effort, and it isn't.
50
New cards
What problem does Brodinski say that vibe coding tools answer
The perception that the pace of shipping features (or building in general) is the bottleneck of product development is a misconception.
51
New cards
Brodinski suggests vibe coding is good for prototyping, but why not feature code?
Prototypes are disposable

"Even if we validate that we were right and our idea works the prototype is still disposable.

The whole idea behind prototyping is that we trade quality for a quick and cheap outcome. It can break. It can be buggy. Sometimes it may even look ugly. The point is: it conveys the idea.

Conversely, a product has to deliver promised value sustainably over time. Awful UX? I'll move to an alternative. Bugs too annoying? I'll stop using it altogether. It breaks entirely? Why would I use it, let alone pay for it?

The quality has to be there. Otherwise, customers will go as fast as they come, and that's not a viable product strategy. Sure, we'd still love to build our product quickly and cheaply, but at some level, quality is non-negotiable. Ultimately, we need the thing to work in the long run."
52
New cards
why does Bodinski say that validation is a bottleneck
Product development, in essence, is continuous discovery. First, we aim to validate the idea, then we switch to validating whether any given change brings us closer to our goals—growth, revenue, retention, or whatever that may be.
The problem is that validation takes time.
53
New cards
why does bodinski suggest communication is a bottleneck
"But what if we do know exactly what to build? Ultimately, it's the basic pattern of project work. We define the scope, we agree on the payment, and off we go!
In such a setup, we can conveniently ignore that we might be building the wrong thing entirely. Or, with a bit of luck, it's one of the rather rare cases where we either run a direct replacement project or automate the existing business, and we have a much better initial understanding of the desirability, viability, and feasibility of the idea."

"Poor communication creates rework. It's not unusual that the quality of communication, or rather lack thereof, adds as much as an additional 100% to the effort."
54
New cards
Brodinski then suggests that coding pace was never the bottleneck
"We subconsciously avoid solving difficult problems by finding a similar one that's much easier to address. Then, we pretend the answer to the latter works as the answer to the former.

In that manner, we respond to the question about successful product development. We have little clue about what makes products successful. However, we certainly see that the most significant part of the effort is development. It takes a great deal of time and money to turn an idea into a product.

So we focus on the speed of development. And suddenly, we have an easy answer. We can make it faster. How? That's simple. Use AI.

Code does not equal product. What follows is that more code does not equal a better product. Often, it's the opposite.

Coding speed was never the bottleneck. Not even when we didn't have an AI shortcut."
55
New cards
Brodzinski says If we stick to the context of product development, vibe coding promises us two things.
We'll get the code fast.
We don't need to hire expensive technical expertise.
but...
Both parts miss the "coding speed was never the bottleneck" observation. Both respond to the simple question instead of the difficult one.
To make matters worse, the price we pay for removing ourselves from understanding the code is more rework
Ultimately, using vibe coding as the main tactic to build a successful product is like solving a minor issue only to make the main problem a much bigger challenge.
56
New cards
code isng the bottleneck agrees with brook's silver bullets
If writing code is a small share of total effort, speeding it up has little effect, like Amdahl's law. Brodzinski shows this at product level.

Automatic programming: Brooks's objection was that generating code from a specification just moves the problem to writing the specification. Vibe coding is the same idea with a looser spec, and Brodzinski's "answering an easier question" argument is the same objection.
57
New cards
Brodinzki and Brook's ideas on prototyping and engineering efficiency differ
Brodzinski concedes that LLMs are good for prototyping. Brooks lists rapid prototyping as one of the real attacks on essence, so cheap prototypes might genuinely shorten the loop for testing whether an idea is desirable. They don't shorten the wait for real user data.
58
New cards
Cheaper code changes 'buy vs build'
This ties back to the Dan Luu piece: if building small things gets cheaper, "build" becomes more attractive than Brooks assumed.
59
New cards
Brodzinski argues vibe coding adds rework because you don't understand the code. What point did brooks make that this could add to
That means it could add to complexity and invisibility (essence), not just fail to remove accident.
60
New cards
Goedecke's "LLMs reward expertise"
His point is that the main skill in using an LLM is domain knowledge, so "the human is the bottleneck, not the model." It connects to two Brooks ideas ...
Great designers: Brooks says good software comes from good designers, not tools. Expertise lets you steer the LLM and spot output that "looks weird."

Expert systems: Brooks hoped they would give inexperienced programmers the accumulated wisdom of the best ones. Goedecke complicates that: LLMs help everyone a bit, but experts get far more out of them.

Both point to the same conclusion. The tool can handle the accidental work, but the conceptual work, knowing what you want and recognising what's wrong, stays with the human. That's essence.
61
New cards
what does validation ensure
Validation ensures that the software meets the user’s needs and requirements, answering the question, “Are we building the right product?” It involves evaluating the final product to confirm that it fulfills its intended purpose and is suitable for its intended users.
62
New cards
example of validation in a banking application
In a banking application, validation involves ensuring that the application correctly calculates interest rates and processes transactions as specified in the business requirements. This could involve:- Performing user acceptance testing (UAT) with actual users to ensure the application is user-friendly and meets their needs.- Conducting end-to-end testing to verify that business processes such as account creation, transactions, and interest calculation are working as intended.
63
New cards
what is verification
Verification, on the other hand, focuses on whether the software has been built correctly and is error-free, answering the question, “Are we building the product right?” Verification activities involve checking that the software adheres to its design specifications and requirements.
64
New cards
Example of what happens during verification
During verification, testers review the software's code to ensure that it follows coding standards and conduct tests to confirm that each feature functions as expected based on its design specifications. This could involve: - Conducting code reviews to ensure coding standards are met and the code is free from defects. - Performing unit testing to verify that individual components or modules work correctly. - Conducting integration testing to ensure that different modules or services interact as expected.
65
New cards
What is quality assurance
QA is a process-oriented activity that focuses on preventing defects and ensuring that the development process is efficient and effective. It involves defining and implementing standards, processes, and procedures to maintain a consistent and high level of quality throughout the software development lifecycle.
66
New cards
example of quality assurance in software engineering
In QA, a company may establish a set of testing best practices and guidelines that all testers should follow. QA aims to identify potential issues early and implement measures to mitigate risks. For instance:- Developing a test plan that outlines the testing strategy, resources, schedule, and scope.- Implementing automated testing frameworks to ensure consistent and repeatable test execution.- Conducting regular process audits and reviews to ensure adherence to established procedures.
67
New cards
what is quality control
QC is a product-oriented activity that involves evaluating the actual product to identify defects and ensure that it meets the specified requirements and standards. It is a reactive process that focuses on finding and fixing defects before the software is released to the end-users.
68
New cards
example of quality control in software engineering
In QC, testers execute test cases and conduct various testing activities, such as functional testing, regression testing, and performance testing, to uncover defects and verify that the software functions correctly. For example:- Performing functional testing to ensure that all features work as intended.- Conducting regression testing to verify that new changes have not introduced new defects.- Executing performance testing to ensure that the application performs well under expected load conditions.
69
New cards
A commonly touted software engineering principle is "Don't Repeat Yourself" (DRY).

What is this
whenever possible, our programs should not have repetition of code which does the same thing. DRYer code tends to have fewer place to touch if we need to modify something.
For example, if we decided to change the game so that we wrote 'Fizz' when i was divisible by 2 instead of by 3 or we wanted to write 'BUZZ' instead of 'Buzz' and thus 'FizzBUZZ', we would have to edit multiple lines with "the same" change.
70
New cards
if we decided to change the game so that we wrote 'Fizz' when i was divisible by 2 instead of by 3 or we wanted to write 'BUZZ' instead of 'Buzz' and thus 'FizzBUZZ', we would have to edit multiple lines with "the same" change. We thus increase the chance of making 2 sorts of errors
What are they
We might make the wrong change. E.g., `i % 22` intead of `i % 2`. The more times we need to make a change, the more opportunities for error.

We might miss a place where we needed to make a change. With only 9 lines this may seem unlikely, but you would be surprised at what human perception can miss.
71
New cards
Pulling out stretches of code into a function or method is a form of abstraction, often called, in a bit on the nose way, functional abstraction.

In principle, such abstraction can improve maintainability (only one place to change functionality) but what drawbacks are there
Efficiency (hence why inlining functions is often a useful optimisation; can you determine the cost here? note: when people talk about "zero-cost" abstraction, they usually mean zero performance cost.)

Understandability (just the fact we introduced functions means we need to understand more bits of Python; also, this code is longer and "jumps around" more and we have a lot of variants of "fizz" and "buzz".)
72
New cards
Principles and guidelines and rules of thumb are all good things to know, but they aren't rules to be applied without thought. They inform but do not dictate judgement.
A good software engineer needs to balance a variety of factors which are often very specific to the situation. You don't make your code "better" just by making it "DRY". You don't avoid wasted work just by observing "YAGNI". Software engineering isn't mechanistic in that way.
73
New cards
The two difficulties mentioned in no silver bullets
• Essential
• Inherent to software (in general) or this software (in particular)
• Typically associated with the problem to be solved by the software
• But not all!
• Accidential
• Not inherent!
• Often associated with things that make the job harder to do
• Stems from choices when there are other, better choices now
• In some sense, eliminable
74
New cards
Complexity conformability changeability and invisibility in this code
• Complexity?
• Think about what you need to
know to understand this
• Conformability?
• Why this boilerplate to control
import vs. run directly behavior?
• Changeability?
• We've seen many versions often
with the same paths!
• Invisibility?
• How many paths again?
• How do we count them?
• Is the "module" a component?
75
New cards
The view of a design space

Every possible design is a point on a chart. Cost is on the x-axis and effectiveness is on the y-axis.
The pink curve is the best effectiveness you can get at each cost.
Designs near the curve are good trade-offs. Designs well below it, like F, are poor: you could get more effectiveness for the same cost.
This assumes you know exactly where each design lands.

We add uncertainty to this
At design time you don’t know a design’s true cost or effectiveness, so each design becomes a blob instead of a point. A bigger blob means more uncertainty.

A is a small blob close to the curve at low cost. You know roughly what you’ll get.

B is a large blob high on the curve at higher cost. It could be very good, but the size shows you’re unsure where inside that area you’ll end up.

C has two arrows, one to a small blob just below the curve at low cost and one to a wide, flat blob at the bottom right (high cost, close to zero effectiveness). I read this as C’s expected outcome being cheap and decent, while its worst case is expensive and nearly useless. The slide doesn’t say this in words.

“C is the really scary one!” because its range of possible outcomes is the widest, and the bad end is a disaster.
76
New cards
what is a claim about systems,
A claim about a system is a statement that says something about a software system, such as how it’s built, how it behaves or how good it is.

Examples

“this module has 3 execution paths” or “this system has 2 components”. These are all claims about the system

WhatsApp reviews, are claims too:

“Best app ever... no problem or fault” (5-star)

“YEARS of messages just PERMANENTLY disappeared” (1-star)

“Sending and receiving videos take absolutely foreverrrrrr” (1-star)

“No Silver Bullet" is a claim about systems It’s about how software system properties (the essential difficulties) affect projects.
77
New cards
What properties do claims about systems have
They're easy to make. The reviews show anyone can make one.
They're hard to make good, precise and intelligible. "Best app ever" and "takes foreverrrrr" are vague, and the two sets of reviews contradict each other.
They need evidence, and evidence can be hard to get. A review is one person's experience, not evidence about the system as a whole.
They're "context sensitive and interest relative"
Whether a claim is true or useful depends on the context and on what the person making it cares about. Counting paths depends on your scope, for example.
Success and failure are always relative to requirements
"It's good" only means something against what the system was supposed to do.
78
New cards
What are external qualities and examples of some
the qualities of a software system that a user is aware of.

those "that a user of the software product is aware of". They are the qualities you can check by observing the system directly, with no "under the hood" view needed.
79
New cards
What are functional vs none functional qualities
Functional qualities are about what the system does.

Does it do Y at all? Does it do it the way we want, within our tolerances, and can we easily get it to do Y′ or Y″?

Non-functional qualities are about how well it does it.

Does it drain the battery? Is it intuitive? Does it crash, corrupt data or leak secrets?
80
New cards
What are internal qualities and examples of some
“things programmers have to care about”, or “things which make life easier for the software engineer”. A user can’t see them. You need to look under the hood.

Static and dynamic views. Internal qualities tend to be associated with the static view, meaning how the components are arranged.
81
New cards
Why do internal qualities matter
They don't change what the user sees, but they change how easy it is to modify and understand the system.
Consider three FizzBuzz programs. They all print the same output, so they're equivalent on external qualities like correctness. They differ internally:
A is the plain loop.
B just prints the literal string.
C takes bounds and triggers as parameters.
82
New cards
What is testability
• A "cross cutting" internal property
• Potentially external too!
• "Black box testing"!
• "Acceptance testing"!
83
New cards
what is external versus internal flexibility
External flexibility is about whether you can easily get the system to do Y′ or Y″. Internal flexibility is about how easily the code can be changed.
84
New cards
Claims about software
systems are context sensitive
and interest relative.
SE concepts and principles
are overlapping, often fuzzy,
and typically rules of thumb.
85
New cards
what are the basic objectives in verification and validation (V&V) of software requirements and design
specifications
The basic objectives in verification and validation (V&V) of software requirements and design
specifications are to identify and resolve software problems and high-risk issues early in the
software life-cycle.
86
New cards
What is the main reason for verification and validation
The main reason for doing this is indicated i. It shows that
savings of up to 100:1 are possible by finding and fixing problems early rather than late in the
life-cycle. Besides the major cost savings, there are also significant payoffs in improved
reliability, maintainability, and human engineering of the resulting software product.
87
New cards
The definition of verification
Verification - to establish the truth of the correspondence between a software product and
its specification. (Note that data bases and documentation are fit subjects for verification, as well as programs.)
88
New cards
The definition of validation
Validation - to establish the fitness or worth of a software product for its operational mission
Informally, we might define these terms via the following questions:
Verification: "Am I building the product right?"
Validation: "Am I building the right product?"
89
New cards
<p>What is a V chart</p>

What is a V chart

A V chart (also called a V diagram or V model) lays out a development process in the shape of a V. It shows how the work is broken down and then checked.

90
New cards
How do we read this V chart
How do we read this V chart
The left side, going down: you start with the whole system’s requirements and keep breaking them into more detail, through product design and detailed design.

The bottom point: the code gets built.

The right side, going up: you put the pieces back together and test at wider and wider scope, from unit tests to integration tests to acceptance tests.

The horizontal links: each test level on the right is checked against the left-side stage at the same height. Unit tests check against detailed design, and acceptance tests check against the requirements.
91
New cards
What can we see from this v chart
From the V-chart, it is clear that the key artifact that distinguishes verification activities from
validation activities is the software requirements baseline. This refers to the requirements
specification which is developed and validated during the Plans and Requirements Phase,
accepted by the customer and developer at the Plans and Requirements Review as the basis for
the software development contract, and formally change-controlled thereafter.
92
New cards
Why does verification begin in the product design phase and conclude with the acceptance test
By definition, verification involves the comparison between the requirements baseline and the successive refinements descending from it—the product design, detailed design, code, database, and documentation
93
New cards
Why do validation activities occur throughout the software life cycle
Validation identifies problems which must be resolved by a change of the requirements specification. Thus, there are validation activities which occur throughout the
software life-cycle, including the development phase.

For example, a simulation of the product
design may establish not only that the design cannot meet the baseline performance requirements (verification), but also that the performance requirements are too stringent for any cost-effective product designs, and therefore need to be changed (validation).
94
New cards
The basic sequence of functions performed during the Plans and Requirements phase and the
Product design phase by the V&V agent, the specification agent (the analyst or software system engineer), the project manager, and the customer are shown

What are the key portions in this
The key portions are the iterative loops involved in the V&V and iteration of the requirements and design specifications, in which:
The V&V agent analyzes the specifications and issues problem reports to the specification agent;

The specification agent isolates the source of the problem, and develops a solution resulting in an iteration of the spec;

The Project Manager and Customer approve any proposed iterations which would perceptibly change the requirements baseline;

The V&V agent analyzes the iterated specification, and issues further problem reports if necessary;

The process continues until the V&V agent completes his planned V&V activities, and all problem reports have been either fixed or assigned to a specific agent for resolution
within a given time
95
New cards
what is a v and v agent
In Boehm, the V&V agent is the role responsible for checking a specification. It isn't a piece of software. The word "agent" here just means whoever fills that role
96
New cards
What are the 4 basic V and V criteria for requirements and design specifications
completeness, consistency, feasibility, and testability
97
New cards
What does it mean for a specification to be complete
A specification is complete to the extent that all of its parts are present and each part is fully
developed.
98
New cards
What are 5 properties a software specification must exhibit in order for it to be complete
a. No TBDs. TBDs are places in the specification where decisions have been postponed by
writing "To Be Determined," or "TBD."
Examples: "The system shall handle a peak load of (TBD) transactions per second."
"Update records coming from personnel information system shall be in the following format: TBD."

b. No reference to nonexistent functions, inputs, or outputs. These are references made in the specification to functions, inputs, or outputs (including data bases) which are not
defined in the specification.
Examples: "Function 3.1.2.3 Output 3.1.2.3.a Inputs 1. Output option flags obtained from the "User Output Options" function ..." - which is undefined in the specification.
"A record of all transactions is retained in the Transaction File" - which is undefined.

c. No missing specification items. These are items which should be present as part of the standard format of the specification, but are not present. Examples: Missing verification provisions
Missing interface specifications
Note that verification of this property often involves a human judgment call: a small, stand-alone system may have no interfaces to specify.

d. No missing functions. These are functions which should have been part of the software product, but which are not called for in the specification.

e. No missing products. These are products which should be part of the delivered software, but which are not called for in the specification.
Examples: Test tools
Output postprocessors
99
New cards
No TBDs and no reference to non existent functions form a subset of the completeness properties called what
"closure" properties. Closure is distinguished by the fact that it can be verified by mechanical means; the last three properties generally require some human intuition to verify or validate.
100
New cards
What does it mean for a specification to be consistent
A specification is consistent to the extent that its provisions do not conflict with each other or
with governing specifications and objectives.