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