Advanced Software Engineering
YAGNI
"You ain't gonna need it" Only design for the current iteration, not classes/responsibilities/collaborators that may come up later
large class
"bloater" class that has grown too large, typically through adding
Design Sprints - Friday
- 1-on-1 interviews with 5 'customers', show prototype and ask open-ended questions - Rest of team observes interaction - Review customer patterns - positive, negative, neutral and move on from there
Waterfall
- A plan-driven, step-by-step sequential process - Review and sign-off at each step - Each step must be verified before going on to the next - Benefits: Easy to explain to non-tech management/government agents. "Road map" to coordinate multiple developers. Some control over scope of project--> More predictability of const and schedule - Drawbacks: One chance to get it right (when problems are found during one step, they may be due to a flaw at a previous step. Backtracking can cause >100% schedule overrun). Emphasis on scope control-->Inflexibility for later changes. No frequent customer involvement (developer doesn't know what the customer wants) - Replaced by adaptive processes like Agile
Continuous Deployment
- Adds automatic deployment to continuous integration. Installs on the production server(s) and our produces a patch to customers. - Examples: Jenkins, Travis CI
What is the goal of a unit test?
- Aim to test a method or class in isolation from the rest of a program
Design Sprints - 0th day
- Assemble team, get space, buy supplies
Design Sprints - Monday
- Assess long term goal - Make a workflow sketch of customers/key players interacting with product - Ask experts on projects for advice - Pick a target to focus on for the rest of sprint
Teardown Code
- Associated with unit testing - Cleans up the state of the unit test so there are no externally visible side effects
Setup Code
- Associated with unit testing - Setup code is invoked before unit testing to set up a state of the world that simulates the state the program would be in when the methods invoked during the full system execution
Test runner/harness
- Call and run unit tests of a program rather than the program itself running tests - Call stubs and mocks rather than calling code in the program
Continuous Integration/Deployment (Pre-Commit)
- Does a local build once the commit command is run, commit doesn't go through if build doesn't pass
Continuous Integration/Deployment (Post-Commit)
- Does a remote build on the repo server after the commit finishes
How do developers determine the estimate?
- Don't ask the customer! - Previous experience - "Planning poker" - playing cards marked 1⁄2, 1, 2, 3, 5, 8, 13, 20, 40, ∞, ? days - Estimates larger than 8 days (2 weeks with time for meetings, demos, disasters) are suspect: "I have no clue how long this will take"
Build tools
- Example: make for C compilation - Automate lots of things for non-compiled languages (e.g. runs package manager to update all external dependencies and/or packages up your program to be installable from a package manager)
Design Sprints - Wednesday
- Go through sketches, critique each, choose best - Weave into storyboard and fill in gaps
What is a test case? What does it do?
- Identified by naming convention or annotation - Usually maintained in a parallel directory/folder hierarchy to corresponding source code - Constructs input for a method and involves method with input parameters - Supplies non-parameter inputs (e.g. inputs from simulated human user, file, network, database, device) - Collects results of method - A set of asserts check results are as expected - Assumes test oracle can always tell whether actual output is correct for given input
Design Sprints - Thursday
- Implement prototype - Do a trial run of the interview script
Continuous Integration
- Integrates version control with build - Anytime anything is checked into the version control system a full build is done
Package Managers
- Keep track of 3rd party code units - They utilize the metadata associated with each package - Work like a mobile app store - Eliminate need for manual installs and updates - Examples: npm, pip
What are the priorities that come from the user?
- Minimum viable product - Categorization of high, medium, and low priorities - Typically there will be more higher priority features than will fit in iteration, remember time box vs. scope box Possibly micro-prioritize within priority category (buckets 10, 20, 30, 40, 50)
GUI Unit testing
- Need something that simulates human user interactions - Examples: selenium, appium
Why is project velocity needed?
- Predicting how long it will take developers to do work can never be 100% accurate - Computers have lives (hardware and software maintenance and downtime) - Developers have lives (personal days, bad days) - Projects have lives (training, meetings, customer interruptions) - Organizations have lives (CTO unexpectedly schedules full-day all-hands meeting)
Design Sprints - Tuesday
- Review existing ideas from other products - Team members separately sketch ideas - "Crazy 8s" - set of 8 quick sketches, then 3 panel storyboard - Start recruiting customers for tests on Friday
What can bug finders detect?
- Secret keys embedded in code - Using 3rd party libraries with known security vulnerabilities - Too many paths in a given function or method (cyclomatic complexity) - Dereferencing a null pointer - Checks/limits on array bounds to prevent buffer overflow - In multi-threaded code check that data dependencies cannot race and locks are matched with unlocks
Bug finders (bug checkers
- Sophisticated tools that look for generic bugs as well as code smells - They don't know about the functionality of code - Sometimes encode domain-specific rules (web/client server messaging formats and protocols) or knowledge of error specifications (C library functions return 0 on success and negative on failure)
What are time point estimates and who they come from?
- Time point estimates are how many time units to complete a given user story (typical minimum unit = 1⁄2 day) - Completion of a user story includes wireframes, design, coding, testing, review - Often use "points" or other relative units instead of explicit time, X seems likely to take 1⁄2 as long as Y or 3 times as long as Z - Schedule time/points for preparing and doing demo/delivery too!
What is the accuracy of static analysis bug checkers?
- Typically produce many false positives - Cannot avoid false negatives (cannot find all bugs) - They do not replace testing
How do testing and debugging fit into iteration?
- Unit testing and code review is often included in time point estimates - Bugs may be reported by testing team or user - Debugging/fixing can be defined as special kind of user story (e.g., pink cards) - also prioritized and estimated - Fit significant bug stories into current iteration by pushing some previously planned stories to next iteration (overflow)
Regression
- When fixing a bug or adding a feature causes previously working code to break or regress.
Package Managers and Dependencies
- When you organize your own codebase into multiple code units then come of your code units are dependent on other code units - When you reuse code units or other resources written by others, your code is dependent on those resources
Storyboard
-A sequence of wireframes, often corresponding to a user story or use case -Often used for the "fake it" prototypes of design sprints
Wireframe
-A sketch of a screen or page for a website/mobile app -Lays out content and functionality, establishes basic structure and what interface elements will be shown -In the case of a single-page app, use different wireframes depicting different states of that single page
Agile
-Adaptive Process -All customers/stakeholders involved throughout software process. -Customer wants to know: How much will it cost, how long will it take, what does the software need to do -Change: Customers can change their mind at any time -Incremental: Pick one part of the app, develop it, then go on to the next part -Iteration: Short project, deliver in increments. Iteration also called a "Sprint". Each includes full range of planning/reqs/design/testing -Emphasis on delivery: Incremental shipping to customer. This is why Agile shouldn't be used for safety-critical systems.
User Stories
-As who I want what so that why -short simple description of ONE function -typically need acceptance criteria -DOES NOT CONTAIN CRUD(create, read, update, delete) -done before development starts
Task board
-Associated with adaptive/agile processes -Says who does what component, and which components have been completed
Standup Meetings
-Associated with adaptive/agile processes -Short, ~10 minutes -Daily--> update task board and burndown chart, detect/remove blockages
class diagram-closed aggregation
-CONSISTS_OF, strong lifecycle -strong lifecycle: deleting will delete all children -filled diamond
Single Responsibility Principle(SRP)
-Every object should have a single responsisbility -check with "the <class name><method name> itself" -reason to change: requirement of the project change
What is the basic process for building an abstract model of the app domain?
-Identify "entities" (nouns)- roles, events, physical tangible devices. Identify static relationships between them -Construct scenarios corresponding to a single path through a use case -Identify dynamic responsibilities of the things during these scenarios
LSP
-Liskov Substitution Principle -extends OCP to require that subtypes must be substitutable for their base types -do inherited methods make sense for instances of the subclass
Time Box vs. Scope Box
-You can increase scope of an iteration, but this increases time -If originally planned features of an iteration take longer than scheduled, you must reduce scope or increase time -You can't both increase scope and decrease/keep constant time -Choosing time boxing over scope boxing controls costs and maintains some predictability (you will complete something each iteration)
Functionalities of version control systems
-backup and restore collection of files - sync among multiple users - short term undo - long term undo -track changes
Difference between framework and library
-code in charge when code calls library - framework calls code and framework in control.
epics
-collections of user stories -different type of user along a sequence
class diagrams
-convey information about static structure of your application domain -useful to communicate, visualize and analyze -broken down to attributes, operations, association, open aggregation
Version Control-VNC
-example: windows backup and restore, dropbox, google drive -you need to know exactly what was done to fix the bug -does not address multiple using a file
Use Cases
-expand user stories -describe the step by step details of how the user role interacts with the software - capture anything and everything that can go wrong
Software Enginnering
-ill defined problems -teams -ten-thousands bugs -runs in production -excisting codebase -use anything that saves time -continual availability -potentially high cost of errors
class diagram-realization
-implemtation from an interface -dash line with unfilled arrow
class diagram-generalization
-inheritance from super class to subclass -unfilled arrow
class diagram-association
-instances of one know about or communicate with instrance of another class -normal arrow
Version Control-renaming files
-keeps your work safe, can undo mistakes -okay for small number of files and versions -quickly becomes unmangable
OCP
-open closed princple -classes should be open for extension and closed for modification, allows change but without modifying any eisting code
Problems with customer requirements
-requirements may be very vague in customer's own mind, or diffucult for customer to explain -little techinical sophistication and ability to articulate software requirments
Version Control-Git
-synchronization among multiple user -short term undo, long term undo -track changes -repository -client -head -all basic git control
Pair Programming-definition
-take turns driving -switch roles at designated intervals such as 25 min -do not divide work
Pair Programming-con
-takes double the amount of man power for the same amount of code -hard to convince non-technical management
Design Principles
-technique that can be applied to designing or writing code to make that code more maintainable, flexiable, and extensible
Pair Programming-pro
-truck factor: multiple people know how to use the problem -shared responsibility to complete tasks on time -stay focus and on task -each member of pair expects other to follow "best practices" -better quality solutions -pool knowledge resources
What are the two stages of Object-Oriented Analysis and Design (OOAD)?
1. Build an abstract model of the problem domain or application domain (what) 2. Add architectural style, design patterns, implementation constraints to make it concrete (how)
Sprint Backlog
A breakdown of the product backlog that addresses each needed feature/fix in a sprint.
Design Sprints - definition
A concept designed by Google Ventures to answer business questions in 5 days without full development and launch cycle
Transitive dependencies
A depends on B depends on C depends on D
What is a unit?
A method or class
Dependency (another definition)
A relationship among work tasks, such as one task cannot be done until the other is done. These should be minimized
Sprint
A set amount of time in which an iteration of a project is done. A sprint can last anywhere from a week to a month. Usually its 2 weeks.
Product Backlog
A set of features/fixes that need to be implemented for a product based on user cases and user stories.
What should you do if you run out of work to do? (concerning project velocity)
Add projects from the backlog to your schedule
Static relationship between entities (concerning OOAD)
Association- "uses" (Car uses road) Inheritance- "is a" (professor is a human) Aggregation- weak containment (grouping. Child can exist independent. Delete class and students still exist) Composition- strong containment (Real-world whole part. Child not independent. Delete house deletes rooms)
Mocks
Behavior verification of a test
What do class diagrams include?
Class name, attributes, operations. Some show structure of a single class, others show relationships between classes.
CRC cards
Class name= thing/entity Responsibility=What it needs to do Collaborators=Classes it interacts with
Coupling (also referred to as dependency)
Degree to which your code unit depends on the innards of another code unit, so that if the other code unit changes, then you need to change your own code. Always bad.
Client
Developer machine
DRY
Don't repeat yourself principle: avoid duplicate code and redundant work
Unit testing tools
Execute the test cases you write. Some may write skeletons of test cases, but they don't write them for you.
Sprint (more info)
First release of new product might take several sprints, e.g., 3 months (fiscal quarter), where delivery may require its own release sprint rather than fitting into per-sprint review
class diagram-open aggregation
HAS-A, no lifecycle relationship -open diamond
What does project velocity account for?
Lost time
What do you do once your CRC cards cover every user story for the current iteration?
Make class diagrams
Design Sprints - Decider
Makes ultimate decision in any debate
What should you do if you cannot finish the scheduled work? (concerning project velocity)
Move projects from your schedule into the backlog.
Flaky test
Produces different results on different test suite executions even when nothing is changed
How do you detect regression?
Re-run all test cases that previously passed and see if any start to fail
Design Sprints - Facilitator
Runs meetings throughout sprints
Allocating responsibilities of classes (when making CRC cards)
Split classes with too many responsibilities Combine classes with too few responsibilities. Remove duplicates Avoid classes with only CRUD operations (create, read, update, delete)
Stubs
State verification of a test
Project velocity
The amount of work that your team schedules to do divided by the amount of work that your team should be able to do. Most companies have a product velocity of 80%. So if your team should be able to do 100 units of work and you want a project velocity of 70%, you schedule 70 units of work to do.
YAGNI
Your aren't gonna need it: do simplest thing that could possibly work
feature envy
a "coupler" class that uses public method of another class excessive
static analysis
a tool that just looks at code without execution
refused bequest
an "object-oriented abuser" class that overrides a method of a base class in such a way that the contract of the base class is not honored by the derived class
data clump
another "bloater" that occurs when group of variables passed around together in various parts of code
inappropriate intimacy
another kind of "coupler" class that has dependencies on implementation details (internal fields and methods) of another class
Use Case Element - Events
any new triggers initiated by the completion of use case
Use Case Element - Preconditions
anything that is expected to be true before case begins
Use Case Element - Postconditions
anything that must be true
message chains
asks for one object of another object, which then asks for another... just keeps going. lots of code, can be simplified
code smells
badly written code, refers to symptom in the source cold. makes changes more difficult and leads to bugs
switch statements
complex switch operator or sequence of if statements
technical debt
cost of additional rework later on caused by fast and easy solution instead of better one
dead code, speculative generality
dispensable" unused code, once previously used and just in case (don't need)
checkin/commit/push
doesn't work to just add to local copy, need to tell VCS to track
checkout/pull
download or copy from repo to local working set
Brainstorming workshops(Requirements elicitation)
drawing on a board to create an idea
Use Case Element - Exception flows
error cases, prevent user from achieving goal
Repository
file database
diff/delta
find differences between two revisions
contrived complexity
forced usage of overcomplicated design where simpler design would suffice.
branching
fork a copy of code base and track changes separately
update/sync
get latest revision of files from repo
coding conventions
govern how and when to use comments, white spaces, naming, grouping, organization, structure
observation and interview when creating a new project(Requirements elicitation)
how will software fit into buisness workflow -constrainst on how it interact with existing system
Design Sprint - Overview
http://www.ehousestudio.com/uploads/blog/DesignSprint-Process-v1.jpg
merge
integrate changes from working set into previous revision
Head
latest revision
Use Case Element - Alternate flows
less common user/system interactions, special cases
too many parameters
list is hard to read, calling and testing complicated
Working set/working copy
local directory on client where dev makes changes
LOCO model
lock on checkout, unlock on checkin (need way to break lock
bug finders
look for generic bugs as well as code smells
URL routing
maps HTTP request to resource, the code that will handle the request and receive any query parameters
tagging
marks the set of all file revisions contributing to some milestone
MOM model
merge on modify
Truck factor
number of engineers that would have disappear before project would be in serious jeopardy
Use Case Element - Description
paragraph (copy user story)
role playing when creating a new project(Requirements elicitation)
pretend to be the software intereacting with the user
main = master = trunk
primary set of versions
dynamic analysis
requires execution
Framework
set of generic components that work together to accomplish common development tasks and functionalities for a popular target domain
Use Case Element - Basic Flow
set of steps actor needs to take to accomplish goal
revert
throw away local changes and reload latest revisions from repo
Use Case Element - Actor
type of users who engage
Use Case Element - Name
verb/noun or actor/verb/noun communicates scope
class diagram-attributes
what describes it
class diagram-operations
what doe sit do
Use Case Element - Triggers
whatever causes the initiation of use case
Server
where repo lives
Burndown Chart
y-axis: Time remaining x-axis: Milestones left Ideal burndown is a constant downward slope to zero You don't want to have more milestones left than time. Associated with agile processes.
