CPS406 Midterm

What can you do with data stores?

typically, one of the CRUD activities: - create - read - update - delete note: in real databases, data is virtually never deleted

Describe the following special relationships: <<extends>>, <<includes>>, and <<uses>>

*<<extends>> relationship*: represent exceptional (alternative) slows which are factored out of the main flow for clarity - the arrow of an <<extends>> relationship points to the base use case from the extended use case (if the extension is options, it is typically dashed) *<<includes>> or <<uses>> relationship*: represents behaviour that is reused by several use cases and thus factored out of the use case - the direction of an <<includes>> relationship is towards the use case(s) that use it (unlike the <<extends>> relationship)

What are the different types of creational patterns?

*Abstract factory*: provides an interface for creating families of related or dependent objects without specifying their concrete classes *Builder*: separates the construction of a complex object from its representation so that the same construction process can create different representations *Factory method*: defines an interface for creating an object, but lets subclasses decide which class to instantiate *Prototype*: specifies the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype *Singleton*: ensures a class only has one instance, an provides a global point of access to it

Define abstraction and decomposition

*Abstraction*: a model or representation that omits some details so that it can focus on other details (different abstractions, built for different purposes, omit different kinds of details) *Decomposition*: the process that spreads the functionality of the system into several modules (the process that achieved modularity); often linked to abstractions

What are the different types of structural patterns?

*Adapter*: converts the interface of a class into another interface clients expect *Bridge*: decouples an abstraction from its implementation so that the two can vary independently *Façade*: provides a unified interface to a set of interfaces in a subsystem *Flyweight*: supports a large number of fine-grained objects efficiently *Proxy*: controls access to an object through a surrogate *Composite*: composes objects into tree structures to represent part-whole hierarchies

Compare application classes and solutions classes.

*Application classes*: represent application concepts, often corresponding to entities in the real world (e.g., customers, customer accounts, withdrawals, interest rates/interest rate calculation, insurance policies, etc.) *Solution classes*: represent system concepts, e.g., user interface objects, databases, etc

What are the different types of behavioural patterns?

*Chain of responsibility*: avoids coupling the sender of a request to its receiver by giving more than one object a chance to handle the request *Command*: lets you parameterize clients with different requests, queue or log requests, and supports undoable operations *Interpreter*: defines and uses a representation for a languages grammar so that sentences written in it can be interpreted *Iterator*: provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation *Mediator*: defines an object that encapsulates how a set of objects interact *Memento*: captures and externalizes an object's internal state so that the object can be restored to this state later without violating encapsulation *Observer*: defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updates automatically *State*: allows an object to alter its behaviour when its internal state changes *Strategy*: lets the algorithm vary independently from clients that use it *Template method*: lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure *Visitor*: lets you define a new operation without changing the classes of the elements on which is operates

What is the difference between class and object adapters? How do you know which one to use?

*Class adapter*: uses multiple inheritance *Object adapter*: uses object composition and delegation - depending on what your code looks like, just choose which one is easier/works better with it

Define the different types of cohesion, from worst to best.

*Coincidental* (worst) - arbitrary grouping - e.g., helper files, utils.c *Logical* - do the same thing even if the nature is different - combine together voice and keyboard input *Temporal* - processing always follows specific sequence - check file existence and permission, then open *Communication* - operate on the same data - module modified a specific table in a database *Sequential* - assembly line - read file and parse it line by line *Functional* (best) - all parts contribute to a single well-defined task - tokenizing CSV file

Define common coupling.

*Common coupling*: two or more modules use the same global data

Define component coupling.

*Component coupling*: when class A has variables that are actually instances of another class C - component coupling will generally imply the presence of interaction coupling also

Define the different types of coupling, from worst to best.

*Content* (worst): once module relies heavily on private functionality of another module; changes in one may lead to changes in the other *Common*: usage of global variables; change of the global variable will lead to modification of all the modules *External*: two modules share communication protocol or device interface (communicating to external modules or devices) *Control*: one module controls the flow of another (passing what to do, not passing the data *Stamp/data structure*: modules share data structure, but use only part of it *Data*: modules share data via parameters (passing parameter to a method); the most frequently used type of coupling *Message* (low): communication is performed via parameter or message passing (often asynchronous); best besides no coupling, but no coupling is often difficult to achieve) *No coupling* (Best): difficult to achieve

Define content (or internal data) coupling.

*Content/internal data coupling*: one module directly modified data inside another module

What does a pattern description contain?

*Context*: environment in which a problem is noted and the specific solution built using the pattern applied *Problem*: a short description of a design problem that needs to be solved *Forces*: issues or concerns to consider when solving the problem *Solutions*: the recommended way to solve the problem in the given context ('one that balances the forces') *Antipatterns (optional)*: solutions that are inferior or do not work in this context, typically with the rationale *Related patterns (optional)* *References*: who developed or inspired the pattern (a human who doesn't want to see his or her name in print has yet to be born)

What are the different types of patterns?

*Creational patterns*: used to create objects in flexible or constrained ways *Structural patterns*: used to represent data structures such as trees, with uniform processing interfaces *Behavioural patterns*: to capture behaviour among objects or groups thereof

Define data coupling and give an example.

*Data coupling*: output from one module is input to another - e.g., using parameter lists to pass items between runtimes

Define control coupling.

*Define control coupling*: passing of a flag as parameter

Three things that happen during the design process are eliding, incomplete, inconsistency, define them.

*Eliding*: elements are hidden to simplify the diagram *Incomplete*: elements may be missing *Inconsistency*: the model may not be consistent

What are engineering tasks?

*Engineering tasks*: tasks that are derived from user stories -- these are the things that we will actually implement In the following user story, several tasks are required: The user should be able to login with her username and password - the screen where the username and password will be entered, and information about unsuccessful login announced, but also... - a database of users with their usernames and encrypted passwords - a preferred algorithm for encrypting the passwords

What are the three categories of prioritization?

*Essential*: absolutely must be met *Desirable*: highly desirable but not necessary (could live without it) *Optional*: possible but could be eliminated (if time/budget allows)

What metrics can uses cases be characterized by?

*Fan-in*: refers to the number of units that use a particular software unit *Fan-out*: refers to the number of units used by a particular software unit

What are functional and non-functional requirements?

*Functional requirements*: the "what", the features/functions the system should support, often has to do with interaction between the user and the system *Non-functional requirements*: the "how", the manner in which those interactions are conducted and system behaviour during the process

What are the differences between implementation inheritance and interface inheritance?

*Implementation inheritance*: aka class inheritance - goal: extend an applications functionality by reusing functionality in a parent class - inherit from an existing class with some or all operations already implemented *Interface inheritance*: aka subtyping - goal: provide different ways to respond to the same set of messages - inherit from an abstract class with all operations specified, but not yet implemented

Define inheritance coupling, least coupling, and explain when coupling can be bad.

*Inheritance coupling*: two classes are coupled if one is a subclass of the other - worst form: when a subclass modifies the signature of a method or deletes a method - coupling is also bad when two or more methods have the same signature but different implementations - least coupling: when a subclass only adds instance variables and methods, but does not modify any of the inherited ones

Define lexical content coupling.

*Lexical content coupling*: when one module refers to the inside of another one (as in C/C++ header files)

Define method cohesion, class cohesion, and inheritance cohesion (used in OO systems)

*Method cohesion*: why different functional elements are together in a method *Class cohesion*: why different attributes and methods are together in a class *Inheritance cohesion*: focuses on why classes are together in a hierarchy

What is open architecture? What are the issues with it?

*Open architecture*: where everything is visible and any client can involve any operation at will - efficient, but the caller must understand how the subsystem works and the relationship within - in most cases the freedom will be misused, leading to non-portable code

What are the pros and cons of the waterfall method?

*Pros* - measurable progress - experience applying steps in past projects can be used in estimating duration of "similar" steps in future projects - works well in environments that are well understood and stable *Cons* - lots of paperwork upfront, little results visible until very late in development cycle - changes become increasingly costly as we advance through phases - problems that require backing up one or two phases can be very costly to fix - technology problems usually not encountered until the implementation phase

What is the difference between a requirements document and requirements specification?

*Requirements document*: a complete listing of everything the customer wants to achieve, typically using customer, therefore informal language *Requirements specification*: restates the requirements as a (semi-) formal expression of how the proposed system shall behave, often using a graphical, semi-formal, or formal notation

Scrum vs Kanabn

*Scrum* Cadence: fixed length sprint Release method: approval by product owner at the end of each sprint Roles: product owner, scrum master, dev team Change strategy: don't change until the end of the sprint *Kanban* Cadence: continuous flow Release method: Continuous delivery Roles: none Change strategy: change at any time

Who are the stakeholders?

*Stakeholders*: the people and groups of people involved in, or affected by, or that affect, project activities; i.e.: - project sponsor - development management and project development team - support staff - customers - users - suppliers - opponents to as well as champions of the project

Define stamp coupling:

*Stamp coupling*: when two objects accept the same data type as a parameter, changes in one object may require changes in the parameter, and then the other object may also need to change

Who is a super user?

*Super user*: someone who knows everything (in and out of the system) and can do anything

What are the steps in the architectural design process?

*System Structuring* - the system is decomposed into several principal sub-systems and communications between these sub-systems are identified *Control modeling* - a model of the control relationships between the different parts of the system is established *Modular decomposition* - the identified sub-systems are decomposing into modules

What are system context models and interaction models?

*System context model*: a structural model that can demonstrate the other systems in the environment of the system being developed *Interaction model*: a dynamic model that shows how the system interacts with its environment as it is used

What kinds of relationships can ER diagrams model?

*Ternary relationships* e.g., An EMPLOYEE is assigned to work on a PROJECT at a given LOCATION... but may be assigned to another PROJECT at another LOCATION *Many-to-many relationships* - these often have attributes (properties of their own) - some attributes need not have a value right away (but eventually they will have a value)

Define traceability, source traceability, requirements traceability, design traceability, and testability.

*Traceability*: concerns the relationships between requirements, their sources, and the system design *Source traceability*: links from requirements to stakeholders who proposed these requirements *Requirements traceability*: links between dependent requirements *Design traceability*: links from the requirements to the design *Testability*: concerns the manner in which we can ascertain that the given requirement is, in fact, fulfilled by the given implementation

Define the trigger, actors, entry conditions, success guarantee, and minimum guarantee

*Trigger*: what will start the use case *Actors*: that participate in the use case *Entry conditions*: that must hold in order for the use case to being at all *Success guarantee*: if the use case falls all the way to the end through the main flow of events, it is a success -- the post conditions of which define what it actually means *Minimum guarantee*: if the use case ends via ANY of the alternative flows, it did not succeed, and failure postconditions define what should hold in that case (at least)

How do you measure unadjusted actor weight (UAW) and unadjusted case weight (UUCW)?

*UAW* simple actor: another system with a defined API (machine to machine interaction); #simple x 1 average actor: another person interacting through a text-based interface; #average x 2 complex actor: person interacting through a graphical user interface (takes longer to test because of the infinite number of ways a person can execute a set of actions); #complex x 3 UAW = (# simple x 1) + (# average x 2) + (# complex x 3) *UUCW* simple use case: up to 3 transactions; #simple x 5 average use case: 4-7 transactions; #simple x 10 complex use case: more than 7 transactions; #complex x 15 UUCW = (# simple x 5) + (# average x 10) + (# complex x 15)

What is UML?

*UML (Unified Modeling Language)*: a standard for modeling object-oriented software - in most cases, you can model 80% of the problem by using about 20% of UML

Define use case diagrams, class diagrams, sequence diagrams, statechart diagrams, and activity diagrams.

*Use case diagrams*: describe the functional behaviour of the system as seen by the user *Class diagrams*: describe the static structure of the system: objects, attributes, associations *Sequence diagrams*: describe the dynamic behaviour between actors and the system and between objects of the system *Statechart diagrams*: describe the dynamic behaviour of an individual object (essentially a finite state automation) *Activity diagrams*: model the dynamic behaviour of a system, in particular the workflow (essentially a flowchart)

What are use cases?

*Use case*: represents a unit of functionality provided by the system as an event flow consists of: - unique name - participating actors - trigger - entry conditions - flow of events, main and alternative (exceptional) - exit conditions: success and minimum guarantees - special requirements - use cases represent externally observable functional behaviour, typically described using structured text - they represent detailed sequences of interaction between an actor (or several of them) and the system - the use case model (the set of all use cases) should, in theory, be a complete description of the system functionality and its environemtn - *NOTE*: use cases do not necessarily model all the tasks of interactions, instead they are used to specify user views of essential system behaviour

What is DevOps driven by?

*Use of agile processes* *Private/public clouds becoming mainstream* - increased rate of production releases enabled by cloud (continuous delivery) *Increased usage of...* - data centre automation and configuration management tools - test automation and continuous integration methods - SaaS offerings such as GitHub and Jira

What are the different types of proxies?

*Virtual proxy*: creates expensive objects on demand *Remote proxy*: provides a local representative for an object in a different address space (often used in networking application) *Protection proxy*: controls access to the original object useful when objects should have different access rights, e.g., in the context of protected access to operating system objects

What are design constraints?

- *Design constraints*: a design decision such as choice of platform or interface components, which may be dictated by backward compatibility or some other, possibly non-technical reason - examples: operating system, programming language, GUI toolkit, database management system, etc

What is a process constraint?

- *Process constraint*: a restriction on the techniques or resources that can be used to build the system - e.g., "here we develop software using scrum"

What are code smells? Give an example of one.

- *code smells* are simple indications that refactoring is needed and what can be eventually cleaned up by refactoring; they are anti-patterns that represent bad code practice - an example of a code smell is duplicate code

What can go wrong with pair programming?

- *disengagement*: one of the members physically moves away from the keyboard or starts working on something else - *watch the master*: one member may be more experienced than the other, causing temptation to defer work to the more senior member while the less senior member becomes an observer; often leads to disengagement - *silence*: pairs can't work together if they're silent

What are the different architectural models?

- *static structural model* that shows the major system components - *dynamic process model* that shows the process structure of the system - *interface model* that defines sub-system interfaces - *deployment model* shows the relationship between system elements and hosts

Describe coupling in objects.

- A has instance variables of C - A has some parameters of type C - A has a method with a local variable of type C - the problem is, when A is coupled with C, it is coupled with all subclasses of C as well

What is DevOps?

- DevOps = development and operations - it is a software development method that stresses communication, collaboration, integration, automation, and measurement of *cooperation between software developers and other IT professionals* - the idea that people who maintain the infrastructure need to work as a cohesive unit was the reason DevOps was created

What is a component?

- a component is a unit of computation of a data store - components may be simple or composite (composite components describe a subsystem) Note: an architecture consisting of composite components describes a system of systems Components are loci of computation and state, these could be: - client (e.g., GUI) - servers - databases - filters (e.g., often when you pass the data through the system, your goal is to extract something and upload it somewhere else, this step allows you to transform data and upload/output it somewhere else) - layers (helps us to partition complex pieces into smaller portions) - ADTs (what is being passed back and forth)

Why create software archiecture?

- a key to reducing development costs because it describes explicit system structure - a natural evolution of design abstractions - technical basis for design, consistency, dependency, and tradeoff analysis

How are the components of a use case represented in a use case diagram?

- a large box: system boundary - stick figures outside the box: actors, both human and system - each oval inside the box: a use case that represents some major required functionality and its variant - a line between an actor and use case: the actor participates in the use case

What are use case points?

- a more detailed look at the user stories to improve accuracy of your estimation

What is a package?

- a package is a UML mechanism for organizing elements into groups - packages are the basic grouping construct with which you may organize UML models to increase their readability

What is data flow diagram decomposition?

- a process may be decomposed ("exploded") into another data flow diagram - there are no additional external entities (may be not external entities at all), but there may be additional data stores - the process repeats and ends when the data transformation within a process cannot be though of as a continuous transformation, but can be described with a flowchart, pseudocode, etc

What are the common errors with data flow diagrams?

- a process with not outputs - a process with no inputs - lack of a or unclear data source (where is the data coming from?)

What is a product backlog?

- a product backlog is all the requirements that need to be implemented in the current sprint - they are prioritized by the customers, estimated by the developers, and a subset to be implemented in the sprint is moved to the sprint backlog - new requirements can be added to the backlog at any time - during the sprint, there can be no changes to the sprint backlog - often written in user story form effort is estimated by the team, ideally in relative units (e.g., story points)

What is a sub-system and a module?

- a sub-system is a part of the system whose operation is (mostly) independent of the services provided by other sub-systems - a module is a system component that provides services to other components but would not normally be considered as a separate system

What are the differences between bridges and adapters?

- an adapter is used to adapt two different classes to operate in a unified way (i.e., it applies to existing compatibilities) - if those classes do similar jobs but don't have a unified interface, adapters provide the uniform interface and can be implemented using either multiple inheritance or delegation through embedding a member of the adapter - a bridge is something we use when we actually need to separate the interface from implementation (varying types of implementation is one reason)

What is aggregaation?

- an aggregation is a special case of association denoting a "consists of" hierarchy - the aggregate is the parent class, components are the children class

What is an architectural configuration/topology?

- an architectural configuration or topology is a connected graph of components and connectors that describes architectural structure - basically, gluing together your nodes and edges; you have your components and there is some flow of information

Why do we need to estimate?

- an effective cost, schedule, and quality estimation approach provides a sound baseline for project planning, monitoring, and control - an effective planning, monitoring, and control capability allows the historical data to be updated and provides for improvement in the quality of cost, schedule, and quality estimation in subsequent projects

What are requirements?

- an expression of a desired behaviour which may deal with objects or entities of the system, the state they can be in, and functions that are performed to change states or object characteristics (all from the viewpoint of the customer) - requirements should focus on customer needs rather than on the solution or implementation - designating what behaviour the system should exhibit without saying how that behaviour will be realized

What is an interface? What should an interface specification communicate to other system developers?

- an interface defines what services the software unit provides to the rest of the system, and how other units can access those services - must define what the unit requires, in terms of services or assumptions, for it to work correctly An interface should communicate everything that developers need to know to use your software unit correctly, including: - purpose - preconditions (assumptions) - protocols - postconditions (visible effects) - quality attributes

What are architectural styles?

- architectural styles are recurring organizational patterns and idioms - an abstraction of recurring composition and interaction characteristics of a set of architectures - styles are key design idioms that enable exploitation of suitable structural and evolution patterns and facilitate component, connector, and process reuse

What are the different pattern levels?

- architectural styles or patterns apply to entire systems and subsystems (pipe-and-filter is a pattern) - design patterns (in the stricter sense) apply at the design level; they typically involve several interacting classes or functions - data structures and algorithms are low-level patterns - idioms are ways of doing things in particular programming languages (lowest level)

Use Case Diagrams vs. Use Cases

- both use cases and use case diagrams represent external behaviour - use case diagrams are useful as a visual aid, not much information though - the "meat" of the model is provided by use case descriptions, rather than use case diagrams - all use cases need to be described for the use case model to be useful, with or without the corresponding diagrams

What is layering? What are the pros and cons?

- breaking down the system into a number of separate layers is one of the most common techniques to master the complexity Pros: - layers are simpler and easier to understand - layers can be replaces without affecting the system - layers make good places for standardization - genetic layers can do many things for those above Cons: - layers encapsulate some, but not all, things well - layers can harm performance -- can involve too much rewriting and "spell-checking" of data along the way

Describe the Spiral model of SE

- building a trivial prototype to show clients, refining prototype to show client, and repeating until the client approves, then building the actual project - reduces the amount of effort that goes into analysis and design - there is an emphasis on constant feedback from customers (not realistic anymore); you will understand very well what the customer needs - first formal model where iterations were introduced in SE

What is a Sprint Burndown Chart?

- can be used for tracking and improvement of time estimates - when we underestimate or overestimate the size, we may deviate from the estimated completion line - good to bring up during reflection meeting at the end of a sprint

What is refactoring?

- changing the internal structure of software to improve readability, modifiability, and reuse without changing its observable behaviour - in many agile approaches such as XP, refactoring is considered as an activity mutually exclusive from coding: - when you are adding new code, you should not be modifying existing code - when you are refactoring, you should not be adding any new functionality or any new test cases

What are the benefits to refactoring?

- code size if often (but not always) refused after refactoring - confusing structures are transformed into simpler structures which are easier to maintain - performance may be improved but then it may be worse (e.g., reducing duplicate code blocks can make things slower) - promotes a deeper understanding of the code, thus helps in finding existing bugs and anticipating potential bugs - contrast with performance optimization, where functionality is not changed, only internal structure - however, performance optimizations often involve making code harder to understand, but faster

What does the scrum master do?

- communicates with customers and the organization, protects the development team from external distractions - organizes daily meetings, tracks backlog of work, records decisions, measures progress agains the backlog, communicated with customers and management outside of the the team

What is system structuring?

- concerned with decomposing the system into interacting subsystems - you can have system structuring that has centralized architecture or distributed architecture

What is the delegation pattern?

- context: you are designing a method in a class - you realize that another class has a method which provides the required service - inheritance is not appropriate, say the isa rule does not apply - problem: how can you most effectively make use of a method that already exists in the other class? - forces: you want to minimize development cost by reusing methods

How does the type of information flow impact coupling?

- coupling depends on the type of information flow - two kinds of information: data or control Transfer of control information: - action of module depends on the information - makes modules more difficult to understand Transfer of data information - module can be treated as input-output function lowest coupling: interfaces with only data communication highest: hybrid interfaces

How does interface complexity impact coupling?

- coupling increases with complexity of interfaces, e.g., number and complexity of parameters - interfaces are needed to support required communication - oftentimes we use more than is the minimum needed, e.g., we pass the entire record when only a single field is needed - keep the interface of. module as simple as possible

Describe the planning phase of the product backlog (Pre-game phase -- planning)

- creating a product backlog list that contains all the requirements that are currently known - this list is constantly updated with new items and new details about the existing items - the current product backlog will be reviewed by the scrum team(s) after each iteration/sprint - requirements are prioritized and effort needed to implement them is estimated - planning includes the definition of the project team, tools, and other resources, and also includes risk assessment, training needs, and management approval

What are possible problems with getting requirements?

- customers don't know what they want, so they can't tell us, or don't want to tell us - customers have unrealistic goals - customers express requirements in their own terms - different stakeholder have conflicting requirements - Organizational and political factors may influence the system requirements - requirements may change during the analysis process, new stakeholders ay emerge and/or the business environment may cause

What is the bridge pattern intended to do?

- decouple an abstraction from its implementation so that the two can vary independently - publish interface in one inheritance hierarchy, and bury implementation in an inheritance hierarchy of its own - insulate beyond encapsulation

What are the consequences of using a bridge?

- decoupling the object's interface - improved extensibility (you can extend (i.e., subclass) the abstraction and implementation hierarchies independently) - hiding details from clients

What is the strategy pattern?

- define a family of algorithms, encapsulate each one, and make them interchangeable - the strategy pattern lets the algorithm vary independently from clients that use it

What are common activities in the process stages of object-oriented design?

- define the context and modes of use of the system - design the system architecture - identify the principle system objects - develop design models - specify object interfaces

What is delegation?

- delegation is a way of making composition (e.g., aggregation) as powerful for reuse as inheritance - two objects are involved in handling a request - a receiving object delegates operations to its delegate - the developer can then make sure that the receiving object does not allow the client to misuse the delegate object

Describe software design

- design activity begins with a set of requirements and maybe an architecture - design is done before the system is implemented - focuses on module view (what modules should be in the system, how they're connected, and how they interact) - the blueprint for implementation - perhaps the most critical activity during system development

Why is. software design the most critical activity during system development?

- design determines the major characteristics of a system - has great impact on testing and maintenance - design document forms the reference for later phases - critical for testers because when you're designing components, they have to be testable (if you start with good architecture, you're setting yourself up for easier maintenance down the road)

What are design models?

- design models show the objects and object classes and relationships between these entities - static models describe the static structure of the system in terms of object classes and relationships - dynamic models describe the dynamic interactions between objects

What are the disadvantages of low cohesion?

- difficult to comprehend a module - difficult to maintain - challenging to reuse - don't need random helper functions - completely agnosticism of language or what type of application it is (e.g., desktop app, cloud app, etc)

A user story is a tangible unit of...

- discussion - estimation - scheduling - functional testing - completion - area (wall or whiteboard) devoted to a story

How is estimation done?

- documents generated in the process of project planning and preparation - using data about similar projects undertaken by us and others - using various formal and informal algorithms, as well as our experience

What is the objective of requirements elicitation?

Answering the question "what is the future system expected to do, and perhaps also how"

What is the agile manifesto?

As long as a process satisfies the following criteria, it is agile: - individuals and interactions over processes and tools - working software over comprehensive documentation - customer collaboration over contract negotiation; talk to customers and talk to them often - responding to change over following the plan

What makes a good design pattern?

A good pattern should be as general, reusable, and flexible (i.e., extendible) as possible - strict modeling of the real world leads to a system that reflects todays realities... but not necessarily tomorrow's ones But at the same time, a good pattern contains a (skeleton of a) solution that has been proven to effectively solve the problem in a specific context (define by the environment and forces at work) - you can't apply just about any pattern in just about any context

What does a smart reference to an object do?

A smart reference to an object replaces a simple pointer so that we can: - count the number of references to the real object so that its space can be freed automatically when there are no more references - load a persistent object into memory when its first references - check that the real object is locked before its accessed to ensure that no other object can change it

What is software architecture?

A software systems blueprint, containing description of: - system components, their interactions, and their interconnection

What is a modular system?

A system in which modules can be built separately and changes in one module have minimum impact on others

What are the advantages and disadvantages to data flow diagrams?

Advantages: - provides an intuitive model of a proposed system's high-level functionality and of the data dependencies among various processes - can be easily transformed into a function-oriented design (slightly harder but nonetheless possible to transform into an object-oriented design) Disadvantages: - can be ambiguous and discouraging to a software developer who is less familiar with the problem being modelled - suitable for a certain type of problem but not very suitable for others (e.g., interactive programs)

When is the strategy pattern applicable?

Allow your software to use different business requirements or algorithms depending on the context they occur

What do statechart diagrams represent?

Behaviour as states and transitions; for objects with interesting dynamic behaviour

What are the equations for calculating Technical Complexity Factors (TF) and Environmental Complexity Factors (EF)? Give an example calculation for both.

CF = 0.6 + 0.01 x Σ(TFw * R) Example calculation: TFactor total = 46.5 TCF = 0.6 + 0.01 x Σ(TFw * R) TCF = 0.6 + (0.01 x TFactor) TCF = 0.6 + (0.01 x 46.5) TCF = 1.065 EF = 1.4 - 0.03 x Σ(TFw * S) EFactor = 17.5 EF = 1.4 - (0.03 x 17.5) EF = 0.875

What is the objective of the requirements elicitation, specification, and validation phase?

Collect, analyze, refine, and organize the information necessary and sufficient for successful design of the system

What are the key architectural components?

Components: nodes Connectors: vertices connecting the nodes Configurations

What is every SE project precipitated by?

Every SE project is precipitated by some business need - a defect in an existing application needs to be corrected - a 'legacy system' needs to be adapted for the changing business environment - the features/functions of an existing application need to be extended - a new product, service, or system needs to be created

What is XP? Describe its features.

Extreme programming; an agile process that is driven by pair programming; not scaleable - test-driven development: you first write the test case, then you write the code that will be tested; this forces you to have a well tested code base

What is the essence of agile?

Fast reaction and small, incremental releases - deliver real business value on a very short cycle - the focus is on management practices, not on specific software development methodology

Define a Data-Flow Diagram and discuss its basic elements.

Data-flow diagram: models functionality in the top-down fashion Basic elements: - rectangles represent actors (entities that provide input data or receive the output result) - a data store: a formal repository or database of information - a bubble or circle represents a process that transforms input data flows into output data flows - an arrow represents a data flow, from an external entity / process / data store to a process / data store / external entity - note: data can't flow between data stores of between external entities without being transformed in the process

What are the pros and cons of delegation and inheritance?

Delegation: *Pros*: - flexibility; any object can be replaced at run time by another one (as long as it has the same type) *Cons*: - inefficiency: objects are incapsulated, takes more time to execute - can increase undesired coupling Inheritance: *Pros*: - straightforward to use - well supported - easy to implement new functionality *Cons*: - exposes a subclass to the details of its parent class - any changes in the parent class implementation forces the subclass to change (which then requires both to be compiled again)

How do you determine cohesion?

Describe the purpose of a module in a sentence, then perform the following tests: - if the sentence has to be a compound sentence and/or contains more than a single verb, the module is probably performing more than one function (*sequential or communication cohesion*) - if the sentence contains words relating to time, like "first", "nest", "after", "start", etc., the module probably has *sequential or temporal cohesion* - if the predicate of the sentence does not contain a single specific object following the verb, the module is probably logically cohesive, as in "edit all data", while "edit source data" may have functional cohesion - words like "initialize", "clean up", often imply *temporal cohesion* - *functionally cohesive* module can always be described by a simple statement

What is architecture?

High-level modeling which: - describes critical aspects of the thing - is understandable to many stakeholders - allows evaluation of the things properties *before* it is built - provides well understood tools and techniques for constructing the thing from its blueprint

What are the different categories of styles?

Idioms and patterns: - deal with global organizational structures - application-domain independent Example: pipe-and-filter, client-server, blackboard, layered Reference models: - specific configurations for certain application areas - may be effective outside their initial domains (but this requires extra care)

Why was/is loud computing a game-changer?

It is much cheaper to host a server on the cloud ($2-50K) than to buy a mainframe ($10M+)

What is the main difference between spiral and agile?

In spiral, the assumption is that the prototypes should resemble the whole product, whereas with agile you develop iteratively and in increments

What is information hiding?

Information hiding is distinguished by its guidance for decomposing a system: - each software unit encapsulates a separate design decision that could be changed in the future - then the interfaces and interface specifications are used to describe each software unit in terms of its externally visible properties Usually in this principle, modules may exhibit different kinds of cohesion - a module that hides a data representation may be informationally cohesive - a module that hides an algorithm may be functionally cohesive - a big advantage of information hiding is that the resulting software units are loosely coupled

Describe the changes in relative cost of hardware and software

Initially, the majority of the cost was the hardware, now the majority of the cost is with the software/software engineers

What are analogies to software architecture?

Hardware architecture - small number of design elements - scale by replication of (canonical) design elements Network architecture - focus on topology - only a few topologies considered (e.g., star, ring, grid) Building architecture - multiple views - styles

Why is modularity important?

Modularity ensures that: - each module will be easy to understand and develop - it will be easier to locate faults (because there are fewer suspect modules per fault) - it will be easier to change the system (because a change in one module affects relatively few other modules)

What are independent modules?

Modules that can function (completely) without the presence of another - note: full independence is not possible, modules must cooperate with each other, otherwise they are not modules but self-contained systems

Describe coupling in OO

Least interaction coupling if methods communicate directly with parameters: - with least number of parameters - with least amount of information being passed - with only data being passed, rather than control information - in other words, methods should pass the least amount of data, with least number of parameters

What is an example of a user story?

Mabel is a 75 year old grandmother; she is comfortable playing solitaire on the computer by is not computer literate; she would prefer to use the Home Shopping Network to purchase items *Goal*: define the purpose of the users' interactions - in other words, what does the user want to do? But take care not to describe how the user will satisfy a goal

Give an example of the persona participating in a scenario.

Mabel: - At the Amazon site, Mabel searches for books by Robert Munsch - She orders The paperbag Princess - She pays for the book - She has the book shipped

What should you refactor?

- duplicated code - long methods: more difficult to understand; an example of a code smell - long parameter list: hard to understand - large class - divergent change: when one type of change requires changing one subset of methods, another type of change requires changing another subset - feature envy: when lots of information from some other class is used - data clumps: attributes that clump together but are not part of the same class - shotgun surgery: a change that requires lots of little changes in lots of classes - primitive obsession: reluctance to use classes - switch statements - parallel inheritance hierarchies: each time you add a subclass to one hierarchy, you need to do it for all related hierarchies - speculative generality: "we need the ability to do this kind of thing someday" - lazy class: a class that no longer "pays its way" - temporary field: an attribute of an object is only set in certain circumstances, but an object should need all of its attributes - message chains: when a client asks an object for another object and then asks that object for another object, etc - inappropriate intimacy: pairs of classes that know too much about each others details - middle man: if a class is delegating more than half of its responsibilities to another class, do you really need it? - alternative classes with different interfaces: when two or more methods do the same thing but have different signature for what they do - data class: has fields, getting and setting methods for the fields, and nothing else - refused bequest: a subclass ignored most of the functionality provided by its superclass - comments can also be a problem, as they are sometimes used to hide bad code

What is architectural design?

- establishing the overall structure of a software system

What is a scrum?

- flexible, holistic product development strategy where a development team works as a unit to reach a common goal - 'moving together as a unit' - most popular method in the industry right now; prevalent in the agile world - focus on managing iterative development rather than specific agile practices

What are the benefits of Kanban?

- helps gets tasks complete rather than continuously adding new tasks to the 'in progress' category - helps with the flow of tasks from inception to completion

What are the two common levels of software design?

- high level (modules are defined but no logic is specified) - detailed design (logic specified for each module) - often, high-level design is called architecture design and low level design is just called design

Describe the architecture phase of the product backlog (pre-game phase -- architecture)

- high level design of the system, including it's architecture is planning based on the current items in the product backlog - a design review meeting is held to review the proposals for implementation and decisions are made on the basis of the review - if the project is an enhancement of an existing system, the changes needed for implementing the backlog are identified along with the problems they may cause (risk analysis) - preliminary plans for individual releases are prepared

How can refactoring be dangerous?

- if programmers spend time "cleaning up the code", then they spend less time implementing required functionality - refactoring can break code that previously worked - refactoring needs to be systematic, incremental, and safe (so use refactoring patterns and test constantly) - when you're doing refactoring you're not adding new functionality, you're improving the already present functionality - so there is a constant trade-off between spending time and money on new features or improving code quality - some refactoring requires that interfaces be changed

What are the issues with Agile?

- in an ideal world, the cost of making changes should be fairly low and should eventually plateau, and because agile is so nimble the overhead should be low, but this is often not the case - requirements are the cheapest to change and the end product is the most expensive - agile development cost grows slow at first but by the end of the project it grows exponentially - agile makes things easier but it doesn't keep costs down

What is inheritance?

- inheritance simplifies the model by eliminating redundancy - the children classes inherit the attributes and operations of the parent class

Briefly describe the V-Model

- interaction going between the blocks (different people giving feedback to others simultaneously) - popular model in electrical engineering - tried to capture the fact that you have testing and phases of construction of individual components - different activities take place sequentially, each has a well defined deliverable, and each one must be complete before the next one is undertaken

An agile process...

- is driven by customer descriptions of what is required (scenarios) - recognizes that plans are short-lived - develops software iteratively with heavy emphasis on constructive activities - delivers multiple 'software increments' - adapts as changes occur

What is the proxy pattern?

- it's time consuming and complicated to create instances of certain classes because of the complex mechanism involved in create the objects in memory, and the associated time delay, together known as "cost" - problem: we want to defer the full cost of creating and initializing an object until we actually need to use it (e.g., we don't need all the embedded pictures when we open up a word document) - but still, we want all the objects to be available for use when and if needed by their clients

What are the key points from the software architecture lecture?

- key architectural concepts are components, connectors, and configurations - nodes (components), connectors and edges, and configuration (the big picture of how everything is connected) - a *style* defines how individual instances of those concepts are interconnected and how they work together to provide the desired functionality - the software architecture is responsible for deriving a structural system model, a control model and a sub-system decomposition model - large systems rarely conform to a single architectural model - if you don't get the architecture right, there will be repercussions down the road when you start doing low level design and coding - when you make your blueprints, you want to show them to your coders to make sure that they can do the testing and coding of the project and that there are no issues

What are the six dominant principles/criteria of design?

- modularity: you want to have your logic split into two modules that interact with each other - interfaces: modules are interacting with each other via interfaces - information hiding: you want to hide as much of the inner workings as possible behind user interfaces - incremental development: you want to build incrementally, one block at a time - abstraction: - generality: when you're designing a module, think where in the future will this be used (so that it may be used again in other projects)

Why is modular independence desireable?

- modules can be modified separately - can be implemented and tested separately - programming cost decreases

How much should modules depend on each other?

- modules should not depend on one another more than necessary to fulfil their duties - the level of dependence is described by the concept of *coupling* - in general, the more we must know about module A in order to understand module B, the more closely connected A is to B - an important design goal is minimizing coupling as much as possible

Why does code decay over time?

- new features are added, often hastily - data structures become more complex - code becomes more difficult to understand note: it is, in fact, the design of the code that decays, and the implementation follows

What is interface specification?

- object interfaces have to be specified so that the objects and other components can be designed in parallel

What is the adaption problem?

- often a component has a very usable function but the interface does not allow for easy reuse - an adapter (sometimes called a wrapper) is a component that provides a new (or at least different) interface to an existing component - forces: you don't have access to multiple inheritance, or you have it but don't want to use it - analogy: electrical or plumbing adapters - we go from US to Canada or to Europe and you need different plugs, so this is a problem that we face in the real world and we also face it in the software world

What is a level estimate?

- one approach is to estimate the effort in perfect person-days, then add all of them for the team, as many as can fit into the sprint - another approach is to assign an estimate of effort level form 1 to 5 for each story, and then convert it to actual effort as follows: - level 1: 0.5 person days - level 2: 1 person day - level 3: 2 person days - level 4: 4 person days - level 5: 8 person days - this accounts for inherent nonlinearity and loss of accuracy with expanded time horizon

What was the software crisis of 1968

- over-budget - over-time - low quality - inefficient - not up to specs - unmaintainable - never delivered

What are the caveats to XP?

- pair programming is as effective as the people involved and works best in small teams where everyone is localized - XP is not scalable

What are the difficulties and risks with patterns?

- patterns are not a panacea -- universal cure for all problems in software design - do not apply a pattern just because you notices a word or a couple of words that seem to indicate that this or that pattern should be applied - always understand in depth the forces that need to be balanced, and when other patterns better balance the forces - make sure you justify each design decision carefully - some say that patterns target the wrong problem, and that the need for patterns results from using computer languages or techniques with insufficient abstraction ability - lacks formal foundations - use of patterns leads to inefficient solutions - it is often more efficient to use a well-factored implementation rather than a "just barely good enough" design pattern

Describe the post-game phase of the sprint/product backlog

- post-game: the closure of the release -- this phase is entered when we all agree that the requirements are complete: no more items and issues can be found, no one new can be involved - the system is ready for release and various preparation activities are performed (integration, system testing, documentation, etc)

What two fundamental principles of OO design does the strategy pattern emphasize?

- program to an interface, not an implementation - encapsulate the concept that varies

What is the façade pattern?

- provides a unified interface to a set of interfaces to entities in a subsystem - the pattern defines a higher-level interface that makes the subsystem entities easier to use - access to the services provided by the subsystem is made easier - e.g., façade (compiler) knows which subsystem classes are responsible for a request, and delegates client requests as appropriate

What are the UML core conventions?

- rectangles are classes or instances - ovals are functions or use cases - instances are denoted with an underlined name - types are denoted with non underlines names - diagrams are graphs

When should you refactor?

- refactor either before you add new functions to the code (makes it easier to add the function), or do it after to clean up the code - when you need to fix a bug - upon doing a code review

What are C and D requirements?

- requirements elicitation proper gives the so-called customer, or *C requirements*; these are expressed in the language that customers or users understand - requirements analysis gives the so-called *D requirements*, or detailed requirements, expressed through one or more (semi-) formal models, using notation familiar to the developers but not necessarily customers (which some people consider to be part of the actual design) - in literature, *C requirements* are also often called *user requirements*, and *D requirements* are often called *system requirements*

What are the disadvantages of high coupling?

- ripple effect: change in one module leads to changes in another - difficult model integration/assembly - difficult to reuse: need to add a bunch of dependent modules - difficult to mock test

What were the root causes of the 1968 software crisis?

- scale - complexity Before there were computers, programming was very easy, when we had a few weak computers, programming became a mild problem, and now that we have massive computers programming is an equally gigantic problem

What is velocity-based estimation?

- see how many units of work (story points, time, etc) you've completed in the last sprint and for the next sprint, pick the stories whose cumulative size matches the previous sprint - e.g., if you're on sprint 4, you want to take the number of story points from the last 3 sprints and average them out to get a better estimate

How does the strategy pattern work?

- separate the section of business rules/algorithms from the implementation of business rules/algorithms - allows the selection to be made based upon context

What are the aspects of estimation?

- several measures can be used in the planning phase of a software project: - productivity - quality - size - size is often used as the independent variable, which is then used to subsequently determine effort and cost estimates - alternatively, we try to estimate (relative) difficulty, and then translate that to effort (that is, actually, used often in agile development)

What is an activity diagram?

- shows flow control within a system - a special case of a state chart diagram in which states are activities ("functions") Two types of states: - action states cannot be decomposed any further - they happen "instantaneously" with respect to the level of abstraction using in the model - activity states can be decomposed into another activity diagram

What are the different definitions of a wrapper?

- some think that a wrapper is just a less fancy name for an adapter - others think that a wrapper pattern should isolate a component from a system, just as a façade isolates one tier (package or subsystem) from another, whilst an adapter should provide endpoint-to-endpoint mapping that enables a component to adapt to its environment - others consider a wrapper to be a generic pattern of which adapter, proxy, and decoder are but specialized classes

Why is visibility of control variables important?

- stakeholders will be able to see all four variables and can consciously choose which variables to control - if they don't like the resulting value of the fourth variable, they can change the inputs or choose which variables to control

How does incremental development work?

- start by mapping out the units' uses relation (relates each software unit to the other software units on which it depends) - uses graphs can help to identify progressively larger subsets of our system that we can implement and test incrementally

What are state diagrams?

- state diagrams are used to show how objects respond to different service requests and the state transitions triggered by these requests - useful high-level models of a system or an object's run-time behaviour - you don't usually need a state diagram for all of the objects in the system, as many of the objects in a typical system would be relatively simple

What are the benefits of agile?

- stresses customer satisfaction emphasizes teamwork - handles changing requirements with ease - quickly produces something useful and keeps making useful enhancements - developers feel they're in control while customers feel they are listened to average developers can produce great software fast

What are some examples of design models?

- subsystem models that show logical groupings of objects into coherent subsystems - sequence models that show the sequence of object interactions - state machine models that show how individual objects change their state in response to events - other models include use case models, aggregation models, generalized models, etc

What are different ways to get information?

- survey/questionnaire - observation - review of internal documents/business plans - review of operational software - domain analysis - prototypes - weblog - interview/meeting/questions and answers --> COMMUNICATION

What are the two primary focuses of software architectures?

- system structure - correspondence between requirements and implementation

Why refactoring?

- the basic philosophy of agile is to make things as simple as possible, but oftentimes you do not write the most general solution first - to implement new stories, you might need to change the existing code, add more cases, etc -- this does not help keep code simple - refactoring is the way to keep things (i.e., the overall simplicity and clarity of the code) under control

What is cohesion?

- the degree to which elements of a module belong together - higher cohesion is better - cohesion to a module represents how tightly bound the elements of a module are - gives a handle about whether the different elements of a module belong together - cohesion and coupling are interrelated: the greater cohesion of modules, the lower coupling between modules

What is generality?

- the design principle that makes a software unit as universally applicable as possible, to increase the chance that it will be useful in some future system - we make a unit more general by increasing the number of contexts in which it can be used; there are several ways of doing this: - parameterizing context-specific information - removing preconditions - simplifying postconditions

What is the cone of uncertainty in effort estimation?

- the earlier in the process, the wider the cone of uncertainty - x is the number we strive to estimate - it is not uncommon when you're doing the initial analysis/estimate to have a range of uncertainty of 400% - as you advance through the project, the cone of uncertainty will decrease until you reach the value of x - by the time you reach the requirements phase, your cone of uncertainty goes from 4x to about 1.25x - as you get more information, you can make better predictions

What are connectors?

- the edges/vertices - a connector i an architectural element that molds: - interactions among components - rules that govern those interactions

How is refactoring incremental design?

- the idea behind refactoring is to acknowledge that it will be difficult to get a design right the first time, and as program requirements change, the design may need to change as well - refactoring provides techniques for evolving the design in small incremental steps - e.g., we have some sort of code snippet, we make changes incrementally; it's a good idea, especially if you have test cases, to recompile your code after every change, run your tests after every change, and make sure that your results are the same - the whole idea of refactoring is making sure that your results are the same after making changes, if they're not, then you've broken something - if you move things around but you don't have mechanisms to test your changes, sometimes you introduce bugs and you find it out the hard way later on

What is modularity?

- the principle of keeping various unrelated aspects of a system separate from each other so that each aspect can be studied in isolation (also called separation of concerns) - if the principle is applied well, each resulting module will have a single purpose and will be relatively independent of the others

What are requirements elicitations?

- the process of defining the new system (customers, developers, management) in terms of what it is supposed to do and how it is supposed to behave -requirement elicitation tries to: - bring out what the user already know about the future system, which is more difficult, even though the user is ver likely to ask about it at delivery - organize this knowledge in a usable form

What is a design pattern?

- the recurring aspects of designs are called design patterns - a pattern is the outline (skeleton) of a reusable solution to a general problem encountered in a particular context - alternative definition: a software design pattern is a model proposed for imitation in the process of solving a software design problem

What is the design and implementation stage in software engineering? Describe them.

- the stage at which an executable software system is developed - software design is a creative activity in which you identify software components and their relationships, based on customer requirements - implementation is the process of realizing the design as a program

What is coupling?

- the strength of interconnections between modules, the degree to which a module relies on other modules - highly coupled modules are joined by strong interconnection - loosely coupled modules have weak interconnection - the goal is to have modules as loosely couples as possible

Why are entity-relationship (ER) diagrams popular?

- they provide an overview of the problem to be addressed and they tend to be comparatively stable

What are the drawback of user stories?

- they're informal and too short to describe their topic in sufficient detail -- in most cases, they are not sufficient to actually implement (i.e., program) - additional information is always needed, hence successful development relies on presence or availability of a knowledgeable customer (who can provide the missing pieces when asked) - also, they tend to be vague so you can't really benefit from asking the customer to sign off on a set of index cards

What are general strategies for creating fast code?

- time budgeting: each piece has a fixed amount of time in a budget and cannot exceed that - constant attention: everyone should do whatever possible to make each part they develop perform as fast as possible - often such modifications degrade the readability, modifiability, and maintainability to such an extent that development is slowed beyond recovery for very small improvements in preference - write first, time later

What role are user stories intended to perform?

- to enable time estimates for the release plan - to facilitate construction of engineering tasks (programming) - to eventually become production code - to drive creation of acceptance tests

What is the developers bill of rights?

- to know the project objectives and to be able to clarify priorities - to know in detail the project they are supposed to build - to have ready access to the customer, manager, marketer, or any other person responsible for the functionality - to work each phase of the project in a technically responsible way - to approve effort and schedule estimates for ant work that they will be asked to perform - to have the projects status reported accurately to customers and upper management - to work in a productive environment free from frequent and unnecessary interruptions

What is the customers bill of rights?

- to set objectives for the project and have them followed - to know how long the software project will take and how much it will cost - to decide which features are in and which are out of the software - to know the projects status at any time during development - to make reasonable changes to requirements throughout the course of the project and to know the cost of making these changes - to be appraised regularly of the risks that could affect cost, schedule, or quality - to have ready access to project deliverables throughout the process

What are the major factors that influence coupling?

- types of connection between modules - complexity of the interface - type of information flow between modules

What is a solution to the proxy pattern?

- use a proxy which acts as a stand-in for the real object - but the proxy and the real object can have the same interface - but the proxy has a lightweight implementation - instead, it simply accesses methods from the heavyweights when needed

What are user stories?

- usually written ("owned") by customers, not developers - 2-3 sentences of text written in customer's language without technical detail, possibly augmented by samples (e.g., formatted report) - useful to create "personas" which served to avoid the "super user" syndrome - users are typically given names and profiles, which helps people visualize, reason about, and remember

What are entity-relationship diagrams?

- visual way of looking at a database - a popular graphical notation paradigm for representing conceptual models -- static models of information - likely to be used early in the requirements phase

What are the fundamental questions we need to answer about software architecture?

- what are the element of the architecture - what are the high-level components we need to have - how are they connected - why are they there in the first place

What do we need to know to build the architecture?

- which aspects of a software are architecturally relevant - how should they be represented in order to enable stakeholders to understand, reason, and communicate about a system before it's built - what tools and techniques are useful got implementing an architecture in a manner that preserves its properties

How do you improve code that has decayed?

- you refactor it - another way to improve is complete redesign, but that implies repeating the whole development which is not the preferred solution

What are the three phases in scrum?

1. Initial phase is an outline planning phase where you establish the general objectives for the project and design the software architecture 2. Followed by a series of sprint cycles, where each cycle develops an increment of the system 3. Project closure phase wraps up the projects, completes required documentation such as system help frames and user manuals and assesses the lessons learned from the project

What are the four control variables of every project?

1. Scope: how much is to be done 2. Resources: how many people are available 3. Time: when the project or release will be done 4. Quality: how good the software will be and how well tested it will be - external forces pick the values of any 3, the development team pick the value of the 4th

What is the scrum flow?

1. Sprint planning meeting: define sprint backlog, make estimates, assign tasks 2. Sprint: typically a 30 day development with daily scrums 3. Sprint review meeting: followed (optionally) by a sprint retrospective meeting

What is the definition of software engineering?

1. application of systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software (the application of engineering to software) 2. the study of approaches as in (1)

What are the 3 roles in the development team?

1. *Scrum master*: interacts with project team, customer, and management; responsible for ensuring that the project is carried through, for removal of impediments, and for keeping the team working productively 2. *Product owner*: officially responsible for the project, managing, controlling, making visible the product backlog list 3. *Scrum team*: project team with the authority to decide on necessary action in order to achieve the goals of each sprint; involved in effort estimation, creation of sprint backlog, and reviews of product backlog

What are the three core constructs of entity-relationship diagrams?

1. An *entity*: depicted as a rectangle, represents a collection of real-world objects that have common properties and behaviours 2. A *relationship*: depicted as an edge between two entities, with a diamond in the middle of the edge specifying the type of relationship 3. An *attribute*: an annotation on an entity that describes data or properties associated with the entity

What are the steps of the waterfall method?

1. Communication: project initiation, requirement gathering 2. Planing: estimating, scheduling, tracking 3. Modeling: analysis, design 4. Construction: code, test 5. Deployment: delivery, support, feedback You go from block to block until you ship, but this method is no longer used

What are the two main approaches of reuse?

1. Composition (also called black-box reuse), where new functionality is obtained by aggregation 2. Inheritance (also called white-box reuse), where functionality is obtained by inheritance (implementation inheritance, interface inheritance, delegation)

What are the steps to do good software cost estimation?

1. establish objective 2. plan for required data and resource 3. pin down software requirements 4. work out as much detail as feasible 5. use several independent techniques and sources 6. compare and iterate estimates 7. follow up

What is the typical roadmap for C requirements?

1. identify the customer(s) 2. interview customer representatives, with the aid of available documentation (manuals, procedures, forms, online forms, existing software, anything that can shed more light on the operation of the new system) 3. write C requirements (maybe using templates) 4. inspect/analyze them for completeness, correctness, consistency, clarity (make sure customers are involved) 5. make the customer sign off (*very important step*), created a kind of contractual obligation: you promise to deliver what is in there, while the customer promises not to request what is not there

Describe the sprint cycle

1. the team is organized for development of the software; during this stage the development team is isolated from customers and the organization and all communication are channeled through the scrum master 2. the scrum master protects the development team from external distractions 3. at the end of the sprint, the work is reviewed and presented to the stakeholders and the next sprint cycle then begins

What is the typical roadmap for building D requirements?

1. using C requirements as the starting point, build D requirements, or detailed requirements, using established formal notation(s) 2. D requirements consist of *models*: abstractions that represent the system (desired or designed) but without unnecessary detail, and possibly from a particular viewpoint) NOTE: UML is a tool for building models, some of them, as there are important formalisms that UML deliberately omits NOTE: the customer should sign off on these

How is scrum different from the waterfall model?

Scrum divides the project into fixed or variable size iterations (sprints), each of which features a complete development cycle

What is the technique of sandwhiching?

Sometimes uses graphs have cycles, which can be broken using a technique called sandwiching: - once of the cycle's units is decomposing into two units, such that one of the new units has no dependencies - sandwiching can be applied more than once, to break either mutual dependencies in tightly coupled units or long dependency chains

Describe step 1 of good software cost estimation

Step 1: Establish Objectives - key the objectives to the needs for decision making information - balance the estimating accuracy objectives for the various system components - use the objectives to drive the level of detail and effort required to perform the subsequent steps - re-examine and modify

Describe step 2 of good software cost estimation

Step 2: Plan for Data and Resources - your boss comes into your office and says: "We've got this proposal that has to be signed off by noon tomorrow so we can send it out. Can you work me up a quick software estimate for it?" typical software cost-estimate plan includes: - purpose - products and schedules - responsibilities - procedures - required resources - assumptions

Describe step 3 of good software cost estimation

Step 3: Pin Down Requirements - use standardized techniques - eliminate vagueness and ambiguity - requirements need to be testable (i.e., hard) in order to be considered

Describe step 4 of good software cost estimation

Step 4: Work Out as Much Detail as Feasible - the more detail, the better we understand the technical aspects - the more pieces of software we estimate, the more we reduce the variance of the estimate - the more we think through all the functions, the less likely we are to miss the cost of unobtrusive components

Describe step 5 of good software cost estimation

Step 5: Get a Second Opinion (or Opinions) - this avoids the weakness of any single method, and capitalizes on their joint strengths (of course, it's always possible... but it's beneficial as an independent check) - there are a number of major methods for cost estimation

Describe step 6 of good software cost estimation

Step 6: Compare and Iterate Estimates - analyze the differences in estimates - optimist/pessimist phenomenon: differing costs of similar components may be due to differing mindset of persons doing the estimation (glass is half full, or half empty, or will eventually be empty, or its twice as big as it needs to be) - tall pole in the tent phenomenon: some techniques relate the size of components to its complexity, which is not always the case

Describe step 7 of good software cost estimation

Step 7: Follow Up - gather data on actual costs throughout the project, and compare these to the estimates - but keep in mind that: - inputs to the estimate are imperfect - estimating techniques are imperfect - project may not exactly fit the model - software projects are volatile

What do sequence diagrams represent?

The behaviour as interactions - UML sequence diagrams represent behaviour in terms of interactions

What is XP's feedback loop? Describe its process.

Release plan (months) --> iteration plan (weeks) --> acceptance test (days) --> stand up meeting (one day) --> pair negotiation (hours) --> unit test (minutes) --> pair programming (seconds) - every couple of hours you decide as a pair (pair-programming) what you'll be working on next; once a day you talk to your larger team to update - every few days you'll do acceptance testing where you show the code/code changes to your client - talking to your client once a week for an hour is what happens normally; not a good idea to try to have constant communication with them

What is the output often referred to as?

Requirements document or requirements specification

What are the core knowledge areas of SE?

Requirements, design, coding, testing, maintenance

How large is a scrum team?

Typically 5-10 people, max 15

What is the equation for calculating total Use Case Points?

UUCP = UAW + UUCW UCP = UUCP x TCF x EF

What are the different components of the V-Model?

Unit Tests - unit tests are created to test individual functions; this can help improve the design of the components Integration Testing - communication between different components is established - making sure that each component is doing/returning what it's supposed to - helps improve design of individual components and the architecture System Testing - emulating the way a client would be using the product; looking at the whole picture Acceptance Testing - done by the client

Unit tests vs integration tests vs system tests

Unit tests test specific function, integration tests test how those functions work together, and system testing tests the whole program

Discuss the approaches to identification.

Use a grammatical approach based on a natural language description of the system - nouns --> objects and attributes - verbs --> operations or services Base the identification on tangible things in the application domain - entities: weather station, barometer - roles: library patrons, staff - location: home, office - use a behavioural approach and identify objects based on what participates in what behaviour - use a scenario-based analysis, in which objects, attributes, and methods in each scenario need to be identified

What do use case diagrams represent?

The functionality of the system from the user's point of view

What is the main goal of reuse?

The main goal is to use knowledge from previous experience to solve the current problem (i.e., use the functionality which is already available

What is the t-shirt approach to estimating?

The simplest requirement is an xxs, and the most complicated is an xxl, all the other requirements are somewhere in between

When and how should you use adapters?

When: - you need to use an existing class, and its interface does does not match the one you need - you want to create a reusable class that cooperates with unrelated or unforeseen classes, that is, classes that don't necessarily have compatible interfaces - adapters obtained in this way are often referred to as Class Adapters - however, there may be cases where you need to use several existing subclasses, but it's impractical to adapt their interface by subclassing every one - in that case, we use an Object Adapter to adapt the interface of its parent class

When should you use a bridge?

When: - you want tun-time binding of the implementation - you have a proliferation of classes resulting from a coupled interface and numerous implementations - you want to share an implementation among multiple objects, or - you need to map orthogonal class hierarchies

What are actors?

an actor models an external entity which communicates with the system: - user - external system - physical environment - an actor has a unique name and a (desirable but optional) description examples: - passenger: a person in the train - GPS satellite: provides the system with GPS coordinates

What are the different steps of the spiral model?

communication, planning (estimation, scheduling, risk analysis), modeling (analysis, design), construction (code, test), deployment (delivery, feedback) - the programmer will go through these steps over and over until the customer is completely happy with a prototype and then the product can be built

When is coupling minimized and increased?

minimized if: - only defined entry of a module is used by others - information is passed exclusively through parameters increased if: - indirect and obscure interface are used - internals of a module are directly used - shared variables employed for communication

What is a version management system an example of?

A layered architecture

What is noun identification?

Noun identification is an effective technique to identify candidate application classes

Is a façade a container?

Not really, although it may (superficially) look like one; a façade is just a front end to a package meant to simply access, while a container encapsulates its contents and limits access to it