COURSE CONTENT
COURSE NAME
.Net Core (Jump)
COURSE OUTLINE
SDLC & Agile
The SDLC: The Life Cycles
Business Analysis Life Cycle
Project Management Life Cycle
Systems Development Life Cycle
Overview of SDLC
What is SDLC means?
History
Overview
Typical Delivery Model
Waterfall vs. Agile
CMMI vs. Agile
PMBOK vs. Agile vs. IID models
Overview of Project Management
Project Definition
Generic Project Life Cycle
Project Management Life Cycle
Project Management Methodologies Compatible with the SDLC
The Development Spectrum
Waterfall
Agile
IID Models
Industry Delivery Models
Spiral model, V Model, RUP, DSDM Models
Design Documents
Test Case Management
Overview of Business Analysis
IIBA
BABOK Overview & Its Practices
Requirements
Project vs. Product Requirements
Levels of Requirements
Business
Stakeholder
Solution
Agile Overview from Industry Practices
Why Agile
The Triple Constraints in Agile
Agile Approach to Planning
Agile Manifesto 4 values vs. 12 sub principles
Various Agile Methodologies – IID Model
Scrum Process
XP 12 Practices
Agile Planning
Introduction to Agile Project Management
Articulating Agile values and principles
Comparing Agile with traditional, masterplan methods
Appreciating Agile development as value-driven delivery
Fundamentals of the Scrum Framework
Dealing with uncertainty and risk
Recognizing Scrum as a framework for self-managing teams
Locating Scrum in empirical process control theory
Revealing systematically the issues in product development
Identifying the roles and their responsibilities
Ordering requirements and insuring Return on Investment through the Product
Owner
Establishing the Scrum Master as a fundamentally new management role
Shaping the self-managed Development Team
Engineering Practices Overview
Test First Approach
DSL, Behaviour Driven Development
Continuous Integration
Value Based Prioritization, MMF, MVP
Metrics, Velocity & Cycle Time
Test Driven Development – TDD
Acceptance Test Driven Development – ATDD
JIRA, JENKIN, GIT, BITBUCKET Overview
Scaling scrum, SAFe Model Overview
Introducing the Scaled Agile Framework (SAFe)
Embracing a Lean-Agile Mindset
Understanding SAFe Principles
Creating high-performing teams and programs
Experiencing Program Increment (PI) Planning
Exploring, Executing, and Releasing Value
Leading the Lean-Agile Enterprise
Empowering a Lean Portfolio
Building Large Solutions
GIT: Version Control
Introduction
Version control systems
Local, Centralized and distributed
Installing Git
Installing on Linux
Installing on Windows
Initial setup
Git essentials
Creating a repository
Cloning, checking-in and committing
Fetch, pull and remote
Branching
Programming in C#
Review of Visual C# Syntax
Overview of Writing Application by Using Visual C#
Data Types, Operators, and Expressions
Visual C# Programming Language Constructs
Lab: Implementing Edit Functionality for the Students List
Implementing Insert Functionality for the Students List
Implementing Delete Functionality for the Students List
Displaying a Student’s Age
Creating Methods, Handling Exceptions, and Monitoring Applications
Creating and Invoking Methods
Creating Overloaded Methods and Using Optional and Output Parameters
Handling Exceptions
Monitoring Applications
Lab: Extending the Class Enrolment Application Functionality
Refactoring the Enrolment Code
Validating Student Information
Saving Changes to the Class List
Basic types and constructs of Visual C#
Implementing Structs and Enums
Organizing Data into Collections
Handling Events
Lab: Writing the Code for the Grades Prototype Application
Adding Navigation Logic to the Grades Prototype Application
Creating Data Types to Store User and Grade Information
Displaying User and Grade Information
Creating Classes and Implementing Type-Safe Collections
Creating Classes
Defining and Implementing Interfaces
Implementing Type-Safe Collections
Lab: Adding Data Validation and Type-Safety to the Application
Implementing the Teacher, Student, and Grade Structs as Classes
Adding Data Validation to the Grade Class
Displaying Students in Name Order
Enabling Teachers to Modify Class and Grade Data
Creating a Class Hierarchy by Using Inheritance
Creating Class Hierarchies
Extending .NET Framework Classes
Lab: Refactoring Common Functionality into the User Class
Refactoring Common Functionality into the User Class
Implementing Password Complexity by Using an Abstract Method
Creating the ClassFullException Custom Exception
Reading and Writing Local Data
Reading and Writing Files
Serializing and Deserializing Data
Performing I/O by Using Streams
Lab: Generating the Grades Report
Serializing Data for the Grades Report as XML
Previewing the Grades Report
Persisting the Serialized Grade Data to a File
Accessing a Database
Creating and Using Entity Data Models
Querying Data by Using LINQ
Lab: Retrieving and Modifying Grade Data
Creating an Entity Data Model from The School of Fine Arts Database
Updating Student and Grade Data by Using the Entity Framework
Extending the Entity Data Model to Validate Data
Accessing Remote Data
Accessing Data Across the Web
Accessing Data by Using OData Connected Services
Lab: Retrieving and Modifying Grade Data Remotely
Creating a WCF Data Service for the SchoolGrades Database
Integrating the Data Service into the Application
Retrieving Student Photographs Over the Web (If Time Permits)
Designing the User Interface for a Graphical Application
Using XAML to Design a User Interface
Binding Controls to Data
Lab: Customizing Student Photographs and Styling the Application
Customizing the Appearance of Student Photographs
Styling the Logon View
Animating the StudentPhoto Control (If Time Permits)
Improving Application Performance and Responsiveness
Implementing Multitasking
Performing Operations Asynchronously
Synchronizing Concurrent Access to Data
Lab: Improving the Responsiveness and Performance of the Application
Ensuring That the UI Remains Responsive When Retrieving Teacher Data
Providing Visual Feedback During Long-Running Operations
Integrating with Unmanaged Code
Creating and Using Dynamic Objects
Managing the Lifetime of Objects and Controlling Unmanaged Resources
Lab: Upgrading the Grades Report
Generating the Grades Report by Using Word
Controlling the Lifetime of Word Objects by Implementing the Dispose Pattern
Creating Reusable Types and Assemblies
Examining Object Metadata
Creating and Using Custom Attributes
Generating Managed Code
Versioning, Signing, and Deploying Assemblies
Lab: Specifying the Data to Include in the Grades Report
Creating and Applying the IncludeInReport attribute
Updating the Report
Storing the Grades
Utilities Assembly Centrally (If Time Permits)
Encrypting and Decrypting Data
Implementing Symmetric Encryption
Implementing Asymmetric Encryption
Lab: Encrypting and Decrypting the Grades Report
Encrypting the Grades Report
Encrypting the Grades Report
HTML CSS3 & Javascript
HTML 5
Sectioning Content
Section
Article
Aside
Nav
Address
Outlines
Explicit Sections
Document Headings
Header and Footer
Planning the Page Layout
Sectioning Roots
Blockquote
Details
Figure
Grouping Elements
Paragraph
Horizontal Rule
Preformatted
Main
Division
Listing Elements
List
Description List
Inline Frames
Edits
Quoting
Span
Table HTML Elements
Simple Table
Column and Row Headings
Column Groups
Table Heading and Footer
Spanning Cells
Embedded HTML Elements
Anchor
Images
Multiple Sources
HTML5 Plug-Ins
HTML Form Elements
Overview
Form Element
Form Action
Form Method
Additional Attributes
Input Elements
Textual Form Data
Selection Elements
Miscellaneous Types
Date and Time Data
Other Visual Elements
Labels
Output Element
Meter Element
Progress Element
Button Types
Organizing a Form
Validation
CSS
CSS Selectors
Selector Overview
Element Selectors
Class Selectors
ID Selectors
Attribute Selectors
Pseudo-Class Selectors
Pseudo-Elements
Using Combinators
Combining Element and Class Selectors
Pseudo-Selectors
Combinator Operators
The Not Selector
Group Operator
Resolving Conflicts
Media Queries
Media Attributes
Using Media Queries
Positioning Content
Display
Defining Sizes
Absolute Size
Relative Size
Setting Maximum Values
Content-Based
Box Sizing
Float
Clearing Floats
Containing Floats
Inline Block
Position
Relative Positioning
Absolute Positioning
Fixed Positioning
Z-Index
Centering Content
Text Styles
Fonts
Obtaining Fonts
Font Families
Font Settings
Shorthand Notation
Text Formatting
Horizontal Alignment
Indent
Overflow
Quotes
Shadow
Capitalization
Spacing and Alignment
Handling Whitespace
Vertical Alignment
Break
Word Wrap
Page Break
Cursor
Flexbox
Container Configuration
Flex Direction
Flex Wrap
Justification
Aligning Items
Item Configuration
Grow and Shrink
Order
Overriding Alignment
Java Script
JavaScript Essentials
Introducing JavaScript
Objects
Constructors
Prototypes
Inheritance
Using Prototypes
Using Create
Using the Class Keyword
Overriding Members
Properties
Arrays
Attributes
Special Types
Miscellaneous Topics
Comparison Operators
Variable Scope
Strict Mode
Functions
Context
Immediately Invoked Functions
Namespaces
Exceptions
Promises
Array Methods
Accessing Elements
Outputting an Array
Manipulating Element
Searching
Creating Subsets
Processing
Browser Environment
Browser Object Model
Screen
Location
History
Navigator
DOM Elements
Document Object Model
Element Inheritance
Simple Demonstration
Basic DOM Manipulation
Finding Elements
Creating Elements
Moving Elements
Modifying Elements
Dynamic Styling
Changing Style Sheets
Enabling Style Sheets
Choosing a Style Sheet
Alternate Style Sheets
Using Style Elements
Modifying Rules
Modifying Classes
Modifying Inline Styles
o Using CSSStyle Declaration
o Setting Style Properties
o Using setAttribute
Computed Style
Events
Initial Example
Event Registration
Event Propagation
Unregistering Events
Event Interface
o Common Event Properties
o Cancelling Events
Exploring Events
SQL
Getting Started with SQL Server 20191
SQL Server core concepts
SQL Server editions
Applications included with SQL Server
Preparing for installation
Creating service accounts
Installing SQL Server
Post-installation checks
Installing sample databases
Tools and System Databases
Introduction to SQL Server Management Studio
Introduction to SQL Server Books Online
SQL Server system databases
Database Modeling: Tables
Introduction to database Modeling
Planning and creating SQL Server database
Identifying columns and selecting data types
Choosing primary keys
Using composite keys
Creating default values
Creating check constraints
Creating unique constraints"
Database Modeling: Relationships
Creating relationships
Defining one-to-many relationships
Exploring one-to-one relationships
Exploring many-to-many relationships
Understanding relationship rules and referential integrity"
Joining and Splitting Tables
Creating joins using your Mouse - the Query Editor
Writing Inner Joins in SQL
Joining more than two tables together
Joining tables from different databases
Using WHEREAS an Alternative to INNER JOIN
The Limitations of Inner Joins
Full, Left and Right Outer Joins in SQL
Deciding on the Order of the Join
Showing Unmatched Records
Outer Joins with Multiple Tables
Cross Joins using SQL
Self-Joins in SQL (joining a table to itself)
Using MERGE, UNION, and INTERSECT AND EXCEPT to combine different tables
Database Modeling: Optimization
Understanding normalization
First normal form
Second normal form
Third normal form
Database de normalization
Creating computed columns"
Importing Existing Data
Using the SQL Server Import and Export Wizard
Importing Excel files into SQL Server
Importing CSV files into SQL Server
Importing Access databases into SQL Server
Retrieving Data with SQL
Introduction to Transact-SQL
Using SELECT statements and SQL Syntax Overview
Formatting SQL
Dealing with nulls - ISNULL, COALESCE and CASE
Controlling column behaviours with constraints
Creating an ID column
Filtering data with WHERE, LIKE, and IN, BETWEEN, AND, OR, NOT
Removing duplicates with SELECT DISTINCT"
Sorting with ORDER BY
Ordering by a Single Column
Sorting Data based on Collation
Sorting Data in Descending Sequence
Sorting Data Based on Column Not In SELECT List
Sorting Data based on Column Ordinal Position
Sorting Data Based on Multiple Columns
Numeric Character Data Sorted Alphabetically"
Inserting and Updating Data
Inserting Single Records into a Table
Inserting Multiple Rows of Data into a Table
SELECT INTO - Making a New Table from Existing Rows
Updating Every Record in a Table
Using Criteria When Updating Records
Referring to Other Tables When Updating Records
Deleting Records from a Table
Deleting Records from Different Tables
Deleting Every Record from a Table
Difference between Delete, Drop and Truncate
Using the OUTPUT clause to return inserted keys and GUIDs"
Grouping Data
Grouping by a Single Column
Grouping by Multiple Columns
Using an Expression in the GROUP BY Clause
Restricting result set by using HAVING clause
Difference between Where and Having
Advanced Group by clause
Using the ROLLUP operator to Create Subtotals and a Grand Total
Using the CUBE Operator to create a Superset of Aggregated Values
Creating Multiple Aggregated Groupings using the GROUPING SETS Operator
TOP Clause
Simple Example of the TOP Clause
Using the PRECENT option of the TOP Clause
Using a Variable to Control the TOP Clause
USING the WITH TIES Option
USING the TOP clause with UPDATE, Insert and Delete Statement
Caution When Using TOP Clause in UNION, EXCEPT and INTERSECT Statements
SQL Functions
Introduction to SQL functions
Using SQL configuration functions
Arithmetic and numerical functions like Abs, Ceiling, Floor, Power, Round, Sign,
Sqrt, Square etc.
String functions like Char index, Replace, Stuff, Patindex, Left, Right, Substring,
Reverse, Len, Ltrim, Rtrim etc.
Date and Time Functions like Dateadd, Datepart, Datename, dated etc
Formatting Dates and Times in SQL
VIEWS
Creating View Using View Designer
Scripting Views Using SQL
Advantages and Disadvantages of Creating Views
Subqueries
Finding the Highest or Lowest Value in a Column
Finding Records Above or Below Average
Using ALL, ANY, SOME, and IN with Subqueries
Creating a Correlated Subquery
Correlated Subqueries using ALL and ANY
Variables
Declaring Variables
Assigning values to variables - SET versus SELECT
Incrementing and decrementing integer variables
The Scope of Variables
Uses of Variables in SQL
Global Variables in SQL - @@Identity, @@RowCount, @@Error, @@ServerName,
@@Trancount etc
Conditions in SQL
IF-ELSE
Syntax of a simple IF statement
Multiple IF conditions using ELSE
Using EXISTS to see if records exist
Using variables to compare two counts
Case when Statement
Loops
The Basic Syntax of a WHILE Loop
Examples of using WHILE Loop
The BREAK Statement
Getting Stuck in an Endless Loop
Debugging and Error Handling
Error Handling
Error Functions in SQL
Debugging Options – Stepping over and Stepping out of the code
Changing the next statement executed
Using Breakpoints
Using Locals Window, Watch Window, Immediate Window, Call stack
Practical Example of Error Handling
Raising Errors – Using THROW, Using RAISE ERROR
Stored Procedures
Views versus Stored Procedures
The Syntax for Creating a Basic Stored Procedure
Different ways of Running Stored Procedure
Altering Stored Procedure
Passing Parameters to Stored Procedures
Reasons for using Parameters and limitations of stored procedures
Returning Values from Stored Procedures
Using Output Parameters in Stored Procedures"
Functions
Scalar User-Defined Functions in SQL Server
Creating and Using Custom Functions
Passing Parameters to Functions
Altering and Deleting Functions
Writing Complex User Defined Functions"
Transactions
Beginning Transactions in SQL Server
Transaction Patterns - Designs
Using Transactions with Error Handling
Automatic Rollback of Transactions
Nesting Transactions
Creating and Rolling Back to a Savepoint
Using Savepoint in Stored Procedures
Temporary Tables
Usage of Temporary Tables
Dropping Temporary Tables - Object_Id or BEGIN TRY
Pros and Cons of Temporary Tables
Table Variables
Syntax of Temporary Variables
Usage of Table Variables
Pros and Cons of Table Variables
Table-valued functions in SQL
Simple (in-line) table-valued functions
Multi-Statement Table-Valued Functions
Limitations of table-valued functions
OUTER and CROSS APPLY joins"
CTEs in SQL - Common Table Expressions
Example of a Common Table Expression
Common Problems with CTEs
Recursive CTEs
Derived Tables in SQL Server
Why Use Derived Tables?
Shortening Complex Queries with Derived Tables
Pivoting Data in SQL Server
Using Pivot Operator in SQL
Dynamic Pivot tables
Unpivot
Triggers in SQL
DDL Triggers
DML Triggers
Logon Triggers
Cursors
Why Use Cursors?
Declaring and Using Cursors
Fetching Records with an SQL Cursor
SQL Cursor Options
Updating Records using a Cursor
Backing Up and Restoring
Creating backups
Creating differential backups and using backup compression
Restoring databases
Performance Tuning
Developing Applications using .NET Core
Introduction
What is .NET Core?
.NET Core vs. Full Framework
Overview of ASP.NET Core
.NET Core SDK
Installation
Version Management
Command-Line Interface (CLI)
Hello World Application
ASP.NET Core Application Architecture
NuGet Packages
Application Startup
Hosting Environments
Middleware and the Request Pipeline
Services and Dependency Injection
MVC vs. Razor Pages
Creating First .Net core Application
Console Based .Net Core application
.Net Core Class Library
.Net Core Web Application
.Net Core Web Application with Client Side Framework (Angular/React)
.Net Core RESTFull Application
Understanding the project architecture, Files, Methods, associated .dll in Detail
Working with C# 9 Integration
Integrate Task Parallel Library (TPL)
Asyn and Await Demonstraion
Simplified Parameter Validation
Nullable Enhansment Type
Ternary Operations
Application Configuration
Configure and ConfigureServices
Configuration Providers and Sources
Configuration API
Options Pattern
HTTPS and HTTP/2
Request Routing
RESTful Services
Endpoint Routing
Route Templates
Route Constraints
Attribute-Based Routing
Models
Persistence Ignorance
Object-Relational Mapping
Entity Framework (EF) Core
Dapper ORM
Controllers
Responsibilities
Requirements and Conventions
Dependencies
Action Results
Views
Responsibilities
Conventions
Razor Syntax
Layouts
ViewData and ViewBag
Strongly-Typed Views
Partial Views
HTML and URL Helpers
Tag Helpers
View Components
Client-Side Dependencies
Razor Pages
View Models
HTML Forms
Form Tag Helper
Input Tag Helper
Select Tag Helper
Form Submissions
Model Binding
Data Validation
Introduction
Data Annotations
Model Binding
Input Tag Helpers
Validation Tag Helpers
Application State
Client-Side vs. Server-Side
HttpContext.Items
Session State
TempData
Error Handling
Best Practices
HTTP Error Status Codes
Status Code Pages
Developer Exception Page
Logging
Configuration
ILogger
Serilog and Seq
.Net Core with Data Interaction Entity Framework Core () (EF Core)
Creating , Upgrading, Modifying Database
Querying Data
Validations
Mapping
Relationship
Concurrency Tokens
Asynchronous Queries
Dependency Injection
Singleton
Transient
Scoped Objects
Understanding IOC Pattern
What is Inversion of control
IOC Hands On lab
IOC with Unity Framework
Creating and Understanding Services ()
Using Dependency Injection for Repository
Creating Repositories
Registering Services in DI.
Filters
Understanding Filters
IFilter Factory
Custom Filters
Working with Caching (HOL)
In-Memory Cache
Distributed Cache
Response Caching
Customization
Custom Tag Helpers
Dependency Injection in Views
Authentication
Introduction
ASP.NET Core Identity
Cookie Middleware
Authorization
Claims-Based Authorization
Web APIs
API Controllers
Testing APIs
CRUD Operations
OpenAPI (Swagger)
Cross-Origin Resource Sharing (CORS)
Deployment
dotnet publish
Kestrel
IIS
Docker
Entity Framework
Entity Framework Introduction
What is ADO.NET Entity Framework
Comparing EF with LINQ to SQL
EF Architecture
EF Versions History
First EF Application and Creating EDMX File
DbContextvsObjectContext
CRUD Operations
Members of DbContext and DbSet
Entity Life Cycle and ObjectStateManager
Example Performing CRUD Operations
Executing Stored Procedure
EDM Relationships
Querying Database
LINQ Queries
Entity SQL Queries
Lazy Loading
Eager Loading
Explicit Loading
No-Tracking Queries
Additional Features
Inheritance Type
o Table Per Type inheritance
o Table Per Hierarchy inheritance
Modeling Techniques
o Database First
o Model First
o Code First
Web API
REST Architecture
What are REST Services
Hypertext Transfer Protocol
Why and When to Use REST Service
REST vs. SOAP Services
The ASP.NET Web API Framework
REST Basics
Resources
Uniform Resource Locators
HTTP Methods
HTTP Status Codes
Resource Formats
MIME Types
Accept Header and Content Negotiation
Building and Using Media and Type Formatters
Browser-Based Clients
Browsers Aren't as Smart as They Should Be
They Claim They Can Accept Any Resource
Use Templates or Data Binding to Display Data
Browsers Can Be over Aggressive with Caching
Browsers Are Built around the HTML Spec and Don't Support All HTTP Features
Hypermedia
The Problem with Simple REST Services
Hypermedia Contracts
OData and AtomPub
Securing REST Services
HTTP Security
SSL/TLS
Basic Authentication
Forms Authentication
Integrated Authentication
Token-Based Security
OAuth and OAuth2
Amazon's S3 Authentication
Federated Security
Scalability
Filtering Data
HTTP Caching
MSTest
Unit Test 101
1. Unit test basics
2. Naming conventions
3. Running unit tests
4. Create the test project
5. Unit Test Generation
6. Debugging unit tests
Gouping and Filtering
1. Grouping Unit Tests
2. Traits
3. Filtering Unit Tests
Code Coverage
1. TestClass and TestMethod attirbutes
2. Testing Exceptions
3. Unit Testing Private Methods
4. Ordered Test
5. Generic Test
Data Driven Unit Tests
1. TestContext
2. Data-Driven Unit Test
3. Data-Driven Unit Test - CSV
4. Using a Configuration File to Define a Data Source
Intialize and Cleanup
1. TestInitialize and TestCleanup
2. ClassInitialize and ClassCleanup
3. AssemblyInitialize and AssemblyCleanup
4. TimeOut and Ignore attributes
Assestions
1. Asserts
2. Assert class
3. Assert Object Equality
4. CollectionAssert
5. StringAssert
React JS Fundamentals
Introduction
Package Manager (npm/Yarn)
npm
What is Node.js?
What is npm?
Using npm
npm Scripts
Working with HapiJS
Compiler Setup
Setup (Babel)
ES6/ES2015
Classes
Scope (var, let, const)
Arrow Functions
Modules
Template Literals
Default, Rest, Spread
Default
Rest
Spread
Destructuring
Optional Parameters
Object.assign()
Object Initializer
Project Setup (Create React App)
Create new Project
Folder Structure
Browser Support
Styles and Assets
Dependencies
Best Practices (Code Organization & Conventions)
React Overview
Why React?
What it is?
Why it is useful?
Angular, React Compared
Web application architectures
Server-side web application architecture
Single-page web application architecture
React Architecture
Elements
Hello World in JavaScript
Hello World in React
JSX
Replacing create Element
Embedding Expressions
Specifying Attributes
Virtual DOM
Components
Creating an Element
Create a Function Component
Rendering a Component
Creating a Class Component
Composing & Reuse
Props
Read-only
String Literals vs. Expressions
Function vs. Class Components
Events
Listening/Subscribing/Wiring to an Event
In Vanilla JavaScript
In React: Function Component
In React: Class Component
Binding
Why Binding is Necessary?
Class Method
Arrow Function
Passing Parameters
Using Arrow Functions
Using Bind
Handling Events
Using Arrow Functions
Using Bind
Synthetic Events
State
Defining
Using State Correctly
Data Flows Down
Converting a Function Component to a Class Component
Lifecycle
What are Lifecycle Methods
Understanding Mounting
Common vs. Less Common Methods
Using Lifecycle Methods
Conditional Rendering
If, else
Conditional Operator (?)
Logical (&&) Operator
Lists
In Vanilla JavaScript: for loop, array.forEach, array.map
In React: using Elements, Components
Why Keys are Needed
Component Architecture
Reuse
Component Communication
Design Patterns
Container and Presentation Components
Composition vs. Inheritance
Forms
Controlled Components
Reuse of Change Logic across Multiple Inputs
Handling Form Submission
Controlling Other Form Elements: select, textarea, number
Validation
Uncontrolled Components
HTTP
Axios library
Fetch API
Using with React (HTTP GET)
Refactoring for Reuse
HTTP POST, PUT, DELETE
Routing (React Router)
Installation
Basics
Handling Not Found (404)
Parameters (Url & Query)
Nesting
Hooks
Defined
Why Hooks?
No Breaking API Changes
Hooks API
useState
useEffect
Custom Hooks
Rules of Hooks
Build & Deploy
Building a React Application for Production
Deploying a React Application
Serving Apps with Client-Side Routing
Customizing Environment Variables
Redux
What is Redux?
What is State?
Benefits Checklist
Principles of Redux
Core Concepts (Store, State, Reducers, Actions, Action Creators)
Complementary Packages
When do you need Redux?
Basic Redux Example (includes time traveling)
Gotchas/Tips
Using Redux with React (React Redux Library)
The connect function
Writing mapState functions
Writing mapDispatch Functions
Provider
Inside React Redux
Example
Asynchronous Actions (Redux Thunk)
Overview
Async Actions (Thunks)
Installation
Your First Thunk
Full CRUD Example
Putting It All Together (React & Redux & Thunk)
Unit Testing
Tools (Jest, Enzyme, Mocha)
Syntax
Testing Vanilla JavaScript with Jest
Mocking
Mocking Modules
Mocking Functions
Introduction
Advanced React
JSX + Do Expressions
Composition vs. Inheritance
Component Tree Patterns
Using Synthetic Events
CSS Animations
Non-React UI Elements
Advanced Unit Testing
State Management Theory
Pitfalls of Local State
Lifting State Up
Kinds of State
Managing State outside the Tree
Advanced Redux
Reducers and State Trees
Combining Reducers
Reducer Patterns
Computing Derived Data
Creating Redux Middleware
Testing Reduces and Action Creators
Routing React/Redux Applications
Principles of Routing
React Router
Connecting React Router to Redux
Advanced Redux Side-Effects
Redux Thunk vs. Redux Sagas
JavaScript Generators
Saga Helpers
Declarative Effects
Error Handling
Sequencing Sagas
Composing Sagas
Testing Sagas
Reactive Programming with React/Redux
Overview of Reactive Programming
Using RxJS with Redux
Redux-Observable and Epics
Testing Epics
Capstone Project