Block 3 - From architecture to product Flashcards
Adapter pattern
where component_A wraps component_B thereby becoming its interface;
analysis pattern
a high-level conceptual-analysis solution;
analytical completeness (FRs)
where SS is complete w.r.t. solely FRs;
applet
a plug-in component installed in the client browser;
Architectural pattern
describes a high-level recurring design solution;
architectural view
a model of the SS framed w.r.t. a specific stakeholder;
architecture specialisation
where specific components are selected;
assertion (handling) mechanism
a run-time construct evaluating SO precons / postcons / invariants;
assertions
= {precons, postcons, invariants}
asynchronous
where clientComponent can carry on without waiting for serverComponent’s response
basis-path testing (WBT)
where each statement in a method is tested 1+ times;
blackboard (data-centred)
an arch-pattern where users can update store and vice versa;
black box testing (BBT)
testing w.r.t. component’s spec;
boundary testing
where test data is produced around the partitions between the input subdomains;
bursty event
where event occurs in unpredictableClusters;
(test) case analysis (partitioning)
partitioning test data into subdomains;
cloud computing
where all software runs on third-party servers;
completeness (FRs)
where all FRs have been implemented;
component-based development (CBD)
where the SS is built with pre-existing components;
connector
reps the comm. between components in an arch-pattern;
container
a component that creates and encompasses other objects;
context dependency
where a component requires other services to provide its service;
coupling between objects (CBO) metric
the number of associations a class has with other classes;
cyclomatic-complexity metric (CCM)
= numberDecisionPoints + 1;
data-centred
an arch-pattern where there is a centralised persistent data store;
defensive programming
where precons should always be checked;
dependency injection
where a container object appropriately initialises a specific object for a client;
deployment model
reps specific components being implemented on machines;
depth-of-inheritance-tree (DIT) metric
the number of anscestors a class has;
Design by Contract (DbC)
where precons are assumed to have been met;
design pattern
describes a mid-level recurring design solution;
enterprise architectures
SSs designed for large orgs;
error guessing
where SOs are tested with random data;
executable documentation
where code is automatically checked against documentation at run-time;
extreme programming (XP)
an agile software development method;
Factory pattern
where a specialised object creates and initialises other objects;
fixture
the conditions&InputData for a test;
flexibility
how easily the SS can be modified;
foreign key
a column in a database table holding a key from a different table;
framework
a package providing behaviour common to a variety of applications;
heuristic evaluation
testing the SS wihout users;
HTTP
an interface for web-components to exchange data;
idiom
a programming-language specific pattern;
inertial convention
where componentStates outwith postcons are assumed to be unchanged;
integration testing
where the emergent properties of sets of components are tested;
interface
the SOs of a component;
Java Enterprise Edition (Java EE)
a framework for consructing enterprise systems;
jitter
variationInLatency;
lack-of-cohesion-in-methods (LCOM) metric
numPairs of methods referencing the same attributes minus the numPairs that don’t;
latency
stimulusProcessingTime;
layered style
where components form a chain and can only message their immediate neighbours;
location transparency
where consumers use a service without knowing where service is hosted;
Mean Time to Change (MTTC)
the averageTime to fix a bug;
miss rate
proportion of requests not responded to;
model
a simplified rep of a problemDomain or softwareSolution;
Model-View-Controller (MVC) pattern
model = database; view = UI-output; controller = UI-input;
notification pattern
where observerComponents register with a subjectComponent for updates;
number-of-children (NOC) metric
numImmediateDescendants of a parentClass;
path parameter
URI/pathParameter;
peer-to-peer
a cliver network;
performance
how well a SS can process serviceRequests;
pipe and filters
filter = processor; pipe = pipe
polymorphism
where the particular object responding to a serviceRequest is determined at runTime;
postcondition
an assertion that must be true on completion of a UC or SO;
precondition
an assertion that must be true commencement of a UC or SO;
presentation layer
= UI;
primary key
the attribute that uniquely identifies each row of a databaseTable;
product
the object produced by the Factory object;
product line
a set of related software products;
provided interface
the SO-outputs of a component;
publish-subscribe
where subscribersComponents register to receive updates from a publisherComponent;
quality attribute scenario
specifying an NFR in detail to inform arch-decisions;
Quantity pattern
gives guidance on how to rep dimensioned quantities;
random testing (BBT)
where testData is randomly generated for the input domain;
record
a row of a database table;
refactoring
improving clarity of an SO’s code without changing without changing the SO’s precons / postcons / invariants;
regression testing
test(allPreviousTests & newTest);
repository
centralised store of persistent data;;
required interface
the SO-inputs of a component;
Requirements pattern
a description of knowledge used in the elicitation of requirements;
response-for-a-class (RFC) metric
size(classResponseSet);
response set
all (own, inherited and invoked) methods of a class;
restart testing
testing that SS can recover from errors of internal state;
RESTful
= REpresentational State Transfer + ful = where a webService users a lean interface (e.g. HTTP);
security testing
tests that SS’s security cannot be breached;
service-oriented architecture (SOA)
where applications are built out of loosely coupled services;
service-oriented pattern
where providers make services available to consumers;
signature
= SO-returnType + SO-name + SO-parameters;
Singleton pattern
where no more than one instance of a specific class is created;
software architecture
= components + relations;
software metrics
measurable quantities that inform SQFs;
SQF
one of the 11 attributes of a SS:
- correctness
- reliability
- efficiency
- integrity
- usability
- maintainability
- flexibility
- testability
- portability
- reusability
- interoperability
sporadic event
= infrequent&Isolated;
start-up testing
tests that SS can start in a working configuration;
statelessness
= component has no memory;
stochastic event
occurs according to a well-defined probability distribution;
straight-through path
the path where all loop / if conditions evaluate to false and switch statements evaluate to default;
stress testing
testing that SS can operate at limits of its resources;
subdomain
a set of inputValues requiring the same processing = equivalenceClass;
test case
the conditions&Data for checking whether SO satisfies its assertions;
test-driven development (TDD)
tests before code;
throughput
numEvents dealt with in a given time;
unit testing
where components are tested in isolation;
usability testing
where UI is tested w.r.t. intendedUsers;
user-command testing
testing userCommands w.r.t. tolerance to syntax / dataInput errors;
user-defined type
a bespoke sourceAlphabet;
validation
checking SS w.r.t. customerRequirements;
verification
checking SS w.r.t. designSpec;
view (MVC)
UI-output;
viewpoint / concern
a perspective on SS w.r.t. a particular stakeholder;
virtual machine
a simulation of a computer;
weighted-methods-per-class (WMPC) metric
= sumForClass(method-CCMs);
white box testing (WBT)
testing w.r.t. component’s code;
