week 7 Flashcards
(57 cards)
1
Q
Node.js
A
- open-source, cross-platform run-time environment built on Chrome’s V8 JavaScript engine.
- is used to execute JavaScript code outside of a web browser
- provides a library of various JavaScript modules, which simplifies the development of web applications.
2
Q
npm (node package manager)
A
- default package manager for the JavaScript runtime environment -Node.js
- 3 components:
- —- website: discovers packages, set up profiles, and manage access to public or private packages
- —- command line interface (CLI): runs from a terminal and allow us to interact with npm
- —- registry: a public database of JavaScript packages comprised of software and metadata
3
Q
use of Node.js for Angular
A
- use Node.js and npm as tools for building Angular or React apps
- Angular is a front-end framework used to create a web application and is written in Typescript
- browser only understands JavaScript code, so need to compile Typescript (.ts file) to plain JavaScript (.js file)
4
Q
package.json file
A
- located in project root of all npm packages
- is used to give information to npm that allows it to identify the project as well as handle the project’s dependencies
- contains metadata relevant to the project
- run “npm init” command in terminal to generate package.json file
- dependencies section is essential for running applications
- devDependencies section is used only for developing applications
5
Q
TypeScript
A
- typed superset of JavaScript
- open-source and object-oriented programming language, developed by Microsoft
- manipulate the DOM for adding or removing elements
- portable across browsers, devices, and operating systems
- supports strong typing or static typing
- files are saved with a “.ts” extension and then compiled into JavaScript using the TypeScript compiler
- gets compiled to JavaScript, which can run on any JavaScript runtime environment.(Eg: Node.js)
6
Q
Single Page Application
A
- web application that fits on a single page in the browser
- all JavaScript, HTML, CSS code retrieved by the browser with a single page load
- navigation between pages performed without refreshing the whole page
- uses AJAX and HTML5 to build responsive web applications
- ex. Gmail, Google Maps, Facebook, Twitter, Trello
7
Q
Advantages and Disadvantages of SPAs
A
Advantages:
- fast and responsive
- caching capabilities: caches all received data locally
- pleasant user experience
Disadvantages:
- doesn’t perform well with SEO (search engine optimization)
- less secure towards XSS (cross site scripting) attacks
- first page loads slower
8
Q
Variable declaration in TypeScript
A
let [identifier] : [type] = value;
9
Q
Datatypes in TypeScript
A
- boolean
- number: store decimal, hexademial, binary and octal literals in a variable
- string: includes template strings which have embedded expressions
- undefined and null
- any: used for ones we do not know when writing application
- void: not useful, can only assign null or undefined to values
- arrays: use the type of the elements followed by [] or use a generic array typeArray for declaring the array type
- tuples: array with a fixed number of elements whose types are known
- enum: declare a set of named constants. a collection of related values that can be numeric or string values
- never: a type of values that never occur. return type for a function that always throws an exception or one that never returns.
10
Q
Classes, Access Modifiers, Modules, Accessors and Mutators in TypeScript
A
Classes:
- “class” keyword: declare a class
- “new” keyword: create an instance of the class
- “extends” keyword: implement an inheritance hierarchy
Access Modifiers:
- public: default
- private: member cannot be visible outside of the class
- protected: member can be accessed only by its containing class and deriving classes
- “readonly” keyword: make properties accessible but immutable
Modules:
- to restrict scopes and also to organize and maintain a large codebase
- all variables, classes, and functions declared in a module are not accessible outside the module
- “export” keyword: create a module
- “import” keyword: use module in another module. syntax is “import { export name } from “file path without extension”;”
Accessors and Mutators:
- “get” and “set” keywords: create getter and setter methods
11
Q
Decorator
A
- special kind of declaration attached to a class declaration, method, accessor, property, or parameter
- defined in the @expression format, where expression evaluates a function that called at runtime
- in tsconfig.json file, set the experimentalDecorators compiler option property to true, in order to use decorators in code.
12
Q
Types of Decorators
A
Class decorators:
- declared before a class declaration
- applied to the constructor of the class
- used to observe, modify, or replace a class definition
Method decorators:
- declared before a method declaration
- applied to the Property Descriptor for the method
- used to observe, modify, or replace a method definition
Property decorators:
- used to listen to state changes on a class
Parameter decorators:
- declared before a parameter declaration
- applied to the function for a class constructor or method declaration
Accessor Decorators:
- applied to the property descriptor for the accessor
13
Q
Interfaces
A
- allow us to create contracts that other classes/ objects can implement
- defined using the interface keyword that includes properties and methods
- optional properties are marked with a “?” that do not have to be implemented
- TypeScript compiler does not convert the interface to JavaScript. Instead they are only used for type checking
- can also contain functions without the function body which is used to ensure the function signature
14
Q
Webpack
A
- powerful static module bundler for JavaScript applications that packages all modules in our application into a bundle and serves it to the browser
- builds a dependency graph when it processes the application. It starts from a list of modules defined in its config file (webpack.config.js) and recursively builds a dependency graph that includes every module our application needs, then packages all of those modules into a small bundle that can be loaded by the browser
- solution to having many javascript files in HTML pages: bundling several files together into one file to be downloaded by the browser in one single request
- module bundlers: used to bundle a group of JavaScript modules with their dependencies and merge them into a single file in the correct order, which can be executed by the browser
15
Q
Angular CLI
A
- command-line interface for Angular, helps with getting started to create an Angular app
- creates an Angular application and uses the Typescript programming language, Webpack for Module bundling, Karma for unit testing, and Protractor for end-to-end testing
- takes care of the configuration and initialization of various libraries
- allows to add components, directives, services, etc, to already existing Angular applications
16
Q
Angular file structure
A
- e2e folder: source files for a set of end-to-end tests and test-specific configuration files
- node_modules folder: provides npm packages to the entire workspace
- src folder: contains the source files which give information about application logic, data, and assets
- app: contains component files
- —- app.component.ts - used to define the logic for the app’s root component (AppComponent).
- —- app.component.html - used to define the HTML template associated with the root AppComponent.
- —- app.component.css - used to define the base CSS stylesheet for the root AppComponent.
- —- app.component.spec.ts - used to define the unit test for the root AppComponent.
- —- app.module.ts - used to define the root module (AppModule) and helps the Angular to assemble the application. All components, including the AppComponent, must be declared inside the AppModule.
- assets - contains image and other asset files.
- environments - contains build configuration options for particular target environments.
- favicon.ico - an icon to used for an application in the bookmark bar
- index.html - the main HTML page that is served when someone visits your site
- main.ts - main entry point for an application
- polyfills.ts - provides polyfill scripts for browser support.
- styles.css - lists CSS files that applies the styles for a project.
- test.ts - main entry point for unit tests used in the application.
- .editorconfig - this file contains configuration for code editors.
- .gitignore - it specifies untracked files that Git should ignore.
- angular.json - holds CLI configuration defaults for all projects in the workspace. It includes configuration options for the build, serve, and test tools.
- browserslist - used to configure the sharing of target browsers and Node.js versions among various front-end tools.
- karma.conf.js - it contains application-specific Karma configuration.
- package-lock.json - this provides version information for all packages installed into node_modules by the npm client.
- package.json - used to configure npm package dependencies that are available to all projects in the workspace.
- README.md - an introductory documentation for the root app.
- tsconfig.app.json - it holds application-specific TypeScript configuration, including TypeScript and Angular template compiler options.
17
Q
AngularJS vs Angular 4+
A
AngularJS:
- uses JavaScript
- uses scopes and controllers (MVC architecture) for control logic
- have to remember the right ng directive in order to bind an image/property or an event
- doesn’t support mobiles
- about to finish its support lifecycle
Angular 4+:
- uses TypeScript (powerful type checking and object-oriented features)
- uses components as its main architectural design
- has more emphasis on modularity
- focuses on “( )” for event binding and “[ ]” for property binding
- supports mobiles
- more modern and has upgrades
18
Q
Component Life Cycle Hooks
A
constructor():
- executed first
- inject any dependencies into the component
ngOnChanges():
- called whenever the input properties of the component change
- returns a SimpleChanges object which holds any current and previous property values
ngOnInit():
- called once to initialize the component and set the input properties
- initializes the component after Angular first displays the data-bound properties
ngDoCheck():
- called during all change-detection runs that Angular can’t detect on its own
- also called immediately after the ngOnChanges() method
ngAfterContentInit():
- invoked once after Angular performs any content projection into the component’s view
ngAfterContentChecked():
- invoked after each time Angular checks for content projected into the component.
- called after ngAfterContentInit() and every subsequent ngDoCheck()
ngAfterViewInit():
- invoked after Angular initializes the component’s views and its child views
ngAfterViewChecked():
- invoked after each time Angular checks for the content projected into the component
- called after ngAfterViewInit() and every subsequent ngAfterContentChecked()
ngOnDestroy():
- invoked before Angular destroys the directive or component
19
Q
Angular Components
A
- the basic building blocks in the Angular application
- contain the data & UI logic that defines the view and behavior of the web application
- defined using a @Component decorator
- includes a selector, template, style, and other properties, and it specifies the metadata required to process the component.
- Angular app has one root component (AppComponent) which is specified in the bootstrap array under the main ngModule module defined in the app.module.ts file
20
Q
@Component decorator
A
- app.component.css - holds all the CSS styles
- app.component.html - this is template contains typical HTML elements and alters the HTML based on our app’s logic and DOM manipulations
- app.component.ts - contains typescript code to control the component behavior
- selector: a CSS selector that tells Angular to create and insert an instance of this component wherever it finds the corresponding tag in template HTML
- templateUrl: the module-relative address of this component’s HTML template
- styleUrls: an array of relative paths to where the component can find the styles used to style the HTML view
- create component in Angular: run “ng generate component “ or “ng g c “ in terminal
21
Q
Angular Directives
A
- allow us to manipulate the DOM
- a marker on a DOM element that tells Angular to change the appearance, behavior, and layout of the DOM element and its children
- most directives begin with ng, where ng stands for Angular, and extend the HTML.
Types of directives:
- Component Directives - alter the details of how the component should be processed, instantiated, and used at runtime.
- Structural Directives - used to manipulate and change the structure of the DOM elements.
- Attribute Directives - used to change the look and behavior of the DOM elements.
22
Q
Structural Directives
A
- used for adding, removing, or manipulating DOM elements
- start with an asterisk (*) followed by a directive name
- can work with the HTML5 element, which is designed to hold template code.
3 built-in directives:
- *ngIf: allows to add or remove DOM Elements based upon the Boolean expression
- *ngFor: used to repeat a part of the HTML template once per each item from an iterable list
- ngSwitch:
- —- attribute directive that controls the behavior of the other two switch structural directives - NgSwitchCase and NgSwitchDefault. write NgSwitch as [ngSwitch], NgSwitchCase as *ngSwitchCase, and NgSwitchDefault as *ngSwitchDefault
- —- NgSwitchCase displays its element when its value matches the switch value. NgSwitchDefault displays its element when no sibling NgSwitchCase matches the switch value
23
Q
Attribute Directories
A
- used to change the look and behavior of the DOM elements
[ngClass]:
- used for adding or removing the CSS classes on an HTML element. allows to apply CSS classes dynamically based on expression evaluation
- syntax is “ ….”. value can be string, array, object
[ngStyle]:
- allows to dynamically change the style of HTML element based on the expression
- syntax is “…”
custom directives:
- use CLI command “ng generate directive “
24
Q
@NgModule decorator
A
NgModule takes metadata and describes how to compile a component’s template and how to create an injector at runtime. It identifies the module’s own components, directives, and pipes and makes them public through the export property which can be used by external components.
takes metadata to launch the app:
- declarations: contains a list of components, directives, and pipes, which belong to this module.
- imports: contains a list of modules, which are used by the component templates in this module reference. For example, we import BrowserModule to have browser-specific services such as DOM rendering, sanitization, and location.
- providers: the list of service providers that the application needs.
- bootstrap: contains the root component of the application
25
Bootstrapping in Angular
- The main.ts is an entry point of an angular application.
- Then, we bootstrap an angular application and we pass app.module.ts as an argument. In app.module.ts, we tell the Angular to bootstrap the AppComponent.
- Then, Angular analyzes this AppComponent and knows there is an app-root selector defined.
- Now, Angular able to handle app-root in the index.html file.
- Finally, the index.html file is loaded on the browser.
26
Pipes
- provide a way to transform values in an Angular template
- used with a Pipe (|) character, and take integers, strings, arrays, and date as input and returns a desired formatted output which can be displayed in the browser.
- accept the any number of optional parameters to fine-tune output. add parameters to a pipe by follow pipe name with a colon ( : ) and then parameter value
- can chain pipe together in effective combinations
built in pipes:
- Date pipe: used for formatting dates.
- Decimal pipe: used for formatting numbers
- Currency pipe: used for formatting currencies
- Percent pipe: used for formatting percentage values
- Slice pipe: used for Slicing strings
- Lowercase pipe: used for converting strings into lowercase
- Uppercase pipe: used for converting strings into uppercase
- Titlecase pipe: used for converting strings into title case
- Json pipe: used for Converting values into a JSON-format representation
- Async Pipe: used for unwrapping values from an asynchronous primitive
27
Custom pipes
- syntax to create custom pipes: "ng g pipe "
- import the @Pipe decorator from the core Angular library. If the Class is decorated with the @Pipe decorator, Angular knows that class is a pipe
- in the @Pipe decorator, define the pipe name that used within template expressions
- pipe class implements the PipeTransform interface to perform a transformation
- transform method accepts an input value followed by optional parameters and returns the transformed value
28
1-way data binding
- allows to manipulate the views through the models
- any changes made to the class gets reflected in the template, but not in the component class
- achieved through:
- ---- string interpolation: bind the data from a typescript class to the template by using the expression in double curly braces
- ---- property binding: bind values to the attributes of HTML elements
- ---- event binding: bind DOM events such as keystrokes, button clicks, mouse overs, touches, etc to a function in the component
29
2-way data binding
- achieved by combining property binding and event binding together
- useful in data entry forms
- need to import the FormsModule package into Angular module to use the ngModel directive
30
Services
- used to organize and share business logic, models, data, or functions with different components of an Angular application
- Angular service is a singleton instance that can be injected into multiple components, where the component utilizes the functions defined in a service class. This allows us to reuse the code.
- define the service class in file with *.service.ts extension. use a Dependency Injection framework to inject the service into components in our application
31
Dependency Injection
- allows the class to receive its dependencies from external sources rather than creating them itself
Dependency Injection as a Framework:
- DI framework uses an Injector where we register all those dependencies to be managed
- injector is responsible for creating service instances and injecting them into components
32
using a Service
Injector holds all the services, and registers them at the NgModule or component level based on their provider. A provider tells where in our application to register the service. The registered service can be accessed using a DI token. A DI token is a lookup key for the registered services.
The @Injectable() decorator marks a class as a service class that can be injected. The @Injectable() decorator has a providedIn property where we specify the provider of the decorated service class with the 'root' as a default, or any other module of our application.
33
HttpClient
- offers testability features, typed request and response objects, request and response interception, Observable APIs, and streamlined error handling
- used for communication between front-end web apps and backend services. communication is done over the HTTP protocol
- In "src/app/app.module.ts" file, import the HttpClient module to make use of the HttpClient service. and include the HttpClientModule in @NgModule's imports array
- HttpClient methods return an Observable of something. observable from HttpClient always emits a single value and then completes, never to emit again.
34
handling errors with HttpClient
- using Angular's HttpClient along with catchError from RxJS to write function to handle errors within each service
2 errors to handle differently:
- Client-side: Network problems and front-end code errors. With HttpClient, these errors return ErrorEvent instances.
- Server-side: AJAX errors, user errors, back-end code errors, database errors, file system errors. With HttpClient, these errors return HTTP Error Responses.
to catch errors: "pipe" the observable result from http.get() (or any HttpClient methods) through an RxJS catchError() operator. Also, add the retry(1) function to the pipe to retry all requests once before failing.
35
Routing
- Router mechanism in Angular provides a way to navigate from one view to another view in the application
- RouterModule has the necessary service providers and directives for navigating through application views
- router: defines navigation of views on a single page and interprets URL links to determine which views to create or destroy, and which components to load or unload
- routing component: imports the Router module, and its template contains a RouterOutlet element where it can display views produced by the router
36
Routing guards
are used to check whether the user should grant or remove access to certain parts of the navigation
4 different interfaces:
- CanActivate - decides if the route can be activated.
- CanActivateChild- decides if children of a route can be activated.
- CanLoad- decides if a route can be loaded.
- CanDeactivate- decides if the user can leave a route.
37
RxJS Observables
- Reactive Extensions for JavaScript(RxJS) is a framework for reactive programming using observables that makes it easier to write asynchronous code
- provide support for passing messages between parts of your application
- use observables for event handling, asynchronous programming, and handling multiple values
- define a function for publishing values, but it is not executed until a consumer subscribes to it. The subscribed consumer then receives notifications until the function completes, or until they unsubscribe
- can deliver multiple values of any type (literals, messages, or events)
3 callback methods:
next() - invoked whenever the value arrives in the stream. passes the value as the argument to the next callback.
error() - invoked if error occurs
complete() - invoked when stream completes
38
RxJS Subjects
- a special type of Observable that allows values to be multicasted to many Observers
- default on an RxJS Observable is unicast
- every Subject is an Observer. It is an object with the methods next(v), error(e), and complete()
- call next(theValue) to feed new value to Subject
39
Subject Variants
Behavior subject:
- used to temporarily store the current data value of any observer declared before it
Replay subject:
- provides an option to choose how many values we want to emit from the last observer
- stores and then passes the last specified option values to the new observer
Async subject:
- emits the last value to observers when the sequence is completed
40
Promises vs Observables
- both can be used for handling asynchronous data
| - a Promise emits a single value while Observable can emit multiple values
41
Publisher/Subscriber Design Pattern
- describes the flow of messages between applications, devices, or services
- a message is published by Publishers to a Channel, that will be consumed by all Subscribers monitoring that channel
- usually implemented in an asynchronous way. publishers and subscribers don’t need to know each other
42
Event Emitters in Angular
- is used to emit custom events synchronously or asynchronously, and register handlers for those events by subscribing to an instance
- @Input decorator: defined in the @angular/core package that marks a class field as an input property and supplies configuration metadata
- @output decorator: marks a class field as an output property and supplies configuration metadata
- @output decorator with EventEmitter API: emit the event or data from a component
43
Testing in Angular with Jasmine and Karma
Jasmine:
- a behavior-driven development framework for testing JavaScript code
- does not depend on any other JavaScript frameworks
- does not require a DOM
- clean, obvious syntax
Karma:
- uses a configuration file in order to set the startup file, the reporters, the testing framework, the browser among other things
44
Software Development Life Cycle (SDLC)
- series of steps that we go through when creating new products
- encompasses methodologies (broader categories of development concepts and practices) and frameworks (a more detailed implementation of a methodology's ideas)
steps:
1. gathering requirements
2. analyzing those requirements
3. designing a solution
4. developing the solution
5. testing the solution
6. user acceptance testing (UAT)
7. releasing the solution
8. finally maintaining the product
phases:
- the design phase (gathering/analyzing requirements and designing the solution)
- the development phase (developing, testing, and UAT)
- the deliver phase (release and maintenance)
45
Waterfall methodology
- very rigid methodology that follows a strict series of steps
- follow each of the eight SDLC steps in order, never revisiting a previous stage
- methodology only flows in one direction
drawbacks:
- changes to previous stages are impossible
- no tests until all development has been completed
benefits:
- no room for confusion in Waterfall because there is a clear barrier between each step. allows for a clean transfer of knowledge between steps
- have an understanding of what the finished product will look like and do as soon as the design phase has been completed because all requirements are gathered before design or development begins
- does not require any specific procedural knowledge, simply move from one step/phase to the next
- great for situations with strict deadline for the final release of the product and strict budgetary constraints (ie. government projects)
46
Agile terminologies
- User Story: An individual feature of/requirement for a project in Agile development.
- Epic: A group of related features that is broken down into multiple user stories.
- Story Point: A level of difficulty assigned to a user story through the use of a sequence of numbers that increases with increasing difficulty.
- Sprint: A brief period of development (almost always less than four weeks, sometimes as short as one week) generally culminating in a release of related features.
- Velocity: The sum of story points of all user stories completed during a sprint. Velocity allows Agile teams to more accurately predict how many user stories can be completed in future sprints.
47
Agile methodology
- fluid, ability to adjust to changing requirements and requests from the client
- used to adapt to changing requirements from the client and unforeseen circumstances that are not simply the result of poor, or nonexistent, planning
drawbacks:
- developers may be tempted to avoid fully designing their solutions prior to implementation
- allowing for change can also encourage unpredictability
- more complicated methodology
benefits:
- flexibility extends to release times, any features that cannot be included in the upcoming release can simply be made as part of the following deployment
- multiple releases allow for faster movement through the testing phase. testing small set of features instead of entire project.
- allows for initial ambiguity
48
Scrum framework (Agile)
- simplest of the Agile frameworks
- enforces certain ceremonies, led by a Scrum Master who ensures that the team is following Scrum practices
- development is broken into two to four week sprints
lifecycle:
- project backlog
- sprint backlog
- sprint (2-4 weeks): include daily standup (15 minutes)
- release
- retrospective
advantages:
- ability to quickly identify any setbacks that developers on the team are experiencing and then quickly solve those problems with the help of others
- relatively short sprints allow for constant releases, more involvement for client
disadvantages:
- fluidity brings uncertainty
- difficult to estimate costs or a final release date
- fluidity results in feature creep, a continuous expansion of proposed functionalities
- require engagement from all team members in order to properly function
49
Kanban
- Kanban board: vehicle for a visual representation of the progress of a project
- no firm requirement for the number of columns on the board, but there should generally be at least one column per SDLC phase
- Kanban cards, visual representations of a single user story or work item, are placed in the columns
- team members who have completed their current task can simply refer to the board and choose a new card from the backlog to work on
- should never be more tasks in progress than there are developers on the team.
advantages:
- event-driven, removing even the small pressure of sprint deadlines found in the Scrum framework
- developers building stronger expertise in a particular area due to specialization
- can always take new client requirements and is persistent throughout releases
- allows the entire team to view the current state and progress of the project
disadvantages:
- board's size will grow to the point where it becomes unnecessarily complex and difficult to understand/navigate
- requires commitment from its devotees. board needs to be kept up to date.
- has no timing element, which can result in an even more extreme version of feature creep and constant release delays/uncertainty
50
Scrumban
- a combination of Scrum and Kanban
- pairs the visual representation of Kanban with the ceremonies and sprints of Scrum
- mitigates Kanban's timing issues with the help of Scrum's sprints
- gives Scrum practitioners the specialization capabilities found in Kanban
51
eXtreme Programming (XP)
- most verbose of the Agile frameworks
- strict procedures designed to encourage XP's values of communication, simplicity, feedback, courage, and respect
- seeks to go beyond improving product quality by also improving team cohesion and the lives and happiness of individual members
- procedures include weekly cycles (one-week sprints), quarterly cycles (i.e. quarterly releases), continuous integration (ensuring that code from new sprints can easily be assimilated into the existing code base), incremental design (initial high-level design of features and functionalities, leaving the specifics for later), the use of user stories and epics, test-driven development (TDD), pair programming, and other practices...
- team includes a member of the customer in order to fulfill the goal of faster feedback
advantages:
- close relationship with the customer
- minimizes or even erases the danger of sunk costs
- focus on communication and pair programming can increase the group's cohesion, openness, awareness of the entire project, and commitment to each other
- brief development periods and focus on continuous integration result in the quick delivery of working solutions
downsides:
- lots of procedures to follow
- involvement of the client on the development team can be a hindrance
- weekly iterations can cause developers to sacrifice general best practices in order to make deadlines
- frequent changes means documentation can quickly become outdated
- no time within a sprint to refine solutions to maximize code efficiency and good design principles
- this framework is stressful to use
52
Agile planning
Teams form client requirements into epics and then break those epics into individual user stories. After that process is complete, each user story is assigned story points. Lastly, each story is given a time estimate.
53
Waterfall model
- Requirements definition
- ---- The system's components, goals, functionalities, services, and constraints will be determined and written in detail in the documentation. This documentation will be known as the system specification.
- System and software design
- ---- Determine the overall system architecture
- Implementation and unit testing
- ---- This stage involves breaking down the software design into components and verifying whether the components address requirement specifications
- Integration and system testing
- ---- Every component is combined to form a single system and is tested to see if they components mesh well with each other.
- Operation and maintenance
- ---- The system is shipped out and maintenance (improving the system and fixing any bugs that were not discovered earlier.
54
Agile manifesto
- Customer involvement
- ---- Stakeholders should give their input in all stages of the development process to show what components should be prioritized and give input that can be analyzed to evaluate the progress of every iteration.
- Embrace change
- ---- Change is inevitable therefore the system should be designed in such a way to relieve the potential stress caused by change.
- Incremental delivery
- ---- Software should be incrementally developed in small batches to test components and allow for feedback.
- Maintain simplicity
- ---- Systems should be simple where applicable.
- People, not process
- ---- People's skills should be recognized and used.
55
Scrum phases
- Initial Phase: begin by outlining objectives for the project and a rough design of the software architecture.
- Sprint Cycles: are the incremental portion of development; each cycle will develop an increment of the project.
- Closure phase: involves wrapping up the project and completing any documentation that is required
56
Story Points
- measurement units for expressing how much effort will have to go into fully implementing/the completion of a requirement or product backlog item
benefits:
- makes teams more prepared and ready for the upcoming workload
- helps understanding of each feature and its Implementation
- reward team members based on difficulty instead of time spent
- process repeated over and over for different projects will lead to a better understanding of the capabilities of the team and time required
57
Scrum Ceremonies
- meetings used during the life cycle of the sprint in a project
- all of the involved groups use them to give progress updates, promote general understanding between teams, create and track user stories, as well as gather data for sprint metrics
- are as time-sensitive as the sprints and are meant to only take as much time as is necessary
types:
- Sprint Planning: scope of the sprint, sprint goals, metrics and other specifics of the sprint(such as user stories and team composition) are decided and agreed upon
- Daily Scrum/ Daily Stand-Up
- Sprint Review: abt the product
- Sprint Retrospective: abt the process
