Agile Midterm (V 2)
Can User Acceptance Testing be automated?
No
Do unit tests require changes to the code being tested?
No
Brooks' law
"Adding manpower to a late software project makes it later." Caveats: - Brooks's law only applies to projects that are already late. Adding more developers at the start of a project creates no such problem. - Skilled software engineers can be added with fewer problems than adding unseasoned developers
How does Scrum try to address the challenges inherent in the Cone of Uncertainty?
"Cone of Uncertainty" maintains that there are many unknowns at the beginning of a project, and few unknowns at the end of a project. The amount of risk involved in making changes to a project shrinks over time: since a project is poorly defined in the beginning, there is low risk of making changes to it; once a project is very well defined towards the end, there is high risk of making changes to it. Scrum, and most other agile development workflows, divide projects into small increments of work, and there is always a functioning product at the end of each increment. This makes the risk of making changes throughout the entire lifecycle of the project somewhat low and constant, since changes only affect a small increment of work, and not the entire project.
4 advantages of using a code linter over manual checking of code.
- Abates the risk of personal conflict within a team - Checks for correct syntax faster than a human - Checks for good code style faster than a human - Identifies the same issues every time it is run on the same code
Imagine the following scenario: a software engineer earns $100/hr. A given simple project requires a set of 100 unit tests. Each unit test takes an average of 3 minutes for the engineer to write. If automated, the unit tests take a total of 1 minute to run. If the tests are executed manually, the unit tests take a total of 10 minutes to run. How many times must the set of unit tests be run in order for the time savings they offer throughout the lifetime of the project to compensate for the up-front cost of their creation?
--Writing tests-- 100 tests X 3 minutes/test = 300 minutes = 5 hours to write tests 5 hours @ $100/hour = $500 cost for the engineer to write tests --Running tests automatically-- 1 minutes = 0.0167 hours to run the tests automatically 0.0167 hours @ $100/hour = $1.67 for the engineer to run the tests automatically --Running tests manually-- 10 minutes = 0.167 hours to run the tests manually 0.167 hours @ $100/hr = $16.7 for the engineer to run the tests manually --To recoup the $500 cost of writing the tests-- Each running of the tests saves $16.7 - $1.67 = $15.03 To recoup the cost, they must be run $500 / $15.03 = 33 times... not much! (This question makes no sense btw)
How many Tasks should be addressed in a single branch in the version control system if following the Feature Branch Workflow?
1
Scrum Process:
Product Backlog -> Sprint Backlog -> Sprint -> Working increment of the software
What's a Spike?
Spike is a User Story that is not customer-facing, but something internal that the team has to do to help their own work
3 reasons Software Engineering is necessary
1: Creating software is difficult; 2: Artisanal approaches do not scale well; 3: Software is everywhere; 4: Software is not just a program 5: Client expectations 6: Developer onboarding
4 High-level SE activities
1: Specification - understanding what the system must do and how it must work in order to be satisfactory 2: Development - programming the code and building the systems 3: Validation - making sure the product works correctly and meets the specification 4: Evolution - maintenance and refinement of the product
Judgment vs. Perception
A Judging preference focuses on deadlines, task completion, making decisions A Perceiving preference focuses on adaptability, open to new opportunities
git remote
A repository may 'know' about another repository. For example, a local repository that originated as a clone of a remote repository may store a reference to the original repository from which it was cloned. The local repository refers to that original remote repository as a remote.
Which type of UML diagram for high-level logic and decision-making of a particular system process? Activity diagram Domain model diagram Sequence diagram State chart diagram Use case diagram
Activity diagram
Problems with Agile thinking
Agile does not remove all problems, like contractors who don't deliver when they are supposed to or charge more than they said they would Agile projects are always incomplete, except perhaps after very last sprint (maybe) Most contracts in industry are written with a description of the scope of the work to be done, often with detailed requirements, and the cost and timing of such work - these are fixed, which makes true Agile development hard-to-impossible. Most true Agile teams solve this by considering the scope and requirements of the work as flexible, while agreeing to a fixed cost and time
First programmer to realize the need for 'librarian types' to keep software development on track
Alan Turing
What activity does Scrum include that address the Agile manifesto's preference for "Responding to change over following a plan"?
All activities where a project is defined and redefined at regular intervals: - Sprint planning - Product backlog grooming - Stakeholder demos
Who should be interviewed as part of the requirements gathering/elicitation process?
All stakeholders and a sample of end-user/customers
Features of Make
Allows developers to define instructions for how exactly to build specific targets Performs minimal recompilation Tracks dependencies Written in a programming language that will look familiar to most developers * Makefiles are specific to a given platform, although tools like GNU Automake allow developers to auto-generate Makefiles for several different platforms at once.
Why learn bash
Almost all build systems can execute arbitrary bash scripts. These can automate about any operation you would perform in the command line, such as: deleting files, connecting to databases, launching applications, running tests, compiling, logging into remote machines, pulling code from a repo, etc.
Sprint Review
Any User Stories haven't been accepted as complete reprioritized and returned to the product backlog. Sometimes User stories are split.
Why does waterfall often lead to software with known problems?
Any significant changes to the specification after it has been "signed off" by the client may trigger a need to backtrack to the specification stage to modify it and get new approval, which risks delaying a project significantly. As a result, most involved try to avoid changes once a project has been specified, even when known flaws are discovered. This leads to poor quality.
Static Analysis of code
Any testing that does not require the application to execute in order to be tested. We learned code linting, which is syntax and style checking.
In what case might you perform remote observation rather than in-person observation?
Anytime it is impractical to do in-person observation. e.g. end-user located far away, system is used in a hazardous or restricted environment
Version Control Motivations:
Archiving Repair Accountability Experimentation Optimization
User Stories
As a _______, I want to _______, so that _______ . INVEST acronym: Independent user stories - stories do not depend on one-another Negotiable - can be canceled or changed at any time Valuable - meaningful stories Estimable - must be descriptive and small enough to be able to easily estimate work for it. Small - story is small enough to be completed in one sprint Testable - story contains enough clarity to be able to easily design a test for it
Demo for Stakeholders
At end of each sprint, viable product should be ready for demo. Stakeholders may suggest new user stories to add.
Feature of any good build system: Automatical ly performs tests, such as unit tests Clearly communicates the sequence of steps necessary to perform the build Documents all dependencies Integration with a version control system Integration with Slack Only rebuilds components that have not changed since the last build Send reports or notification to the developers of the success or failure of the build or tests
Automatically performs tests, such as unit tests Clearly communicates the sequence of steps necessary to perform the build Documents all dependencies Integration with a version control system Only rebuilds components that have not changed since the last build Send reports or notification to the developers of the success or failure of the build or tests
Creator of Bash
Brian Fox
What should be included in Git commit message if changes address a documented issue?
Bug/Issue tracking number
Activity Diagrams
Business logic involved in a particular scenario. Flow chart. Clearly indicate a beginning and end point. Simplify sub-activities. Questions activities that have no inputs or outputs
Why learn about build systems when CI automation servers can run bash script when changes are committed to repo?
CI servers are used to trigger the creation of a new virtual env. in response to an event such as change in the code, or a PR. Venv is where the system is built and tested. Build system tools are specialized for automating builds, and can be triggered by those CI servers. Bash scripts are more general purpose and not specialized for builds.
How test-driven development relate code coverage
Code coverage close to 100%
Integration (end-to-end) testing
Combine multiple units and tests the combinations. User Acceptance Testing (UAT) is also one.
Release Plan
Connects roadmaps to sprints. velocity = how many story points completed in single sprint
Continuous Delivery V.S. Continuous Deployment
Continuous Delivery: Frequently staging changes, ready to be deployed Continuous Deployment: Updated product immediately made available to end-users automatically.
Rationale for automation
Developer's perspective, automation allows developers to receive feedback on their work more quickly Business perspective, continuous integration, continuous delivery, and continuous deployment allow end-users - the users of the system - to get the value of the work more quickly to solve business needs more rapidly and with agility.
Is Git centralized of decentralized version control system
Decentralized. It can optionally be used centralized workflow if desired.
Sprint planning
Deciding which User Stories in Product Backlog to include in new Sprint Backlog Breaking up into Tasks Contractual Agreement - agree and promise to complete in sprint
Developers Role:
Delivering a potentially releasable Increment of "Done"product at the end of each Sprint. Managing their own work - nobody tells them how to do the work defined for each sprint... not even the Scrum Master. Estimating the work of each item in the Product Backlog Renegotiating the work for a Sprint with the Product Owner if they feel it becomes unachievable
What sort of model is based directly on the nouns written in the specification documentation? Conceptual model Domain model Sequence model Use case model Universal model
Domain Model, Conceptual model. Understanding which entities exists in a domain model is to read through the documentation of the system and extract all the nouns. Relationship among these entities are (optionally) discovered by reading the verbs.
Which scripting environments that we've learned about have a built-in ability for minimal recompilation of source code? Bash Make Ant Maven Gradle Grunt
Everything besides Bash
What does GitHub 'fork' do in terms of Git?
Github 'fork' is a git 'clone' of a remote GitHub repository. Github creates a remote clone of the original remote repository in the user's Github account.
Why learn about personality types?
Help us understand how others, such as recruiters, may view us. Provide a way to understand the behavior and preferences of our teammates.
Why a client may prefer waterfall process model over Incremental process
Helps client understand what exactly is being built, how it is being built, how much it will cost, and how long it will take.
Sensing vs. Intuition
How you prefer to gather information is a second personality dimension. Direct observation (Sensing) vs. association of ideas, sixth sense (Intuition) Sensing trusts experience and tangible hard facts Intuition enjoys theories and concepts
If working on a new system from scratch, what can you observe the user doing as part of your requirements elicitation?
If there's no existing system to observe, it is possible to observe end-users - using a prototype of the system you intend to build - using their current alternative
When do teams update the Product Backlog to add, remove, or update User Stories?
In middle of each sprint during Product Backlog Grooming
Why pull before pushing to a Git remote repo in team project?
In typical workflow, multiple developers upload and download code from a central remote repo. Doing a git "pull" before a "push" allows a developer to make sure they have downloaded and are working on the latest version of the code before they submit their own changes. If a second developer has changes some of the code while the first developer was working, the first developer will see those changes after the 'pull', and must merge the changes into their own code submitting the combined changes back to the central remote repository.
Advantage of incremental process model over waterfall
Incremental processes have the advantage of involving the client for their feedback and suggestions throughout the process and changing requirements are welcomed.
Why is ongoing refactoring especially important in incremental processes versus waterfall?
Incremental-oriented developers face the challenge of creating elegant, easy to maintain systems, in an environment where parts of software are being slapped on-top-of-another in a piecemeal fashion. This requires constant refactoring of old code so that new code integrates structurally with the existing codebase in a reliable, maintainable way.
State Chart Diagram
Indicate the behavior of an entity in response to specific events. Useful for modeling real-time systems or system whose behavior heavily depends upon asynchronous events.
User Acceptance Testing is a form of Code linting Integration testing Unit testing System testing
Integration Testing
Unit testing & integration testing difference
Integration Testing - multiple units interacting with one-another. Unit Testing - test a single unit in isolation
Sequence Diagram
Interactions necessary between objects and order those interactions occur. Start the flow of the diagram from the upper-left corner. Place reactive actors on the right-most side of your diagram.
Use cases always include: - interactions that actors have with the system - all interactions each actor will have with the system - the sequence/ordinality of those interactions - the data or messages that are sent between one part of the system and another in the course of an interaction
Interactions that actors have with the system
Grunt designed to automate builds for what language?
JS
Which Myers-Briggs lifestyle trait would be interested in clearing an existing Sprint Backlog item than in uncovering new ideas for a project? - Judging - Perceibing
Judging. Judging focuses on deadlines, task completion, making decisions. Perceiving focuses on adaptability, open to new opportunities.
Originator of unit testing
Kent Beck
Relationship load testing & stress testing
Load: test and app at levels of load that it is designed for. Stress: tests at higher loads than designed for
Advantage of plug-in architecture to build a system
Make plug-ins to help automate builds of a specialized type that's not supported by the build system
Why might Brooks' Law not apply to today's SE teams?
Many modern tools, such as version control, automated testing, and CI, allow new developers to join a team without disrupting or causing a drag on existing team members.
Which build system(s) that we've discussed host an officially-supported repository of plug-ins?
Maven Gradle Grunt
Why might it be unusually difficult for a developer unfamiliar with Maven to understand what tasks a Maven build script performs?
Maven applies a philosophy of "convention over customization" to build scripts. So build scripts may contain minimal code, relying on Maven's conventional defaults to build the system the "usual" way. So a developer will usually not see most of what Maven will do when it builds by simply looking at the build script - they have to dive deep into Maven's documentation to understand what is happening.
Domain Modelling
Model of system, identifying important entities. Connect entities with line and use verb to describe the relationship. Indicate multiplicity with upper and lower bound
What organization hosted a conference in 1968 that officially spurred the creation of SE as a discipline?
NATO Science Committee
Difference between multiplicity and cardinality (StackOverflow answer)
No big difference. Cardinality is used in DB design and data modeling to refer to the number of entities involved in a relationship. Multiplicity is used in UML modeling and domain models to refer to the same concept. Term Multiplicity is more correct since it refers to a range of allowed entities - an upper and lower bound - in a relationship, whereas cardinality refers to an exact number of entities.
Does it ever make sense for a developer to approve their own Pull Request?
No. PR is for enforcing code review. Code review are never done only by the developer who wrote the code.
Are unit tests typically run on the user interface of a web application, such as those written in HTML, CSS, JSX, or XML?
No. UI code such as that written in HTML, CSS, JSX, XML does not usually involve any logic to be tested. If programming code (JS, Java) is included, then it can be tested.
Would a build script written in XML or YAML support programming conditional statements, like if/else if/else into a build script?
No. XML and YAML are for markup, not programming But Groovy or JS supports
Continuous Integration
Offers the advantage of discovering problems rapidly and always maintaining a shippable version of the product. automatically copy the mainline source from the version control system into a build server (usually a new virtual machine or container spun up automatically for this purpose) build the system in the build server, and run automated tests to ensure that the built system passes all tests. If the build fails or the tests fail, the build is broken, and whoever checked in the last change to the baseline source is responsible for repairing the problem. make changes to the system components as necessary repeat steps 2-3 until the system builds properly and passes all tests once the system passes tests on the build server, check it in as a new baseline in the version control system
Product Backlog Grooming
Once per sprint, at the mid-point of the sprint, the whole team comes together to review changes in the Product Backlog. Afterwards, Product owner prioritizes the new User Stories and adds them to the Product Backlog wherever they think they fit in the order New User Stories can only be added to future Sprints, not the current Sprint
What are stakeholders and why are they important to software engineers?
People or organizations who either have a say in the product, or who could cause problems for the product developers if they desired.
Requirements Enginnering
Process understanding what a system needs to do in order to satisfy its stakeholders. Part of system specification.
Product Owner Role
Product Backlog management includes: Clearly expressing Product Backlog items Ordering the items in the Product Backlog to best achieve the business goals and missions Optimizing the value of the work the Development Team performs, by prioritizing the Backlog correctly Ensuring that the Product Backlog is visible, transparent, and clear to all, and shows what the Scrum Team will work on next Ensuring the Development Team understands items in the Product Backlog to the level needed. The Product Owner ultimately is the representative of the client. Their liaison responsibilities include: being the full-time business representative on the team reviewing all work to accept or change it interact with stakeholders to keep project in-line and everyone bought in help prioritize work items to be highest business-value first
Whose job is it to maintain the Task Board?
Product Owner
Product Vision Statement
Product Owner draft at beginning Define MVP
Why should the Product Owner really not be a Software Engineer?
Product Owner should be the representative of the stakeholders. They must write and speak in "regular" language, not technical jargon.
What does Github automatically do with CONTRIBUTING.md
Provides a link to it automatically to users who create a Pull Request
Original impetus for Stuart Feldman to create Make in 1976
Reduce time spent debugging failed builds. Developers used to have to remember to perform all build steps in a particular sequence and install all dependencies first in the correct order.
Bash
Replacement for UNIX's Bourne Shell GNU project.
Git three tree approach
Repository - the 'official' history of a project, including all content of all files in all versions. Only contains changes that have been explicitly committed to the repository. Staging index - a middle-ground staging area between the repository and a user's working copy of the files. Any modified files a user adds here from their working copy are available to be committed to the repository, if the user desires to do so. Working copy - a copy of the files that a user is currently free to make changes to. These are not tracked by the git system until added to the staging index. When a user is done editing files, they typically add them to the index, then commit them to the repository.
Why is it important to write at lease the high-level functional requirements in jargon-less natural language?
Requirements are written so everyone can understand and agree to.
Which column(s) of a Task Board is appropriate to place User Stories?
Spring Backlog. Never leaves that column. Tasks related to it moves around.
At what Scrum event do teams write Acceptance Criteria and Estimates of Work for User Stories?
Sprint Planning
Purpose of Git staging index and how it relates to the Working Copy and Repository
Staging index allows developers to control what parts of the working copy go into the repository on the next "commit" operation
Management responsibilities of the Scrum Master
Scrum Master is a "servant leader". They are not considered managers, but they are enforcers of the rules of Scrum. For example, they remind every how Daily Stand-ups are supposed to be done, how the Product Owner is supposed to write the user stories, etc.
Which UML for communicating the changes to a web-based system triggered by a user of that system moving their pointer, clicking, and typing on various parts of the web UI? Activity diagram Domain model diagram Sequence diagram State chart diagram Use case diagram
State chart diagram
Use case diagram
Stickman directly connected to circles with actions. Does not imply sequence of interactions. Lines indicate the connection between actors and the use cases they interact with. Use descriptive verbs
Creator of Make
Stuart Feldman
How does Scrum relate to Agile?
Scrum is a "framework" for agile software development. It prescribes a specific workflow that ensure an agile methodology.
Which Maslow-ian needs are relevant to software team-building? Self-actualization Esteem Social belonging Safety Physiological needs
Self-actualization, Esteem, Social belonging
UML for working out communication and sequence of message necessary to be passed among objects in an order to achieve a particular goal? Activity diagram Domain model diagram Sequence diagram State chart diagram Use case diagram
Sequence diagram
Team norms
Set of rules and norms agreed upon team formation: Definition of done Sprint cadence Standup schedule What to do when someone failing Rules prioritize Product Backlog
Tools used in class for social belonging.
Slack and Github
What does unit in 'unit testing' refer to? The smallest testable piece of code in a system A function/method An object A class
Smallest testable piece of code in a system. Often an object, class or method
What defines an extrovert compared to an introvert?
Someone who derives more energy from social interaction
Myers-Briggs Type Indicator
Source of energy: Extraversion vs. Introversion Way of gathering information: Sensing vs. iNtuition Decision-making: Thinking vs. Feeling How you relate to the external world: Judgment vs. Perception
Non-functional requirements
Specify constraints on either the system or development process. e.g.: timing, technology used, standards, speed, size, reliability, robustness, portability
Features of a good unit test
TRIP Through Repeatable Independent Professional Fast and automatic controlled - only test code unique to the system, not from external dependencies mocks/isolation setup & teardown legibility - test should tell a story easily understood by others placement - separate unit test from production code
CI limitation
Target deployment environment is significantly different from the development machines and build servers, continuous integration may not be feasible. Automated daily builds are usually performed on a fixed schedule as a way to discover problems with some regularity while not requiring constant use of resources of the target environment.
Team Retrospective
Team performance meeting. Only Scrum master and developers. What worked well? What did not work well? What can be improved?
Why should unit tests follow the same standards of good code design for your test code?
Test code can essentially define the API of an application. Since there are typically 4 or more unit tests for every method of application code, good style helps with maintenance
Unit testing frameworks benefits
integration, reusable, automated, fast, lower maintenance cost
Test-Driven Development Criticisms
Test-driven development is often seen as a bit too extreme (in fact, TDD originated from what is called the eXtreme Programming methodology). In most cases, requirements of systems are not fully known until development starts, and it is not unusually for new requirements to surface late in the development cycle. Many developers consider it helpful to have an ongoing feedback loop between specifying, developing and testing.
Regression testing
Testing old unit tests that have previously passed before new addition or changes were made to the project.
What perceived problem was NATO Science Committee organized to address?
The "Software Crisis"
Scrum key features:
The Product Owner creates and maintains a "Product Backlog" - this is an ordered list of the requirements of the system to be built. It is a living document that is always shifting. Work on the project is broken up into Sprints, each Sprint being 1-4 weeks long Before every Sprint, the team reviews the Product Backlog and decides which requirements they should try to build in the new Sprint such that they can reduce the Product Backlog and also deliver a functioning though incomplete product by the end of the Sprint. The Developers develop and test their work within the Sprint's timeframe until it's ready and done The team presents their work to the Product Owner and other Stakeholders At the end of each sprint, the team reviews what they've done and reflects on what they've done and what they can do better next cycle
Who drafts the User Stories and Acceptance Criteria and Estimates?
The Product Owner draft user stories. PO and developers collaboratively draft acceptance criteria. Developers draft the estimation of work.
Sprint Backlog
The Product Owner is responsible for making sure the stories in the Product Backlog with the highest business priority are included in each Sprint Developers are responsible for negotiating with the Product Owner to make sure the items in the Sprint Backlog can actually be achieved in the given time. Developers are responsible for maintaining the Sprint Backlog for the entirety of the Sprint, keeping it an accurate reflection of the work of the Sprint at every point in time The Scrum Master is responsible for making sure the Sprint Planning process is adhered to
Backlog creation
The Product Owner, by speaking with Stakeholders and through their own understanding of the product creation process, creates the Product Backlog, with the help of the entire team.
What is the appropriate amount of work to include in each Task?
The amount of work 1 developer can do in about 1 or 2 days
Agile is different from other lean or iterative methodologies because:
There is a functioning product at every step that is added to in small increments Business partners are encouraged to be involved throughout the whole project, not just beginning and end as in traditional methodologies Agile measure success with completed software, not with milestones Documentation is lightweight and only as much as needed to make the point Agile allows teams to self-organize, so managers and clients can help determine what a system should do, but not how the team operates when building it
What is the ideal ratio of test code to production code?
There is no ratio that is ideal for all projects
key differences among build systems
language build scripts are written Specific to one platform or platform-agnostic Emphasize convention or custom config Allow 3rd-party plugin architecture * all build systems allow developer to specify build targets and perform minimal recompilation
Use Cases
long document, multiple goals and details Include: title (the goal), actor, scenario, preconditions, extensions
Use Case Sample
Title: Purchase items Actor: Customer Scenario: Customer reviews items in shopping cart. Customer provides payment and shipping information. System validates payment information and responds with a confirmation of order and provides order number that Customer can use to check on order status. System will send Customer a confirmation of order details and tracking number in an email.
Why planning Poker cards often come with numbers from Fibonacci sequence on them?
To reflect the inherent uncertainty in estimating larger items
Three pillars of a good unit test according to Roy
Trustworthiness Maintainability Readability
Why is 'mocking' important for integrity of unit tests?
Unit Testing is ideally done in isolation, so other systems or code outside of the are of focus are not interfering in the test
Why do both use cases and user stories exist in software engineering practice and when should you use each?
Use cases and user stories are two different methods of documenting the same thing - user requirements. Which you choose depends on which development methodology. Agile methodology often prescribe user stories as the way to document User Requirements. Waterfall, Object-Oriented Systems Analysis and Design (OOSAD) and some other prescribe use cases to do the same thing.
What happens to User Stories from the Sprint Backlog that are not completed by the end of Sprint?
User Stories not implemented in a Sprint are returned to the Product Backlog
Which of the following are considered "user requirements"? - Efficiency requirements - User stories - Use cases - Non-functional requirements - Reliability metrics - Security requirements - System requirements
User Stories, Use cases
Agile Manifesto states:
We are uncovering better ways of developing software by doing it and helping others do it. Through this work we have come to value: * Individuals and interactions over processes and tools * Working software over comprehensive documentation * Customer collaboration over contract negotiation * Responding to change over following a plan That is, while there is value in the items on the right, we value the items on the left more.
Functional requirements
What the system should do in natural language. Service the system should provide How the system should behave in particular circumstance What outputs the system should provide in response to particular inputs
Introversion vs. Extroversion
Which environments give a person energy, and which detract from that energy. Extraverted minds look outside for motivation to act, change, or interact. Introverted minds look for internal thoughts and ideas.
Github Issues
an Issue is either a bug, a new feature, or a project requirement
Test-Driven Development Benefits
code coverage - every bit of code has a test developed for it before the code to be tested has even been written debugging - since tests are run with every code change, it is easy to identify the new code that created a bug documentation - the tests themselves become a specification of the system
System Building
creating complete, executable system by compiling and linking the system components, external libraries, configuration files, and other information. Anything that is necessary for the software to be executable in its intended form is considered building.
Acceptance Criteria
e.g. Customer phone number is captured and saved Customer password is captured and saved Invalid name, email, phone, and passwords are rejected
Thinking vs. Feeling
how you decide on the meaning and importance of information. Analytic, cause-and-effect (Thinking) vs. value-oriented, idealistic (Feeling) Thinking prefers logical arguments, questioning the veracity of the information Feeling prefers values, examining impacts on individuals
Scrum Master Role:
remind and reinforce the rules and practices of the Scrum framework to both the Developers and the Product Owner helping the Product Owner understand the correct way to enter user stories to the Backlog to make them most valuable helping the Development team understand how to create Acceptance Criteria and estimate work and meet sprint goals removing impediments from the Development team's work keep team working at a sustainable pace without burnout or disillusionment collect trends on team's productivity to help them reflect and improve next time be a facilitator of Scrum events - guide team through the correct processes for all events:: Sprint Planning Daily Scrum Sprint Review Sprint Retrospective
Daily Scrum
same time every day - non-negotiable stand in front of the task board and adjust it as necessary no more than 15 minutes long what did you do yesterday? what are you going to do today? is there anything blocking your progress? i f a blocking problem can't be solved after 1 day, the scrum master steps in and tries to remove the block. If they can't do that after 1 day, the product owner tries.
Four phases of a unit test
setup - prepare environment for the test, set up test cases, their inputs and expected outputs, import any necessary modules, replace dependencies with dummy data, etc. execution - the object or method to be tested is called, and the results of the call are captured validation - compare the results of execution with the assertions in the test case to determine success or failure. If the assertion evaluates to true, the test passed, otherwise, it failed. cleanup - remove any traces or artifacts of the test so the next test can start from a clean slate
User Stories
short (1 index card), one goal, no detail, informal, placeholder for conversation
Two pizza team
the two pizza philosophy says that team size should never go beyond what 2 pizzas can feed. by Jeff Bezos