FULLSTACK COURSES
Guaranteed 8+ LPA
Salary or Pay Nothing Until You Do! - Pay
After Placement
Quick Enquiry
Join our Pay After Placement Full Stack Learning Bootcamp, where you only pay when you land a job above 8 LPA. Gain in-demand skills, expert mentorship & career support without any financial burden.
Quick Enquiry
Fullstack Course
Equiped you with the most in-demand skills for a thriving tech career.
If coding is your strength, unlock a bright future with the best Full Stack Developer course in Delhi, NCR. This industry-focused program is designed to equip you with cutting-edge skills and expertise that today’s tech world demands.
5000+
Students Placed
Excel in tech with hands-on learning and expert guidance. Enroll today!
PROLYTICS OFFERS
100% Job Guarantee
Get 100% Job Guarantee with Prolytics! Gain in-demand skills, hands-on training, and expert guidance. Secure top jobs with our proven placement support. You can grab any below mentioned positions!
Knowledge and Numbers
Full Stack Development is all about mastering both the front-end and back-end of web applications. The front-end is what users see and interact with, while the back-end powers the system, managing data and logic. A Full Stack Developer works with a variety of technologies to build fully functional, seamless applications from start to finish.
Absolutely! Full Stack Developers are among the most sought-after professionals in the tech industry. Companies prefer skilled developers who can handle both front-end and back-end tasks efficiently. In India, Full Stack Development is one of the highest-paying careers in IT. That’s why many institutes, including Prolytics, offer expert-led Full Stack Developer courses in Delhi NCR to help students build a thriving career.
Upon completing our Full Stack Developer course with guaranteed placement support, you will receive: ✅ Industry-recognized certification, ✅ Hands-on project experience, ✅ Placement assistance, where we share your profile with top companies and set up interviews until you secure a job. Our goal is to make you job-ready from day one!
We provide 100% placement assistance after you finish your course. we connected with more than 500+ multinational IT companies for placement. With Prolytics dedicated placement assistance, you can start receiving interview calls within two weeks of submitting your placement application. Depending on your skills and preparation, you can land a full-time job within a month after completing the course.
Upon completion, you’ll have a professional resume, portfolio, and a diploma certificate. We also offer placement support to help you secure a job with a reputable company. Also give experience letter to get the job quickly.
Our Pay After Placement Full Stack Learning agreement, where you only pay when you land a job above 8 LPA.
we believe in empowering individuals with the skills and knowledge needed to excel in today's competitive world.
0
0
0
0
UPSKILL
WHY PROLYTICS
Why Choose Prolytics for Your Career Growth?
Cras a elit sit amet leo accumsan volutpat. Suspendisse hendreriast ehicula leo, vel efficitur felis ultrices non.
- Cutting-Edge Curriculum - Stay ahead with industry-relevant courses designed for real-world applications.
- Expert-Led Training – Learn from experienced professionals with hands-on industry knowledge.
- Job Assistance & Placement Support – Secure top opportunities with our dedicated career placement program.
- Build a Standout Portfolio – Gain practical skills and showcase your expertise with guided portfolio development.
ADVANCED COURSE
Fullstack Course Curriculam
Cras a elit sit amet leo accumsan volutpat. Suspendisse hendreriast ehicula leo, vel efficitur felis ultrices non. Cras a elit sit amet leo acun volutpat. Suspendisse hendrerit vehicula leo, vel efficitur fel.
Learning Modules
| Course Setup & Resources |
| Module Introduction | |
| A New Starting Project & Analyzing The Project Structure | |
| Understanding Components & How Content Ends Up On The Screen | |
| Creating a First Custom Component | |
| [Optional] JavaScript Refresher: Classes, Properties & More | |
| Configuring the Custom Component | |
| Using the Custom Component | |
| Styling the Header Component & Adding An Image | |
| Managing & Creating Components with the Angular CLI | |
| Styling & Using Our Next Custom Component | |
| Preparing User Data (To Output Dynamic Content) | |
| Storing Data in a Component Class | |
| Outputting Dynamic Content with String Interpolation | |
| Property Binding & Outputting Computed Values | |
| Attribute Binding | |
| Using Getters For Computed Values | |
| Listening to Events with Event Binding | |
| Managing State & Changing Data | |
| A Look Behind The Scenes Of Angular's Change Detection Mechanism | |
| Introducing Signals | |
| We Need More Flexible Components! | |
| Defining Component Inputs | |
| Required & Optional Inputs | |
| Using Signal Inputs | |
| We Need Custom Events! | |
| Working with Outputs & Emitting Data | |
| Using the output() Function | |
| Adding Extra Type Information To EventEmitter | |
| Exercise: Create a Configurable Component | |
| TypeScript: Working With Potentially Undefined Values & Union Types | |
| Accepting Objects As Inputs & Adding Appropriate Typings | |
| TypeScript: Type Aliases & Interfaces | |
| Outputting List Content | |
| Outputting Conditional Content | |
| Legacy Angular: Using ngFor & ngIf | |
| Adding More Components to the Demo App | |
| Outputting User-specific Tasks | |
| Outputting Task Data in the Task Component | |
| Storing Data Models in Separate Files | |
| Dynamic CSS Styling with Class Bindings | |
| More Component Communication: Deleting Tasks | |
| Creating & Conditionally Rendering Another Component | |
| Managing The "New Task" Dialog | |
| Using Directives & Two-Way-Binding | |
| Signals & Two-Way-Binding | |
| Handling Form Submission | |
| Using the Submitted Data | |
| Content Projection with ng-content | |
| Transforming Template Data with Pipes | |
| Getting Started with Services | |
| Getting Started with Dependency Injection | |
| More Service Usage & Alternative Dependency Injection Mechanism | |
| Time to Practice: Services | |
| Using localStorage for Data Storage | |
| Module Summary |
| Module Introduction | |
| A First Introduction To Angular Modules (NgModule) | |
| Creating a First Empty Module | |
| Bootstrapping Apps with Angular Modules | |
| Declaring & Using Components | |
| A First Summary | |
| Migrating All Components To Use Modules | |
| Creating & Using Shared Modules | |
| Creating More Complex Module-based App Structures |
| Module Introduction & Starting Project | |
| Exercise Hints | |
| Adding a Header Component With An Image | |
| Adding a User Input Component | |
| Handling Form Submission | |
| Extracting Values with Two-Way-Binding | |
| Calculating the Annual Investment Data | |
| Cross-Component Communication with Outputs | |
| Creating & Using a Data Model | |
| Passing Data from Parent to Child with Inputs | |
| Outputting Data in a Table | |
| Formatting Output with a Pipe | |
| Using Signals & Resetting The Form After Submission | |
| Using a Service for Cross-Component Communication | |
| Using Signals in Services | |
| Migrating to Angular Modules | |
| Module Summary |
| Module Introduction | |
| Understanding Error Messages & Fixing Errors | |
| Debugging Logical Errors with the Browser DevTools & Breakpoints | |
| Exploring the Angular DevTools |
| Module Introduction | |
| Starting Project & An Opportunity For Smaller Components? | |
| When & How To Split Up Components | |
| Splitting A Component Into Multiple Components | |
| Creating Reusable Components | |
| Component Inputs: Repetition | |
| Property Binding: Repetition | |
| Using Content Projection & ng-content | |
| Adding Forms to Components | |
| A Possible, But Not Ideal Way Of Extending Built-in Elements | |
| Extending Built-in Elements with Custom Components via Attribute Selectors | |
| Supporting Content Projection with Multiple Slots | |
| Exploring Advanced Content Projection | |
| Defining Content Projection Fallbacks | |
| Multi-Element Custom Components & Content Projection | |
| Scoping CSS Styles to Components | |
| Understanding & Configuring View Encapsulation | |
| Making Sense of Component Host Elements | |
| Using Host Elements Like Regular Elements | |
| Interacting With Host Elements From Inside Components | |
| When (Not) To Rely On Host Elements | |
| Interacting with Host Elements via @HostListener & @HostBinding | |
| Accessing Host Elements Programmatically | |
| Class Bindings: Repetition | |
| There's More Than One Way Of Binding CSS Classes Dynamically | |
| A Closer Look At Dynamic Inline Style Binding | |
| Manipulating State & Using Literal Values | |
| Introducing the Component Lifecycle: ngOnInit | |
| Implementing Lifecycle Interfaces | |
| Component Lifecycle - A Deep Dive | |
| Component Cleanup with ngOnDestroy | |
| Component Cleanup with DestroyRef | |
| Handling Form Submissions: Repetition | |
| Working with Template Variables | |
| Extracting Input Values via Template Variables | |
| Template Variables & Component Instances | |
| Getting Access to Template Elements via ViewChild | |
| Using The viewChild Signal Function | |
| ViewChild vs ContentChild | |
| A Closer Look at Decorator-based Queries & Lifecycle Hooks | |
| The afterRender and afterNextRender Lifecycle Functions | |
| Making Sense of Signal Effects | |
| Signal Effects Cleanup Functions | |
| TypeScript & Type Models: Repetition | |
| Component Outputs: Repetition | |
| A Closer Look At Template For Loops | |
| Revisiting Inputs & Signals | |
| Updating Signal Values | |
| Cross-Component Communication & State Management | |
| Configuring Component Inputs & Outputs | |
| Two-Way Binding: Repetition | |
| Setting Up Custom Two-Way Binding | |
| An Easier Way of Setting Up Custom Two-Way Binding |
| Module Introduction | |
| Understanding Directives | |
| The Starting Project | |
| Analyzing a Built-in Attribute Directive: ngModel | |
| Analyzing a Built-in Structural Directive: ngIf | |
| Getting Started with Custom Directives | |
| Using Attribute Directives To Change Element Behavior | |
| Working with Inputs in Custom Directives | |
| Directives & Dependency Injection | |
| Building Another Directive | |
| Building a Custom Structural Directive | |
| Structural Directives & Syntactic Sugar | |
| Host Directives & Composition |
| Module Introduction | |
| Making Sense of Pipes | |
| Using Built-in Pipes | |
| More Built-in Pipes Examples | |
| Building a First Custom Pipe | |
| Using Custom Pipes to Perform Custom Transformations | |
| Accepting Parameters in Custom Pipes | |
| Chaining Pipes & Being Aware of Limitations | |
| Building a Pipe That Sorts Items | |
| Understanding How Pipes Are Executed | |
| Pure & Impure Pipes | |
| Pipe Limitations & When Not To Use Them |
| Module Introduction | |
| The Starting Project & The Need For A Centralized Service | |
| Creating a Service | |
| How NOT To Provide A Service | |
| Using Angular's Dependency Injection Mechanism | |
| Using The Alternative Dependency Injection Syntax | |
| Outsourcing & Reusing Logic with Services | |
| Angular Has Multiple Injectors! | |
| There Are Multiple Ways Of Providing a Service | |
| Providing Services via the Element Injector | |
| Understanding the Element Injector's Behavior | |
| Injecting Services Into Services | |
| Analyzing Dependency Injection with the Angular DevTools | |
| Using Custom DI Tokens & Providers | |
| Preparing A Non-Class Value For Injection | |
| Injecting Other Values (NOT Services) | |
| Angular Modules (NgModule) & Dependency Injection | |
| Working with Services Without Using Signals |
| Module Introduction | |
| Analyzing the Starting Project | |
| Understanding How Angular Performs Change Detection | |
| Change Detection During Development: ExpressionChangedAfterChecked Errors | |
| Writing Efficient Template Bindings | |
| Avoiding Zone Pollution | |
| Using the OnPush Strategy | |
| Understanding the OnPush Strategy | |
| Working with OnPush & Signals | |
| Using Signals for Sharing Data Across Components (with OnPush) | |
| The Problem With OnPush, Cross-Component Data & Not Using Signals | |
| Triggering Change Detection Manually & Using RxJS Subjects | |
| Introducing The async Pipe | |
| Going Zoneless! |
| Module Introduction | |
| What Are Observables & What Is RxJS? | |
| Creating & Using an Observable | |
| Working with RxJS Operators | |
| Working with Signals | |
| Signals vs Observables | |
| Converting Signals To Observables | |
| Converting Observables To Signals | |
| Deep Dive: Creating & Using A Custom Observable From Scratch | |
| Module Summary |
| Module Introduction | |
| The Starting Projects: Frontend & Backend | |
| How To Connect Angular Apps To A Backend | |
| Optional: HTTP Essentials | |
| Getting Started with Angular's Http Client | |
| Providing the HttpClient when using NgModules | |
| Sending a GET Request To Fetch Data | |
| Configuring Http Requests | |
| Transforming & Using Response Data | |
| Showing a Loading Fallback | |
| Handling HTTP Errors | |
| Sending Data To A Backend | |
| More Data Fetching & Some Code Duplication | |
| Outsourcing HTTP Request Logic Into A Service | |
| Managing HTTP-loaded Data via a Service | |
| Implementing Optimistic Updating | |
| Potential Problems Introduced by Optimistic Updating | |
| Improved Optimistic Updating | |
| Implementing App-wide Error Management | |
| Practice: Sending DELETE Requests | |
| Introducing HTTP Interceptors | |
| Optional: Class-based Interceptors | |
| Introducing HTTP Response Interceptors |
| Module Introduction | |
| Template-driven vs Reactive Forms | |
| Template-driven: Registering Form Controls | |
| Getting Access to the Angular-managed Form | |
| Extracting User Input Values | |
| Validating Input with Form Validation Directives | |
| Using the Form Validation Status To Provide User Feedback | |
| Adding Validation Styles | |
| Interacting With The Underlying Form Object In The Component | |
| Updating Form Values Programmatically | |
| Reactive Forms: Getting Started | |
| Syncing Reactive Form Definition & Template | |
| Handling Form Submission (Reactive Forms) | |
| Adding Validators To Reactive Forms | |
| Building Custom Validators | |
| Creating & Using Async Validators | |
| Interacting with the Form Programmatically | |
| Exercise: Problem | |
| Exercise: Solution | |
| Connecting & Registering Inputs For A Complex Form | |
| Working with Nested Form Groups | |
| Working with Form Arrays | |
| Practice: Adding More Validation | |
| Creating Multi-Input Validators / Form Group Validators | |
| Module Summary |
| Module Introduction | |
| What Is Routing? | |
| Enabling Routing & Adding a First Route | |
| Rendering Routes | |
| Registering Multiple Routes | |
| Adding Links The Right Way | |
| Styling Active Navigation Links | |
| Setting Up & Navigating To Dynamic Routes | |
| Extracting Dynamic Route Parameters via Inputs | |
| Extracting Dynamic Route Parameters via @Input() | |
| Extracting Dynamic Route Parameters via Observables | |
| Working with Nested Routes | |
| Route Links & Relative Links | |
| Accessing Parent Route Data From Inside Nested Routes | |
| Loading Data Based On Route Parameters In Child Routes | |
| Link Shortcuts & Programmatic Navigation | |
| Adding A "Not Found" Route | |
| Redirecting Users | |
| Splitting Route Definitions Across Multiple Files | |
| Activated Route vs Activated Route Snapshot | |
| Setting Query Parameters | |
| Extracting Query Parameters via Inputs | |
| Extracting Query Parameters via Observables | |
| Using Query Parameters For Data Manipulation | |
| Adding Static Data To Routes | |
| Resolving Route-related Dynamic Data | |
| Optional: Class-based Resolvers | |
| Accessing Route Data In Components | |
| Controlling Route Resolver Execution | |
| Setting & Resolving Titles | |
| Introducing Route Guards | |
| Optional: Class-based Guards | |
| Making Sense of The CanDeactivate Guard | |
| Improving The CanDeactivate Logic | |
| Reloading Pages via the Angular Router & Configuring Programmatic Navigation |
| Module Introduction | |
| What Is Lazy Loading / Code Splitting? | |
| Introducing Route-based Lazy Loading | |
| Implementing Route-based Lazy Loading | |
| Lazy Loading Entire Route Groups | |
| Using Lazy Loading & Routing to Lazy-load Services | |
| Introducing Deferrable Views | |
| Defer Loading Until Viewport Visibility | |
| Deferrable Views: Using Other Triggers | |
| Prefetching Lazy-loaded Code | |
| Deferrable Views: Summary |
| Module Introduction | |
| The Starting Project | |
| Preparing a Project For Deployment: Building It For Production | |
| Building SPAs: Pros & Cons | |
| SPAs: Deployment Example | |
| Using "ng add", "ng deploy" & Angular's Built-in Deployment Support | |
| Server-side Rendering (SSR) Introduction | |
| Setting Up SSR For An Angular App | |
| Building and Service an SSR App | |
| Authoring SSR-ready Code (Beware of Pitfalls!) | |
| SSR and Client-Server Mismatches | |
| Static Site Generation (SSG) Introduction | |
| Configuring & Using SSG | |
| Deployment Methods - A Summary | |
| SSR & SSG Deployment Example |
| Course Roundup | |
| Bonus: More Content! | |
| About The Rest Of This Course | |
| Where To Go Next? |
| About This Section | |
| Module Introduction | |
| How an Angular App gets Loaded and Started | |
| Components are Important! | |
| Creating a New Component | |
| Understanding the Role of AppModule and Component Declaration | |
| Working with Standalone Components | |
| Using Custom Components | |
| Creating Components with the CLI & Nesting Components | |
| Working with Component Templates | |
| Working with Component Styles | |
| Fully Understanding the Component Selector | |
| Practicing Components | |
| [OPTIONAL] Assignment Solution | |
| What is Databinding? | |
| String Interpolation | |
| Property Binding | |
| Property Binding vs String Interpolation | |
| Event Binding | |
| Bindable Properties and Events | |
| Passing and Using Data with Event Binding | |
| Important: FormsModule is Required for Two-Way-Binding! | |
| Two-Way-Databinding | |
| Combining all Forms of Databinding | |
| Practicing Databinding | |
| [OPTIONAL] Assignment Solution | |
| Understanding Directives | |
| Using ngIf to Output Data Conditionally | |
| Enhancing ngIf with an Else Condition | |
| Angular 17: Alternative "if" Syntax | |
| Styling Elements Dynamically with ngStyle | |
| Applying CSS Classes Dynamically with ngClass | |
| Outputting Lists with ngFor | |
| Angular 17: Alternative "for" Syntax | |
| Practicing Directives | |
| [OPTIONAL] Assignment Solution | |
| Getting the Index when using ngFor |
| About This Section | |
| Project Introduction | |
| Planning the App | |
| Creating a New App Correctly | |
| Setting up the Application | |
| Creating the Components | |
| Using the Components | |
| Adding a Navigation Bar | |
| Alternative Non-Collapsable Navigation Bar | |
| Creating a "Recipe" Model | |
| Adding Content to the Recipes Components | |
| Outputting a List of Recipes with ngFor | |
| Displaying Recipe Details | |
| Working on the ShoppingListComponent | |
| Creating an "Ingredient" Model | |
| Creating and Outputting the Shopping List | |
| Adding a Shopping List Edit Section | |
| Wrap Up & Next Steps |
| Understanding Angular Error Messages | |
| Debugging Code in the Browser Using Sourcemaps |
| Module Introduction | |
| Splitting Apps into Components | |
| Property & Event Binding Overview | |
| Binding to Custom Properties | |
| Assigning an Alias to Custom Properties | |
| Binding to Custom Events | |
| Assigning an Alias to Custom Events | |
| Custom Property and Event Binding Summary | |
| Understanding View Encapsulation | |
| More on View Encapsulation | |
| Using Local References in Templates | |
| @ViewChild() in Angular 8+ | |
| Getting Access to the Template & DOM with @ViewChild | |
| Projecting Content into Components with ng-content | |
| Understanding the Component Lifecycle | |
| Seeing Lifecycle Hooks in Action | |
| Lifecycle Hooks and Template Access | |
| @ContentChild() in Angular 8+ | |
| Getting Access to ng-content with @ContentChild | |
| Wrap Up | |
| Practicing Property & Event Binding and View Encapsulation | |
| [OPTIONAL] Assignment Solution |
| Introduction | |
| Adding Navigation with Event Binding and ngIf | |
| Passing Recipe Data with Property Binding | |
| Passing Data with Event and Property Binding (Combined) | |
| Make sure you have FormsModule added! | |
| Allowing the User to Add Ingredients to the Shopping List |
| Module Introduction | |
| ngFor and ngIf Recap | |
| ngClass and ngStyle Recap | |
| Creating a Basic Attribute Directive | |
| Using the Renderer to build a Better Attribute Directive | |
| More about the Renderer | |
| Using HostListener to Listen to Host Events | |
| Using HostBinding to Bind to Host Properties | |
| Binding to Directive Properties | |
| What Happens behind the Scenes on Structural Directives | |
| Building a Structural Directive | |
| Understanding ngSwitch |
| Building and Using a Dropdown Directive | |
| Closing the Dropdown From Anywhere |
| Module Introduction | |
| Why would you Need Services? | |
| Creating a Logging Service | |
| Injecting the Logging Service into Components | |
| Alternative Injection Syntax | |
| Creating a Data Service | |
| Understanding the Hierarchical Injector | |
| How many Instances of Service Should It Be? | |
| Injecting Services into Services | |
| Using Services for Cross-Component Communication | |
| A Different Way Of Injecting Services | |
| Practicing Services | |
| [OPTIONAL] Assignment Solution |
| Introduction | |
| Setting up the Services | |
| Managing Recipes in a Recipe Service | |
| Using a Service for Cross-Component Communication | |
| Adding the Shopping List Service | |
| Using Services for Pushing Data from A to B | |
| Adding Ingredients to Recipes | |
| Passing Ingredients from Recipes to the Shopping List (via a Service) |
| Module Introduction | |
| Why do we need a Router? | |
| Understanding the Example Project | |
| Setting up and Loading Routes | |
| Navigating with Router Links | |
| Understanding Navigation Paths | |
| Styling Active Router Links | |
| Navigating Programmatically | |
| Using Relative Paths in Programmatic Navigation | |
| Passing Parameters to Routes | |
| Fetching Route Parameters | |
| Fetching Route Parameters Reactively | |
| An Important Note about Route Observables | |
| Passing Query Parameters and Fragments | |
| Retrieving Query Parameters and Fragments | |
| Practicing and some Common Gotchas | |
| Setting up Child (Nested) Routes | |
| Using Query Parameters - Practice | |
| Configuring the Handling of Query Parameters | |
| Redirecting and Wildcard Routes | |
| Important: Redirection Path Matching | |
| Outsourcing the Route Configuration | |
| An Introduction to Guards | |
| Protecting Routes with canActivate | |
| Protecting Child (Nested) Routes with canActivateChild | |
| Using a Fake Auth Service | |
| Controlling Navigation with canDeactivate | |
| Passing Static Data to a Route | |
| Resolving Dynamic Data with the resolve Guard | |
| Understanding Location Strategies | |
| Wrap Up |
| Planning the General Structure | |
| Setting Up Routes | |
| Adding Navigation to the App | |
| Marking Active Routes | |
| Fixing Page Reload Issues | |
| Child Routes: Challenge | |
| Adding Child Routing Together | |
| Configuring Route Parameters | |
| Passing Dynamic Parameters to Links | |
| Styling Active Recipe Items | |
| Adding Editing Routes | |
| Retrieving Route Parameters | |
| Programmatic Navigation to the Edit Page | |
| One Note about Route Observables | |
| Project Cleanup |
| Module Introduction | |
| Install RxJS | |
| Analyzing Angular Observables | |
| Getting Closer to the Core of Observables | |
| Building a Custom Observable | |
| Errors & Completion | |
| Observables & You! | |
| Understanding Operators | |
| Subjects | |
| Wrap Up | |
| Useful Resources & Links |
| Improving the Reactive Service with Observables (Subjects) | |
| Changed the Subscription Name |
| Module Introduction | |
| Why do we Need Angular's Help? | |
| Template-Driven (TD) vs Reactive Approach | |
| An Example Form | |
| TD: Creating the Form and Registering the Controls | |
| TD: Submitting and Using the Form | |
| TD: Understanding Form State | |
| TD: Accessing the Form with @ViewChild | |
| TD: Adding Validation to check User Input | |
| Built-in Validators & Using HTML5 Validation | |
| TD: Using the Form State | |
| TD: Outputting Validation Error Messages | |
| TD: Set Default Values with ngModel Property Binding | |
| TD: Using ngModel with Two-Way-Binding | |
| TD: Grouping Form Controls | |
| TD: Handling Radio Buttons | |
| TD: Setting and Patching Form Values | |
| TD: Using Form Data | |
| TD: Resetting Forms | |
| Practicing Template-Driven Forms | |
| Introduction to the Reactive Approach | |
| Reactive: Setup | |
| Reactive: Creating a Form in Code | |
| Reactive: Syncing HTML and Form | |
| Reactive: Submitting the Form | |
| Reactive: Adding Validation | |
| Reactive: Getting Access to Controls | |
| Reactive: Grouping Controls | |
| Fixing a Bug | |
| Reactive: Arrays of Form Controls (FormArray) | |
| Reactive: Creating Custom Validators | |
| Reactive: Using Error Codes | |
| Reactive: Creating a Custom Async Validator | |
| Reactive: Reacting to Status or Value Changes | |
| Reactive: Setting and Patching Values | |
| Practicing Reactive Forms | |
| [OPTIONAL] Assignment Solution |
| Introduction | |
| TD: Adding the Shopping List Form | |
| Adding Validation to the Form | |
| Allowing the Selection of Items in the List | |
| Loading the Shopping List Items into the Form | |
| Updating existing Items | |
| Resetting the Form | |
| Allowing the the User to Clear (Cancel) the Form | |
| Allowing the Deletion of Shopping List Items | |
| Creating the Template for the (Reactive) Recipe Edit Form | |
| Creating the Form For Editing Recipes | |
| Syncing HTML with the Form | |
| Fixing a Bug | |
| Adding Ingredient Controls to a Form Array | |
| Adding new Ingredient Controls | |
| Validating User Input | |
| Submitting the Recipe Edit Form | |
| Adding a Delete and Clear (Cancel) Functionality | |
| Redirecting the User (after Deleting a Recipe) | |
| Adding an Image Preview | |
| Providing the Recipe Service Correctly | |
| Deleting Ingredients and Some Finishing Touches | |
| Deleting all Items in a FormArray |
| Introduction & Why Pipes are Useful | |
| Using Pipes | |
| Parametrizing Pipes | |
| Where to learn more about Pipes | |
| Chaining Multiple Pipes | |
| Creating a Custom Pipe | |
| Parametrizing a Custom Pipe | |
| Example: Creating a Filter Pipe | |
| Pure and Impure Pipes (or: How to "fix" the Filter Pipe) | |
| Understanding the "async" Pipe | |
| Practicing Pipes |
| A New IDE | |
| Module Introduction | |
| How Does Angular Interact With Backends? | |
| The Anatomy of a Http Request | |
| Backend (Firebase) Setup | |
| Sending a POST Request | |
| GETting Data | |
| Using RxJS Operators to Transform Response Data | |
| Using Types with the HttpClient | |
| Outputting Posts | |
| Showing a Loading Indicator | |
| Using a Service for Http Requests | |
| Services & Components Working Together | |
| Sending a DELETE Request | |
| Handling Errors | |
| Using Subjects for Error Handling | |
| Using the catchError Operator | |
| Error Handling & UX | |
| Setting Headers | |
| Adding Query Params | |
| Observing Different Types of Responses | |
| Changing the Response Body Type | |
| Introducing Interceptors | |
| Manipulating Request Objects | |
| Response Interceptors | |
| Multiple Interceptors | |
| Wrap Up | |
| Useful Resources & Links |
| Module Introduction | |
| Backend (Firebase) Setup | |
| Setting Up the DataStorage Service | |
| Storing Recipes | |
| Fetching Recipes | |
| Transforming Response Data | |
| Resolving Data Before Loading | |
| Fixing a Bug with the Resolver |
| Module Introduction | |
| How Authentication Works | |
| Adding the Auth Page | |
| Switching Between Auth Modes | |
| Handling Form Input | |
| Preparing the Backend | |
| Make sure you got Recipes in your backend! | |
| Preparing the Signup Request | |
| Sending the Signup Request | |
| Adding a Loading Spinner & Error Handling Logic | |
| Improving Error Handling | |
| Sending Login Requests | |
| Login Error Handling | |
| Creating & Storing the User Data | |
| Reflecting the Auth State in the UI | |
| Adding the Token to Outgoing Requests | |
| Attaching the Token with an Interceptor | |
| Adding Logout | |
| Adding Auto-Login | |
| Adding Auto-Logout | |
| Adding an Auth Guard | |
| Wrap Up | |
| Useful Resources & Links |
| Module Introduction | |
| Adding an Alert Modal Component | |
| Understanding the Different Approaches | |
| Using ngIf | |
| Preparing Programmatic Creation | |
| Creating a Component Programmatically | |
| About entryComponents | |
| Understanding entryComponents | |
| Data Binding & Event Binding | |
| Wrap Up | |
| Useful Resources & Links |
| Module Introduction | |
| What are Modules? | |
| Analyzing the AppModule | |
| Getting Started with Feature Modules | |
| Splitting Modules Correctly | |
| Adding Routes to Feature Modules | |
| Component Declarations | |
| The ShoppingList Feature Module | |
| Understanding Shared Modules | |
| Understanding the Core Module | |
| Adding an Auth Feature Module | |
| Understanding Lazy Loading | |
| Implementing Lazy Loading | |
| More Lazy Loading | |
| Preloading Lazy-Loaded Code | |
| Modules & Services | |
| Loading Services Differently | |
| Useful Resources & Links |
| Module Introduction | |
| Starting Setup & Why We Want Standalone Components | |
| Building a First Standalone Component | |
| Standalone Components Are Now Stable | |
| Standalone Directives & Connecting Building Blocks | |
| Migrating Another Component | |
| A Standalone Root Component | |
| Services & Standalone Components | |
| Routing with Standalone Components | |
| Lazy Loading | |
| Summary |
| Module Introduction | |
| Signals: What & Why? | |
| Creating a New Signal | |
| Updating a Signal Value | |
| Reading & Outputting a Signal Value | |
| Signal Updating: set(), update() & mutate() | |
| Important: Signals are NOT Finished Yet! | |
| Signals: What's To Come? | |
| Computed Values & Effects | |
| Module Summary |
| Module Introduction | |
| What Is NgRx? | |
| Understanding NgRx & Its Building Blocks | |
| Project Setup & Installing NgRx | |
| Adding a First Reducer & Store Setup | |
| An Alternative Way Of Creating Reducers | |
| Reading Data From The Store | |
| Introducing Actions & State Changing Reducers | |
| Dispatching Actions | |
| Attaching Data To Actions | |
| Handling Actions Without createReducer | |
| An Alternative Way Of Defining Actions | |
| Time To Practice: A Second Action | |
| Exploring Selectors | |
| Introducing Effects | |
| Installing the Effects Package | |
| Defining a First Effect | |
| The Old @Effect Decorator & Registering Effects | |
| Using Store Data In Effects | |
| Adding a Second Effect | |
| Summary | |
| NgRx - The Old Syntax |
| Making Animations Work with Angular 4+ | |
| Introduction | |
| Setting up the Starting Project | |
| Animations Triggers and State | |
| Switching between States | |
| Transitions | |
| Advanced Transitions | |
| Transition Phases | |
| The "void" State | |
| Using Keyframes for Animations | |
| Grouping Transitions | |
| Using Animation Callbacks |
| Module Introduction | |
| Adding Service Workers | |
| Caching Assets for Offline Use | |
| Caching Dynamic Assets & URLs | |
| Further Links & Resources |
| About this Section | |
| Introduction | |
| Why Unit Tests? | |
| Analyzing the Testing Setup (as created by the CLI) | |
| Running Tests (with the CLI) | |
| Adding a Component and some fitting Tests | |
| Testing Dependencies: Components and Services | |
| Simulating Async Tasks | |
| Using "fakeAsync" and "tick" | |
| Isolated vs Non-Isolated Tests | |
| Further Resources & Where to Go Next |
| Module Introduction | |
| A Closer Look at "ng new" | |
| IDE & Project Setup | |
| Understanding the Config Files | |
| Important CLI Commands | |
| The "angular.json" File - A Closer Look | |
| Angular Schematics - An Introduction | |
| The "ng add" Command | |
| Using Custom "ng generate" Schematics | |
| Smooth Updating of Projects with "ng update" | |
| Simplified Deployment with "ng deploy" | |
| Understanding "Differential Loading" | |
| Managing Multiple Projects in One Folder | |
| Angular Libraries - An Introduction | |
| Wrap Up |
| Module Introduction | |
| What & Why? | |
| Installing & Using TypeScript | |
| Base Types & Primitives | |
| Array & Object Types | |
| Type Inference | |
| Working with Union Types | |
| Assigning Type Aliases | |
| Diving into Functions & Function Types | |
| Understanding Generics | |
| Classes & TypeScript | |
| Working with Interfaces | |
| Configuring the TypeScript Compiler | |
| Module Resources |
Learning Modules
| Join our Online Learning Community | |
| Course Setup |
| Module Introduction | |
| Starting Project | |
| Adding JavaScript To A Page & How React Projects Differ | |
| React Projects Use a Build Process | |
| "import" & "export" | |
| Revisiting Variables & Values | |
| Revisiting Operators | |
| Revisiting Functions & Parameters | |
| Exercise: Working with Functions | |
| Arrow Functions | |
| More on the Arrow Function Syntax | |
| Revisiting Objects & Classes | |
| Arrays & Array Methods like map() | |
| Exercise: Array Methods | |
| Destructuring | |
| Destructuring in Function Parameter Lists | |
| The Spread Operator | |
| Revisiting Control Structures | |
| Manipulating the DOM - Not With React! | |
| Using Functions as Values | |
| Defining Functions Inside Of Functions | |
| Reference vs Primitive Values | |
| Next-Gen JavaScript - Summary | |
| JS Array Functions | |
| Module Resources |
| Module Introduction | |
| It's All About Components! [Core Concept] | |
| Setting Up The Starting Project | |
| JSX & React Components [Core Concept] | |
| Creating & Using a First Custom Component | |
| A Closer Look: Components & File Extensions | |
| Building & Using a Component | |
| How React Handles Components & How It Builds A "Component Tree" [Core Concept] | |
| Components & JSX | |
| Using & Outputting Dynamic Values [Core Concept] | |
| Setting HTML Attributes Dynamically & Loading Image Files | |
| Outputting Dynamic Content | |
| Making Components Reusable with Props [Core Concept] | |
| Alternative Props Syntaxes | |
| More Prop Syntaxes | |
| Working with Props | |
| Dynamic Values & Props | |
| Best Practice: Storing Components in Files & Using a Good Project Structure | |
| Storing Component Style Files Next To Components | |
| Component Composition: The special "children" Prop [Core Concept] | |
| Component Composition | |
| Reacting to Events [Core Concept] | |
| Passing Functions as Values to Props | |
| Reacting to Events | |
| Passing Custom Arguments to Event Functions | |
| Configuring Event Handlers | |
| Best Practices & Event Handling | |
| How NOT to Update the UI - A Look Behind The Scenes of React [Core Concept] | |
| Managing State & Using Hooks [Core Concept] | |
| Working with State | |
| Deriving & Outputting Data Based on State | |
| State & Computed Values | |
| Rendering Content Conditionally | |
| Conditional Content | |
| CSS Styling & Dynamic Styling | |
| Dynamic Styling | |
| Outputting List Data Dynamically | |
| Dynamic List Content | |
| Conditional Content & Dynamic Lists | |
| Module Summary |
| Module Introduction | |
| You Don't Have To Use JSX! | |
| Working with Fragments | |
| Using Fragments | |
| When Should You Split Components? | |
| Splitting Components By Feature & State | |
| Problem: Props Are Not Forwarded To Inner Elements | |
| Forwarding Props To Wrapped Elements | |
| Forwarding Props | |
| Working with Multiple JSX Slots | |
| Setting Component Types Dynamically | |
| Setting Default Prop Values | |
| Creating Flexible Components | |
| Onwards To The Next Project & Advanced Concepts | |
| Not All Content Must Go Into Components | |
| Closer Look: public/ vs assets/ for Image Storage | |
| New Project: First Steps Towards Our Tic-Tac-Toe Game | |
| Concept Repetition: Splitting Components & Building Reusable Components | |
| Concept Repetition: Working with State | |
| Component Instances Work In Isolation! | |
| Conditional Content & A Suboptimal Way Of Updating State | |
| Best Practice: Updating State Based On Old State Correctly | |
| User Input & Two-Way-Binding | |
| Two-Way-Binding | |
| Rendering Multi-Dimensional Lists | |
| Best Practice: Updating Object State Immutably | |
| Lifting State Up [Core Concept] | |
| Avoid Intersecting States! | |
| Prefer Computed Values & Avoid Unnecessary State Management | |
| Deriving State From Props | |
| Sharing State Across Components | |
| Reducing State Management & Identifying Unnecessary State | |
| Disabling Buttons Conditionally | |
| Outsourcing Data Into A Separate File | |
| Lifting Computed Values Up | |
| Deriving Computed Values From Other Computed Values | |
| Tic-Tac-Toe Game: The "Game Over" Screen & Checking for a Draw | |
| Why Immutability Matters - Always! | |
| When NOT To Lift State Up | |
| An Alternative To Lifting State Up | |
| Final Polishing & Improving Components |
| Module Introduction & A Challenge For You! | |
| Adding a Header Component | |
| Getting Started with a User Input Component | |
| Handling Events & Using Two-Way-Binding | |
| Lifting State Up | |
| Computing Values & Properly Handling Number Values | |
| Outputting Results in a List & Deriving More Values | |
| Outputting Content Conditionally |
| Module Introduction & Starting Project | |
| Splitting CSS Code Across Multiple Files | |
| Styling React Apps with Vanilla CSS - Pros & Cons | |
| Vanilla CSS Styles Are NOT Scoped To Components! | |
| Styling React Apps with Inline Styles | |
| Dynamic & Conditional Inline Styles | |
| Dynamic Styling with Inline Styles | |
| Dynamic & Conditional Styling with CSS Files & CSS Classes | |
| Dynamic Styling with CSS Classes | |
| Scoping CSS Rules with CSS Modules | |
| Introducing "Styled Components" (Third-party Package) | |
| Creating Flexible Components with Styled Components | |
| Dynamic & Conditional Styling with Styled Components | |
| Styled Components: Pseudo Selectors, Nested Rules & Media Queries | |
| Creating Reusable Components & Component Combinations | |
| Introducing Tailwind CSS For React App Styling | |
| Tailwind 3 vs 4 | |
| Adding & Using Tailwind CSS In A React Project | |
| Tailwind: Media Queries & Pseudo Selectors | |
| Dynamic & Conditional Styling with Tailwind | |
| Migrating The Demo App to Tailwind CSS | |
| Tailwind CSS: Pros & Cons | |
| Exercise: Dynamic Styles |
| Module Introduction | |
| The Starting Project | |
| Understanding React Error Messages | |
| Using the Browser Debugger & Breakpoints | |
| Understanding React's "Strict Mode" | |
| Using the React DevTools (Browser Extension) | |
| Exercise: Fix Errors |
| Module Introduction & Starting Project | |
| Repetition: Managing User Input with State (Two-Way-Binding) | |
| Repetition: Fragments | |
| Introducing Refs: Connecting & Accessing HTML Elements via Refs | |
| Manipulating the DOM via Refs | |
| Accessing DOM Elements with "refs" | |
| Refs vs State Values | |
| Adding Challenges to the Demo Project | |
| Setting Timers & Managing State | |
| Using Refs for More Than "DOM Element Connections" | |
| Managing Other Values with Refs | |
| Adding a Modal Component | |
| Forwarding Refs to Custom Components | |
| Forwarding Refs | |
| Exposing Component APIs via the useImperativeHandle Hook | |
| Exposing Component APIs | |
| More Examples: When To Use Refs & State | |
| Sharing State Across Components | |
| Enhancing the Demo App "Result Modal" | |
| Closing the Modal via the ESC (Escape) Key | |
| Introducing & Understanding "Portals" | |
| Working with Portals |
| Module Introduction & Starting Project | |
| Adding a "Projects Sidebar" Component | |
| Styling the Sidebar & Button with Tailwind CSS | |
| Adding the "New Project" Component & A Reusable "Input" Component | |
| Styling Buttons & Inputs with Tailwind CSS | |
| Splitting Components to Split JSX & Tailwind Styles (for Higher Reusability) | |
| Managing State to Switch Between Components | |
| Collecting User Input with Refs & Forwarded Refs | |
| Handling Project Creation & Updating the UI | |
| Validating User Input & Showing an Error Modal via useImperativeHandle | |
| Styling the Modal via Tailwind CSS | |
| Making Projects Selectable & Viewing Project Details | |
| Handling Project Deletion | |
| Adding "Project Tasks" & A Tasks Component | |
| Managing Tasks & Understanding Prop Drilling | |
| Clearing Tasks & Fixing Minor Bugs |
| Module Introduction | |
| Understanding Prop Drilling & Project Overview | |
| Prop Drilling: Component Composition as a Solution | |
| Introducing the Context API | |
| Creating & Providing The Context | |
| Consuming the Context | |
| Linking the Context to State | |
| A Different Way Of Consuming Context | |
| What Happens When Context Values Change? | |
| Migrating the Entire Demo Project to use the Context API | |
| Outsourcing Context & State Into a Separate Provider Component | |
| Creating & Using Context | |
| Introducing the useReducer Hook | |
| Dispatching Actions & Editing State with useReducer | |
| Using useReducer() |
| Module Introduction & Starting Project | |
| What's a "Side Effect"? A Thorough Example | |
| A Potential Problem with Side Effects: An Infinite Loop | |
| Using useEffect for Handling (Some) Side Effects | |
| Not All Side Effects Need useEffect | |
| useEffect Not Needed: Another Example | |
| Preparing Another Use-Case For useEffect | |
| Using useEffect for Syncing With Browser APIs | |
| Understanding Effect Dependencies | |
| Fixing a Small Bug | |
| Preparing Another Problem That Can Be Fixed with useEffect | |
| Introducing useEffect's Cleanup Function | |
| The Problem with Object & Function Dependencies | |
| The useCallback Hook | |
| useEffect's Cleanup Function: Another Example | |
| Optimizing State Updates |
| Module Introduction & Starting Project | |
| A First Component & Some State | |
| Deriving Values, Outputting Questions & Registering Answers | |
| Shuffling Answers & Adding Quiz Logic | |
| Adding Question Timers | |
| Working with Effect Dependencies & useCallback | |
| Using Effect Cleanup Functions & Using Keys for Resetting Components | |
| Highlighting Selected Answers & Managing More State | |
| Splitting Components Up To Solve Problems | |
| Moving Logic To Components That Actually Need It ("Moving State Down") | |
| Setting Different Timers Based On The Selected Answer | |
| Outputting Quiz Results |
| Module Introduction | |
| React Builds A Component Tree / How React Works Behind The Scenes | |
| Analyzing Component Function Executions via React's DevTools Profiler | |
| Avoiding Component Function Executions with memo() | |
| Avoiding Component Function Executions with Clever Structuring | |
| Understanding the useCallback() Hook | |
| Understanding the useMemo() Hook | |
| React Uses A Virtual DOM - Time To Explore It! | |
| Why Keys Matter When Managing State! | |
| More Reasons For Why Keys Matter | |
| Using Keys For Resetting Components | |
| State Scheduling & Batching | |
| Optimizing React with MillionJS |
| Module Introduction | |
| What & Why | |
| Adding a First Class-based Component | |
| Working with State & Events | |
| The Component Lifecycle (Class-based Components Only!) | |
| Lifecycle Methods In Action | |
| Class-based Components & Context | |
| Class-based vs Functional Components: A Summary | |
| Introducing Error Boundaries | |
| Module Resources |
| Module Introduction | |
| How (Not) To Connect To A Database | |
| Starting Project & Dummy Backend API | |
| Preparing the App For Data Fetching | |
| How NOT To Send HTTP Requests (And Why It's Wrong) | |
| Sending HTTP Requests (GET Request) via useEffect | |
| Using async / await | |
| Handling Loading States | |
| Importing from Error.jsx | |
| Handling HTTP Errors | |
| Transforming Fetched Data | |
| Extracting Code & Improving Code Structure | |
| Sending Data with POST Requests | |
| Using Optimistic Updating | |
| Deleting Data (via DELETE HTTP Requests) | |
| Practice: Fetching Data |
| Module Introduction & Starting Project | |
| Revisiting the "Rules of Hooks" & Why To Use Hooks | |
| Creating a Custom Hook | |
| Custom Hook: Managing State & Returning State Values | |
| Exposing Nested Functions From The Custom Hook | |
| Using A Custom Hook in Multiple Components | |
| Creating Flexible Custom Hooks |
| Module Introduction & Starting Project | |
| What Are Forms & What's Tricky About Them? | |
| Handling Form Submission | |
| Managing & Getting User Input via State & Generic Handlers | |
| Getting User Input via Refs | |
| Getting Values via FormData & Native Browser APIs | |
| Resetting Forms | |
| Validating Input on Every Keystroke via State | |
| Validating Input Upon Lost Focus (Blur) | |
| Validating Input Upon Form Submission | |
| Validating Input via Built-in Validation Props | |
| Mixing Custom & Built-in Validation Logic | |
| Building & Using a Reusable Input Component | |
| Outsourcing Validation Logic | |
| Creating a Custom useInput Hook | |
| Using Third-Party Form Libraries |
| Module Introduction | |
| What are Form Actions? | |
| Adding Validation Checks | |
| Managing Form-dependent State with useActionState() | |
| Using User Input | |
| Moving the Action Function out of the Component | |
| A Demo App: Introduction | |
| Handling Form Submission | |
| Working with Asynchronous Form Actions | |
| Updating the UI with useFormStatus() | |
| Registering Multiple Form Actions | |
| Sending an HTTP Request via a Form Action | |
| Using the "pending" State from useActionState() | |
| Adding Optimistic Updating | |
| Module Summary |
| Module Introduction & Starting Project | |
| Planning the App & Adding a First Component | |
| Fetching Meals Data (GET HTTP Request) | |
| Adding a "MealItem" Component | |
| Formatting & Outputting Numbers as Currency | |
| Creating a Configurable & Flexible Custom Button Component | |
| Getting Started with Cart Context & Reducer | |
| Finishing & Using the Cart Context & Reducer | |
| Adding a Reusable Modal Component with useEffect | |
| Opening the Cart in the Modal via a New Context | |
| Working on the Cart Items | |
| Adding a Custom Input Component & Managing Modal Visibility | |
| Handling Form Submission & Validation | |
| Sending a POST Request with Order Data | |
| Adding a Custom HTTP Hook & Avoiding Common Errors | |
| Handling HTTP Loading & Error States | |
| Finishing Touches | |
| Migrating To Form Actions | |
| Managing Form Status with Form Actions |
| Module Introduction | |
| Another Look At State In React Apps | |
| Redux vs React Context | |
| How Redux Works | |
| MUST READ: Redux createStore() is (not) deprecated | |
| Exploring The Core Redux Concepts | |
| More Redux Basics | |
| Preparing a new Project | |
| Creating a Redux Store for React | |
| Providing the Store | |
| Using Redux Data in React Components | |
| Dispatching Actions From Inside Components | |
| Redux with Class-based Components | |
| Attaching Payloads to Actions | |
| Working with Multiple State Properties | |
| How To Work With Redux State Correctly | |
| Redux Challenges & Introducing Redux Toolkit | |
| Adding State Slices | |
| Connecting Redux Toolkit State | |
| Migrating Everything To Redux Toolkit | |
| Working with Multiple Slices | |
| Reading & Dispatching From A New Slice | |
| Splitting Our Code | |
| Summary |
| Module Introduction | |
| Redux & Side Effects (and Asynchronous Code) | |
| Refresher / Practice: Part 1/2 | |
| Refresher / Practice: Part 2/2 | |
| Using Firebase as a Backend | |
| Redux & Async Code | |
| Frontend Code vs Backend Code | |
| Where To Put Our Logic | |
| Using useEffect with Redux | |
| A Problem with useEffect() | |
| Handling Http States & Feedback with Redux | |
| Using an Action Creator Thunk | |
| Getting Started with Fetching Data | |
| Finalizing the Fetching Logic | |
| Exploring the Redux DevTools | |
| Summary |
| Module Introduction | |
| Routing: Multiple Pages in Single-Page Applications | |
| Project Setup & Installing React Router | |
| Defining Routes | |
| Adding a Second Route | |
| Exploring an Alternative Way of Defining Routes | |
| Navigating between Pages with Links | |
| Layouts & Nested Routes | |
| Showing Error Pages with errorElement | |
| Working with Navigation Links (NavLink) | |
| Navigating Programmatically | |
| Defining & Using Dynamic Routes | |
| Adding Links for Dynamic Routes | |
| Understanding Relative & Absolute Paths | |
| Working with Index Routes | |
| Onwards to a new Project Setup | |
| Time to Practice: Problem | |
| Time to Practice: Solution | |
| Data Fetching with a loader() | |
| Using Data From A Loader In The Route Component | |
| More loader() Data Usage | |
| Where Should loader() Code Be Stored? | |
| When Are loader() Functions Executed? | |
| Reflecting The Current Navigation State in the UI | |
| Returning Responses in loader()s | |
| Which Kind Of Code Goes Into loader()s? | |
| Error Handling with Custom Errors | |
| Extracting Error Data & Throwing Responses | |
| The json() Utility Function | |
| Dynamic Routes & loader()s | |
| The useRouteLoaderData() Hook & Accessing Data From Other Routes | |
| Planning Data Submission | |
| Working with action() Functions | |
| Submitting Data Programmatically | |
| Updating the UI State Based on the Submission Status | |
| Validating User Input & Outputting Validation Errors | |
| Reusing Actions via Request Methods | |
| Behind-the-Scenes Work with useFetcher() | |
| Deferring Data Fetching with defer() | |
| defer() and json() with React Router v7 | |
| Controlling Which Data Should Be Deferred | |
| Module Summary | |
| Module Resources | |
| Old Lectures |
| Module Introduction | |
| How Authentication Works | |
| Project Setup & Route Setup | |
| Working with Query Parameters | |
| Implementing the Auth Action | |
| Validating User Input & Outputting Validation Errors | |
| Adding User Login | |
| Attaching Auth Tokens to Outgoing Requests | |
| Adding User Logout | |
| Updating the UI Based on Auth Status | |
| Important: loader()s must return null or any other value | |
| Adding Route Protection | |
| Adding Automatic Logout | |
| Managing the Token Expiration | |
| Module Resources |
| Module Introduction | |
| Deployment Steps | |
| Understanding Lazy Loading | |
| Adding Lazy Loading | |
| Building the Code For Production | |
| Deployment Example | |
| Server-side Routing & Required Configuration |
| Module Introduction | |
| Project Setup & Overview | |
| React Query: What & Why? | |
| Installing & Using Tanstack Query - And Seeing Why It's Great! | |
| Understanding & Configuring Query Behaviors - Cache & Stale Data | |
| Dynamic Query Functions & Query Keys | |
| The Query Configuration Object & Aborting Requests | |
| Enabled & Disabled Queries | |
| Changing Data with Mutations | |
| Fetching More Data & Testing the Mutation | |
| Acting on Mutation Success & Invalidating Queries | |
| A Challenge! The Problem | |
| A Challenge! The Solution | |
| Disabling Automatic Refetching After Invalidations | |
| Enhancing the Demo App & Repeating Mutation Concepts | |
| React Query Advantages In Action | |
| Updating Data with Mutations | |
| Optimistic Updating | |
| Using the Query Key As Query Function Input | |
| React Query & React Router |
| Module Introduction | |
| Creating a NextJS Project | |
| Understanding File-based Routing & React Server Components | |
| Adding Another Route via the Filesystem | |
| Navigating Between Pages | |
| Working with Pages & Layouts | |
| Reserved File Names, Custom Components & How To Organize A NextJS Project | |
| Reserved Filenames | |
| Configuring Dynamic Routes & Using Route Parameters | |
| Onwards to the Main Project: The Foodies App | |
| Exercise: Your Task | |
| Exercise: Solution | |
| Revisiting The Concept Of Layouts | |
| Adding a Custom Component To A Layout | |
| Styling NextJS Project: Your Options & Using CSS Modules | |
| Optimizing Images with the NextJS Image Component | |
| Using More Custom Components | |
| Populating The Starting Page Content | |
| Preparing an Image Slideshow | |
| React Server Components vs Client Components - When To Use What | |
| Using Client Components Efficiently | |
| Outputting Meals Data & Images With Unknown Dimensions | |
| Setting Up A SQLite Database | |
| Fetching Data By Leveraging NextJS & Fullstack Capabilities | |
| Adding A Loading Page | |
| Using Suspense & Streamed Responses For Granular Loading State Management | |
| Handling Errors | |
| Handling "Not Found" States | |
| Loading & Rendering Meal Details via Dynamic Routes & Route Parameters | |
| Throwing Not Found Errors For Individual Meals | |
| Getting Started with the "Share Meal" Form | |
| Getting Started with a Custom Image Picker Input Component | |
| Adding an Image Preview to the Picker | |
| Improving the Image Picker Component | |
| Introducing & Using Server Actions for Handling Form Submissions | |
| Storing Server Actions in Separate Files | |
| Creating a Slug & Sanitizing User Input for XSS Protection | |
| Storing Uploaded Images & Storing Data in the Database | |
| Managing the Form Submission Status with useFormStatus | |
| Adding Server-Side Input Validation | |
| Working with Server Action Responses & useFormState | |
| Building For Production & Understanding NextJS Caching | |
| Triggering Cache Revalidations | |
| Don't Store Files Locally On The Filesystem! | |
| Bonus: Storing Uploaded Images In The Cloud (AWS S3) | |
| Adding Static Metadata | |
| Adding Dynamic Metadata | |
| Module Summary | |
| About the NextJS Pages Router | |
| Creating a NextJS Project | |
| Analyzing the Created Project | |
| Adding First Pages | |
| Adding Nested Paths & Pages (Nested Routes) | |
| Creating Dynamic Pages (with Parameters) | |
| Extracting Dynamic Parameter Values | |
| Linking Between Pages | |
| Onwards to a bigger Project! | |
| Preparing the Project Pages | |
| Outputting a List of Meetups | |
| Adding the New Meetup Form | |
| The "_app.js" File & Layout Wrapper | |
| Using Programmatic (Imperative) Navigation | |
| Adding Custom Components & CSS Modules | |
| How Pre-rendering Works & Which Problem We Face | |
| Data Fetching for Static Pages | |
| More on Static Site Generation (SSG) | |
| Exploring Server-side Rendering (SSR) with "getServerSideProps" | |
| Working with Params for SSG Data Fetching | |
| Preparing Paths with "getStaticPaths" & Working With Fallback Pages | |
| Introducing API Routes | |
| Working with MongoDB | |
| Sending Http Requests To Our API Routes | |
| Getting Data From The Database | |
| Getting Meetup Details Data & Preparing Pages | |
| Adding "head" Metadata | |
| Deploying Next.js Projects | |
| Using Fallback Pages & Re-deploying | |
| Summary | |
| Module Resources |
| Module Introduction | |
| Why We Need A Special Project Setup | |
| Understanding React Server Components | |
| Changing Server to Client Components | |
| Combining Server and Client Components | |
| Fetching Data with RSCs | |
| Submitting Data with Server Actions | |
| Using the use() Hook for Promises & Data Fetching | |
| The use() Hook In Action | |
| Handling Errors | |
| Theory Wrap Up |
| Module Introduction | |
| Project Setup & Overview | |
| Animating with CSS Transitions | |
| Animating with CSS Animations | |
| Introducing Framer Motion | |
| Framer Motion Basics & Fundamentals | |
| Animating Between Conditional Values | |
| Adding Entry Animations | |
| Animating Element Disappearances / Removal | |
| Making Elements "Pop" With Hover Animations | |
| Reusing Animation States | |
| Nested Animations & Variants | |
| Animating Staggered Lists | |
| Animating Colors & Working with Keyframes | |
| Imperative Animations | |
| Animating Layout Changes | |
| Orchestrating Multi-Element Animations | |
| Combining Animations With Layout Animations | |
| Animating Shared Elements | |
| Re-triggering Animations via Keys | |
| Scroll-based Animations |
| Module Introduction | |
| Project Overview | |
| Introducing Compound Components | |
| Managing Multi-Component State with the Context API | |
| Grouping Compound Components | |
| Adding Extra Components For Reusability & Configurability | |
| Sharing Cross-Component State When Working With Compound Components | |
| Introducing & Using Render Props | |
| Adding Search To A React App | |
| Implementing a Search Functionality With Help Of Render Props | |
| Handling Keys Dynamically | |
| Working with Debouncing |
| Module Introduction | |
| React 18 & This Section | |
| Starting Project & Why You Would Replace Redux | |
| Alternative: Using the Context API | |
| Toggling Favorites with the Context API | |
| Context API Summary (and why NOT to use it instead of Redux) | |
| Getting Started with a Custom Hook as a Store | |
| Finishing the Store Hook | |
| Creating a Concrete Store | |
| Using the Custom Store | |
| Custom Hook Store Summary | |
| Optimizing the Custom Hook Store | |
| Bonus: Managing Multiple State Slices with the Custom Store Hook | |
| Wrap Up | |
| Module Resources |
| Module Introduction | |
| What & Why? | |
| Understanding Different Kinds Of Tests | |
| What To Test & How To Test | |
| Understanding the Technical Setup & Involved Tools | |
| Running a First Test | |
| Writing Our First Test | |
| Grouping Tests Together With Test Suites | |
| Testing User Interaction & State | |
| Testing Connected Components | |
| Testing Asynchronous Code | |
| Working With Mocks | |
| Summary & Further Resources |
| Module Introduction | |
| What & Why? | |
| Installing & Using TypeScript | |
| Exploring the Base Types | |
| Working with Array & Object Types | |
| Understanding Type Inference | |
| Using Union Types | |
| Understanding Type Aliases | |
| Functions & Function Types | |
| Diving Into Generics | |
| A Closer Look At Generics | |
| Creating a React + TypeScript Project | |
| Working with Components & TypeScript | |
| Working with Props & TypeScript | |
| Adding a Data Model | |
| Time to Practice: Exercise Time! | |
| Form Submissions In TypeScript Projects | |
| Working with refs & useRef | |
| Working with "Function Props" | |
| Managing State & TypeScript | |
| Adding Styling | |
| Time to Practice: Removing a Todo | |
| The Context API & TypeScript | |
| Summary | |
| Bonus: Exploring tsconfig.json |
| Module Introduction | |
| What Is React & Why Would You Use It? | |
| React Projects - Requirements | |
| Creating React Projects | |
| Out Starting Project | |
| Understanding How React Works | |
| Building A First Custom Component | |
| Outputting Dynamic Values | |
| Reusing Components | |
| Passing Data to Components with Props | |
| CSS Styling & CSS Modules | |
| Exercise & Another Component | |
| Preparing the App For State Management | |
| Adding Event Listeners | |
| Working with State | |
| Lifting State Up | |
| The Special "children" Prop | |
| State & Conditional Content | |
| Adding a Shared Header & More State Management | |
| Adding Form Buttons | |
| Handling Form Submission | |
| Updating State Based On Previous State | |
| Outputting List Data | |
| Adding a Backend to the React SPA | |
| Sending a POST HTTP Request | |
| Handling Side Effects with useEffect() | |
| Handle Loading State | |
| Understanding & Adding Routing | |
| Adding Routes | |
| Working with Layout Routes | |
| Refactoring Route Components & More Nesting | |
| Linking & Navigating | |
| Data Fetching via loader()s | |
| Submitting Data with action()s | |
| Dynamic Routes | |
| Module Summary | |
| Module Resources |
| Course Roundup | |
| Bonus! |
| Course Update Overview, Explanation & Migration Guide | |
| Old Course Content Download |
| About these [BONUS / OPTIONAL] sections | |
| Module Introduction | |
| What Are Components? And Why Is React All About Them? | |
| React Code Is Written In A "Declarative Way"! | |
| Creating a new React Project | |
| The Starting Project | |
| Analyzing a Standard React Project | |
| Introducing JSX | |
| How React Works | |
| Exercise: Working with JSX Code | |
| Building a First Custom Component | |
| Exercise: Building a First Component | |
| Writing More Complex JSX Code | |
| Adding Basic CSS Styling | |
| Outputting Dynamic Data & Working with Expressions in JSX | |
| Passing Data via "props" | |
| Time to Practice: React & Component Basics | |
| Exercise: Passing Data via "props" | |
| Alternative Ways of Passing & Receiving / Handling "props" | |
| Adding "normal" JavaScript Logic to Components | |
| Splitting Components Into Multiple Components | |
| The Concept of "Composition" ("children props") | |
| Exercise: Component Composition | |
| A First Summary | |
| A Closer Look At JSX | |
| Organizing Component Files | |
| An Alternative Function Syntax | |
| Learning Check: React Basics, Components, Props & JSX | |
| Module Resources |
| Module Introduction | |
| The Starting Project & Your Tasks | |
| Exercise Hints | |
| Outputting Key Concepts Data | |
| Identifying Possible Components | |
| Creating & Using a Custom Component | |
| Outsourcing Concept Items Into a Reusable Component | |
| Module Resources |
| Module Introduction | |
| Listening to Events & Working with Event Handlers | |
| Exercise: Listening to Events | |
| How Component Functions Are Executed | |
| Working with "State" | |
| Exercise: Working with "State" | |
| A Closer Look at the "useState" Hook | |
| State can be updated in many ways! | |
| Adding Form Inputs | |
| Listening to User Input | |
| Working with Multiple States | |
| Using One State Instead (And What's Better) | |
| Updating State That Depends On The Previous State | |
| Exercise: Using State with Form Inputs | |
| Exercise: Updating State Based On Older State | |
| Alternative: Creating A Shared Handler Function | |
| Handling Form Submission | |
| Adding Two-Way Binding | |
| Time to Practice: Working with Events & State | |
| Child-to-Parent Component Communication (Bottom-up) | |
| Lifting The State Up | |
| Derived / Computed State | |
| Learning Check: Working with Events & State | |
| Module Resources |
| Module Introduction | |
| Rendering Lists of Data | |
| Exercise: Rendering Lists of Data | |
| Using Stateful Lists | |
| Understanding "Keys" | |
| Outputting Conditional Content | |
| Exercise: Outputting Conditional Content | |
| Adding Conditional Return Statements | |
| Demo App: Adding a Chart | |
| Adding Dynamic Styles | |
| Wrap Up & Next Steps | |
| Fixing a Small Bug | |
| Learning Check: Outputting Lists & Conditional Content | |
| Module Resources |
| Module Introduction | |
| The First Practice Project & Your Tasks | |
| Exercise Hints | |
| Splitting the App Into Components | |
| Handling Events | |
| Managing State | |
| Lifting the State Up | |
| Outputting Results Conditionally | |
| Adding CSS Modules | |
| Fixing a Small Bug | |
| Introducing the Second Project | |
| Exercise Hints | |
| Adding a "User" Component | |
| Adding a re-usable "Card" Component | |
| Adding a re-usable "Button" Component | |
| Managing the User Input State | |
| Adding Validation & Resetting Logic | |
| Adding a Users List Component | |
| Managing a List Of Users via State | |
| Adding The "ErrorModal" Component | |
| Managing the Error State | |
| Module Resources |
Learning Modules
| What we are making in this Figma course | |
| Class project 01- Create your own brief | |
| Class project 01- Create your own brief |
| What is Lo Fi Wireframe vs High Fidelity in Figma | |
| Creating our design file & introducing frames in Figma |
| The basics of type & fonts in Figma | |
| Rectangles Circles Buttons Rounded corners in Figma | |
| How to use color in Figma | |
| Strokes plus updating color defaults in Figma | |
| Object editing and how to escape in Figma | |
| Scale vs Selection Tool in Figma | |
| Frames vs Groups in Figma | |
| Class project 02- Wireframe | |
| Class project 02- Wireframe | |
| Where to get Free icons for Figma | |
| Matching the stroke of our icons | |
| How to use Plugins in Figma for icons | |
| Class project 03 - Icons | |
| Class project 03 - Icons |
| How to use Pages in Figma |
| How to prototype in Figma | |
| Prototype animation and easing in Figma | |
| Testing on your phone with Figma Mirror | |
| Class project 04 - Testing on your phone | |
| Class project 04 - Testing on your phone |
| What is Smart Animation & delays in Figma | |
| Class project 05 - My first animation | |
| Class project 05 - My first animation |
| Sharing & Commenting on Figma file with Stakeholders | |
| Share editing with other UX designers in Figma |
| How I get inspiration for UX projects | |
| How to create a mood board in Figma | |
| Class Project 06 - Moodboard | |
| Class Project 06 - Moodboard |
| How to work with Columns & Grid in Figma |
| Tips Tricks Preferences and Weirdness in Figma |
| Color Inspiration & the eyedropper in Figma | |
| How to create a color palette in Figma | |
| How to make gradients in Figma | |
| How to create & use Color Styles in Figma | |
| Class Project 07 - Colors & Columns | |
| Class Project 07 - Colors & Columns |
| Font on Desktop vs Browser Figma | |
| What fonts can I use plus font pairing in Figma | |
| What common font sizes should I choose in web design | |
| How to make Character Styles in Figma | |
| Lorem ipsum & Placeholder text in Figma | |
| Useful things to know about text in Figma | |
| How fix missing fonts in Figma | |
| Class project 08 - Text | |
| Class project 08 - Text |
| Drawing tips and tricks in Figma | |
| Squircle buttons with ios rounded courses in Figma | |
| Boolean Union Subtract Intersect Exclude Pathfinder in Figma | |
| What is the difference Union vs Flatten Figma | |
| Class Project 09 - Making stuff | |
| Class Project 09 - Making stuff | |
| Smart Selection & Tidy up in Figma |
| Do I need to know Illustrator with Figma |
| Tips & tricks for using images in Figma | |
| Masking Cropping images in Figma | |
| Free image & plugin for Figma |
| Do you need Photoshop for UX Design in Figma? | |
| Class Project 10 - Images | |
| Class Project 10 - Images |
| Autolayout & Constraints | |
| Class project 11 - Buttons | |
| Class project 11 - Buttons | |
| Auto Layout for spacing | |
| How to use constraints in figma | |
| Combining Nested frames Auto Layout & Constraints in Figma | |
| Adding Text Box Autoheight to Autolayout in Figma | |
| Class Project 12 - Responsive Design | |
| Class Project 12 - Responsive Design | |
| Nice drop shadow & Inner drop shadow effects in Figma |
| Blur Layer & Background Blur & Image Blur in Figma | |
| How to make Neumorphic ui buttons in Figma | |
| Class project 13 - Effects | |
| Class project 13 - Effects |
| How to save locally & save history in Figma |
| What are components in Figma | |
| Updating & Changing & Resetting your components | |
| You can’t kill main components in Figma | |
| Where should you keep your main components in Figma | |
| Intro to the forward slash / naming convention in Figma | |
| Class Project 14 - Components | |
| Class Project 14 - Components |
| How to make component variants in Figma | |
| Another way to make variants in Figma | |
| How to make a Multi Dimensional Variant in Figma | |
| Class Project 15 - Variants | |
| Class Project 15 - Variants |
| How to make a form using variants in Figma | |
| Class Project 16 - Form | |
| Class Project 16 - Form | |
| Putting it all together in an desktop example |
| How to add a popup overlay modal in Figma | |
| How to make & prototype a tool tip in Figma | |
| What are Flows in Figma | |
| Slide in mobile nav menu overlay in Figma | |
| Class project 17 - Prototyping | |
| Class project 17 - Prototyping | |
| How to pin navigation to top in Figma | |
| How to make horizontal scrolling swipe in Figma | |
| Automatic scroll down the page to anchor point in Figma |
| What are Teams vs Projects vs Files in Figma |
| How do you use team libraries in Figma |
| The difference between animation & micro interactions | |
| Animation with custom easing in Figma | |
| Class Project 18 - My Second Animation | |
| Class Project 18 - My Second Animation | |
| How to make animated transitions in Figma | |
| Class Project 19 - Page transition | |
| Class Project 19 - Page transition | |
| Micro interactions using interactive components in Figma | |
| Micro interaction toggle switch in Figma | |
| Micro Interaction burger menu turned into cross in Figma | |
| Class Project 20 - Micro interaction | |
| Class Project 20 - Micro interaction |
| How to change the thumbnail for Figma Files |
| How to export Images out of Figma | |
| How to share you document with clients & stakeholders | |
| Talking to your developer early in the figma design process | |
| Sharing Figma with developers & engineers handoff | |
| What are the next level handoffs aka design systems | |
| Class Project 21 - Finish your design | |
| Class Project 21 - Finish your design |
| What next for you and Figma | |
| Continue learning with me! Links inside. |
Learning Modules
| Section-1 Quiz |
| HTML Tags | |
| Tag's Attributes | |
| Favicon in HTML Page | |
| History of HTML & HTML5 | |
| Introduction to HTML Article | |
| Section Conclusion | |
| Section-2 Quiz |
| Section Overview | |
| Heading | |
| Paragraph | |
| Different Formatting Tags | |
| HTML5 Heading Coding Exercise | |
| Download Section Exercise Files | |
| Section Conclusion | |
| Section-3 Quiz |
| Overview | |
| Blockquote Tag | |
| Short Quotation Tag | |
| Abbreviation Tag | |
| Address Tag | |
| Cite Tag | |
| Bi-directional Override Tag | |
| Section Conclusion | |
| Download Section Exercise Files | |
| Section-4 Quiz |
| Section Overview | |
| Internal Hyperlink | |
| External Hyperlink | |
| Email Hyperlink | |
| Pagejump Hyperlink or Bookmark Hyperlink | |
| Link Attribute | |
| Image as a Link | |
| Section Conclusion | |
| Download Section Exercise Files | |
| Section-5 Quiz |
| Section Overview | |
| Images in HTML | |
| Creating a Basic Webpage Exercise | |
| Download Section Exercise Files | |
| Section Conclusion | |
| Section-6 Quiz |
| Section Overview | |
| Block Level Tags | |
| Inline Level Tags | |
| Download Section Exercise Files | |
| Section Conclusion | |
| Section-7 Quiz |
| Section Overview | |
| Tables in HTML5 | |
| Download Section Exercise Files | |
| Section Conclusion | |
| Section-8 Quiz |
| Section Oveview | |
| Media in HTML5 | |
| Video Tag | |
| Audio Tag | |
| Embedding YouTube Videos in HTML5 Webpage | |
| Section Conclusion | |
| Download Section Exercise Files | |
| Section-9 Quiz |
| Section Overview | |
| Form and its Attributes | |
| Form Element | |
| Different Input Types | |
| Input Attributes | |
| Section Conclusion | |
| Download Section Exercise Files | |
| Section-10 Quiz |
| Section Overview | |
| What is CSS and Different types of CSS | |
| CSS Margins | |
| CSS Paddings | |
| CSS Borders | |
| Section Conclusion | |
| Download Section Exercise Files | |
| Section-11 Quiz |
| Section Overview | |
| Semantic Elements Part 1 | |
| Semantic Elements Part 2 | |
| Section Conclusion | |
| Download Section Exercise Files | |
| Section-12 Quiz |
| How to Make a Single Page Website - Sample Project | |
| Download Section Exercise Files | |
| Section-13 Quiz |
| Wrap Up |
Learning Modules
| Introduction Continued: Here is What You Will Learn In Our SASS & SCSS Course! | |
| How To Follow Along and Use This Course |
| Preprocessors | |
| Sass vs. SCSS |
| Setting Up Sublime Text 3 | |
| Installing Sass / SCSS | |
| A Quick Test | |
| Setting Up The Project Structure |
| Using Variables Correctly | |
| Variables |
| Partials | |
| Partials |
| Mixins in Sass | |
| Mixins | |
| Mixins with Arguments | |
| Mixins with Arguments | |
| Passing Content Into Mixins | |
| Mixins with Content Blocks |
| Imports in Sass | |
| Imports | |
| Practice Activity: A Mixin to Import Fonts |
| Nested Media Queries in Sass | |
| Nested Media Queries | |
| Practice Activity: Mixins & Media Queries |
| Basic Arithmetic & The Sass Shell | |
| Color Arithmetic | |
| Arithmetic in Sass |
| What Are Functions? | |
| Built-in Functions | |
| Creating Your Own Functions | |
| Sass Functions |
| Inheritance with @extend | |
| More About @extend (+ Sass placeholders) | |
| Do You Need It? @extend vs. @mixin | |
| Inheritance |
| Using the @if and @else Directives | |
| Practice Activity: @if Directives To Switch Themes | |
| Practice Activity: A Useful Mixin With @if | |
| Conditionals and the @if Directive |
| @for Loops | |
| @each Loops | |
| @while Loops | |
| Loops |
| An Overview of Susy, Breakpoint & Compass | |
| Installing the Toolkits & Frameworks | |
| Getting Started With Susy: Creating Your Own Grid System | |
| More About Susy: Border-Box-Sizing | |
| Mobile-First Design & Media Queries With Breakpoint | |
| Compass: Your Helper for Everything Else |
| Course Summary & Course Conclusion - A Short Overview of What We Have Learned | |
| A Special Bonus Lecture Exclusively For The Students Enrolling In This Course! |
Learning Modules
| Project Links | |
| Basic Environment Setup |
| Utility-First Example | |
| Working With Colors | |
| Container & Spacing | |
| Typography | |
| Width & Height | |
| Layout & Position | |
| Backgrounds & Shadows | |
| Borders & Border Radius | |
| Filters |
| Interactivity | |
| Breakpoint Classes & Media Queries | |
| Columns | |
| Flexbox | |
| Grid | |
| Transition & Transform | |
| Animation Classes & Keyframes | |
| Config & Customization | |
| Dark Mode |
| Create An Environment With Tailwind CLI | |
| Directives & Functions | |
| Optional - Webpack & PostCSS Environment |
| Mini-Project 1 - Email Subscribe Card | |
| Mini-Project 2 - Pricing Grids | |
| Mini-Project 3 - Product Modal | |
| Mini-Project 4 - Image Gallery | |
| Mini-Project 5 - Login Modal |
| Setup & Config | |
| Hero Section & Background Image | |
| 4 - Snippets Section & Using Directives | |
| Features Section & Items | |
| Supercharge Section | |
| References & Footer | |
| Deploy To Netlify |
| Setup & Config | |
| Hero With Desktop Navigation | |
| Feature Section | |
| Creations Section With Gradient Overlays | |
| Footer | |
| Hamburger Button & Animation | |
| Mobile Menu & JavaScript | |
| Deploy To Vercel |
| Setup & Config | |
| Navbar | |
| Hero Section | |
| Shorten Form & Links | |
| JavaScript Link Validation | |
| Feature Boxes | |
| CTA & Footer | |
| Mobile Menu |
| Setup & Config | |
| FIrst Box | |
| Remaining Boxes | |
| Add Grid Classes | |
| Line Clamp Plugin |
| Project Intro | |
| Setup & Config | |
| Header & Dark Mode Button | |
| JavaScript For Color Mode | |
| Hero Section | |
| Features & Productive Sections | |
| Testimonials & Early Access | |
| Smooth Scroll & Footer |
| Project Intro | |
| Setup & Config | |
| Navbar | |
| Hero Section | |
| Tabs & Panel Layout | |
| JavaScript For Tabs | |
| Download Boxes | |
| FAQ Accordion | |
| Newsletter & Footer | |
| Mobile Menu |
Learning Modules
| Console Commands and Multiline Statements | |
| Sources, Network, and Other Panels | |
| How to View Your Changes |
| Static Python SimpleServer | |
| Windows Server Setup |
| Introducing Snippets | |
| Applying Changes | |
| CSS History | |
| Experimental Chrome Features & Workspaces |
| The Various Style Editors | |
| Animations Editor |
| Using the Debugger in the Sources Panel | |
| Keyboard Shortcuts for Debugging | |
| The Call Stack |
| Finding Stuff | |
| Cookies and Local Storage with the Application Tab |
| Console Multiline and Asserts | |
| Miscellaneous Console Functions | |
| Console Profile & Dollar Shortcuts | |
| Console Styling |
| Types of Breakpoints | |
| Line of Code Breakpoints | |
| Conditional Breakpoints | |
| DOM and Network Breakpoints | |
| Event and Exception Breakpoints |
| Downloading From Codepen.io | |
| The Network Panel | |
| Improve page load speed with Audits & Lighthouse | |
| Security and HTTPS with NGrok |
| Introducing a Client Performance Example | |
| Performance / Timeline Tab | |
| Detecting Memory Leaks |
| Other Browsers, VM's and BrowserStack | |
| A Thank You and Common Questions |
Learning Modules
| Small Note about Github Repository |
| What is publicPath? | |
| Asset/inline Module Type | |
| General Asset Type | |
| Asset/source Module Type |
| Handling CSS With Webpack | |
| Handling SASS | |
| Using Latest JavaScript Features With Babel | |
| Experimental JavaScript Features |
| What Is Webpack Plugin? | |
| Minification of the Resulting Webpack Bundle | |
| Extracting CSS Into a Separate Bundle With mini-css-extract-plugin, Part 1 | |
| Extracting CSS Into a Separate Bundle, Part 2 | |
| Browser Caching | |
| How To Clean Dist Folder Before Generating New Bundles | |
| Generating HTML Files Automatically During Webpack Build Process | |
| Customizing Generated HTML Files | |
| Integration with Handlebars | |
| More Webpack Plugins |
| Introduction | |
| Mode | |
| Managing Webpack Config for Production and Development Use Cases | |
| Faster Development with webpack dev server | |
| Cleaning Up A Bit |
| Introduction | |
| Creating KiwiImage Component | |
| Code Splitting in Webpack: Multiple JS and CSS Bundles | |
| How To Generate Multiple HTML Files | |
| Extracting Common Dependencies While Code Splitting | |
| Setting Custom Options for Code Splitting | |
| How To Setup Development Environment For Multiple Page Application |
| How To Use Github Repository |
| Introduction | |
| Getting Code for Single Page Application | |
| Integrating Express Into Our Application | |
| Serving HTML Pages via Express | |
| Handling JS and CSS via Express | |
| Getting Code for Multiple Page Application | |
| Integrating Express.js Into A Multiple Page Application |
| Creating 2 Separate Applications, Part 1 | |
| Creating 2 Separate Applications, Part 2 | |
| Setting Up Module Federation | |
| Consuming Federated Modules | |
| Modules Are Loaded At Runtime | |
| Creating Micro Frontends | |
| Micro Frontends In Action, Part 1 | |
| Micro Frontends In Action, Part 2 | |
| Navigation Bar Component | |
| Nested Module Federation. Part 1 | |
| Nested Module Federation. Part 2 |
| Getting the Source Code | |
| Integration with jQuery |
| Configuring ESLint | |
| More hints about ESLint |
| Summary | |
| Bonus Lecture |
Learning Modules
| IMPORTANT | |
| Setting up the Development Environment for the Angular SSR In Depth Course | |
| Why Angular SSR? Performance Benefits | |
| Why Angular SSR? Social Media Crawlers | |
| Why Angular SSR? SEO or Search Engine Optimization |
| How To Add Server-Side Rendering to an Angular Application Using the Angular CLI | |
| Understanding the Angular Client and Server Applications | |
| Running Angular Server-Side Rendering in Production and Hot Reload Mode | |
| Understanding the Angular SSR Express Server | |
| Angular Server Side Rendering Hydration - What it it and how does it work? |
| Angular SSR Prerendering - How does it work? | |
| Angular SSR Prerendering - Angular Router Integration | |
| Angular SSR Dynamic Route Prerendering | |
| Angular SSR and SEO - Search Engine Optimization Introduction | |
| Angular SSR SEO - Setting a Custom Page Title And Meta Tags | |
| Angular SSR - Social Media Crawlers Support |
| What is an Application Shell? | |
| Application Shell Implementation - The appShellRender Custom Directive | |
| Application Shell - appShellRender Custom Structural Directive Implementation | |
| Application Shell - implementation Finished and Demo |
| State Transfer API - Section Introduction | |
| What is the Angular SSR State Transfer API? | |
| Reviewing the Course Component and the Course Resolver | |
| Transfering State from the Server to the Client with the State Transfer API | |
| Angular SSR State Transfer - Runtime Demo |
| Angular SSR Production Deployment - Introduction | |
| Preparing an Application for Deployment on Google App Engine for Node | |
| Angular SSR In Production - Final Demo |
| Bonus Lecture (Updated March 2025) | |
| Angular SSR In Depth Course - Conclusions and Key Takeaways |
Learning Modules
| What Is PHP? | |
| Setup PHP - MacOS | |
| Setup PHP - Windows | |
| Text Editor Setup |
| Variables | |
| Data Types | |
| String Concatenation | |
| Type Casting & Juggling | |
| Variables Challenge | |
| Arithmetic Operators & Functions | |
| String Functions | |
| Dates & Times |
| Intro To Arrays | |
| Array Functions | |
| Associative Arrays | |
| Multi-Dimensional Arrays | |
| Array Challenges | |
| Basic Loops | |
| Nested Loops | |
| Looping Through Arrays | |
| Multi-Dimensional Array Iteration | |
| Array & Loop Challenges |
| If Statements | |
| Conditional HTML Output | |
| Comparison & Logical Operators | |
| Conditionals In Loops - break & continue | |
| Activity: Dynamic Job Listings | |
| FizzBuzz Challenge | |
| Switch Statements | |
| Ternary Operator | |
| Null Coalescing Operator | |
| Names Challenge |
| Functions & Return Values | |
| Parameters & Arguments | |
| Global & Local Scope | |
| Constants | |
| Optional Type Declarations | |
| Activity: Job Listings Helper Functions | |
| Average Salary Challenge | |
| Anonymous Functions & Closures | |
| Callback Functions | |
| Arrow Functions | |
| Format Salary Refactor Challenge | |
| More Function Challenges |
| OOP Overview | |
| Access Modifiers, Getters & Setters | |
| Inheritence | |
| Static Members & Methods | |
| OOP Challenges | |
| Abstract Classes | |
| Interfaces |
| Overview Of Superglobals | |
| $_SERVER - Get Server Information | |
| Environment Variables & $GLOBALS | |
| $_GET - Data From Query Params | |
| $_POST - Data From Forms | |
| $_REQUEST - Superglobal | |
| Message Alert Challenge | |
| $_SESSION - Creating a Session | |
| $_COOKIE - Working With Cookies |
| An Intro To Databases | |
| MySQL Setup - MacOS | |
| MySQL Setup - Windows | |
| MySQL Shell & Making Queries | |
| MySQL Workbench & Database Setup | |
| Database Users & Privileges | |
| Connect With PDO | |
| Fetch Multiple Records | |
| Fetch Single Record | |
| Create Form & Insert Record | |
| Delete Records | |
| Edit Form & Update Records |
| Project Repo Link | |
| UI Theme Files | |
| Folder Setup | |
| Home View & Set Document Root | |
| Git Setup & Commit | |
| Split UI Into Partials | |
| Inspect Helper Functions | |
| Create a VERY Basic Router | |
| Create Views | |
| Separate Router Files |
| Project Database Setup - MySQL Workbench | |
| Database Class & Connection | |
| Query Method & Fetch Listings | |
| Pass Data To View | |
| Single Listing & Named Params | |
| Single Listing Display |
| Folder Structure Refactor | |
| Custom Autoloader | |
| Composer & PSR-4 Autoloader | |
| Namespaces | |
| Router Refactor For Controller Classes | |
| Controller Classes - Home & Listings | |
| ErrorController Class | |
| Handling Route Params | |
| Section Wrap |
| Validation Class | |
| Form Submission & Sanitizing Data | |
| Implement Validation | |
| Insert Listings Into Database | |
| Delete Listings | |
| Flash Messages | |
| Edit Form | |
| Update Listing |
| User Controller & Views | |
| Register Validation & Error Partial | |
| Register User | |
| Session Class & Set User | |
| Dynamic Navbar Links | |
| Logout & Clear Session | |
| Login Functionality | |
| Authorize Middleware | |
| Delete Authorization | |
| Flash Message Methods | |
| Update Authorization |
| Section Intro | |
| Listing Search Functionality |
| Hostinger Intro | |
| Hosting & Domain Setup | |
| Database Export - Local | |
| Database Import - Production | |
| Upload Website & Configure Files |
| Course Wrap Up |
Learning Modules
| Setting up your webhosting account (part 2) |
| Wordpress - why we need it and how to install it | |
| A brief tour of Wordpress | |
| Woocommerce - why we need it and how to install it | |
| A brief tour of Woocommerce | |
| The Storefront theme |
| Adding an 'About Us' and/or a 'Contact Us' page | |
| Terms & Conditions and a Privacy Policy |
| Adding a logo | |
| Creating a menu | |
| Product categories | |
| Adding a sub menu |
| Adding a simple product | |
| Adding a variable product |
| Clean up the main website pages | |
| Adding a sidebar & widget |
| Creating a static home page | |
| Homepage control | |
| A few words about images in general | |
| Adding a home page image slider | |
| A responsive design |
| Alidropship | |
| Woodropship |
| What is the customer account ? | |
| How to configure the customer account |
| Adding payment providers | |
| Paypal | |
| Stripe |
| Shipping zones & options | |
| Dealing with taxes |
| Backing up your site | |
| Wordfence | |
| SSL |
| Guarantees & credit card logos | |
| Let's get social | |
| Adding a Refund & Returns policy | |
| Adding product reviews | |
| Grasshopper |
| Let's take a breath ! | |
| Become a wordpress/woocommerce developer | |
| Build an ecommerce business | |
| Sum up |
| BONUS LECTURE - Don't miss out! |
Learning Modules
| Auto-Welcome Message | |
| Course Curriculum Overview | |
| Why Python? | |
| Course FAQs |
| Command Line Basics | |
| Running Python Code | |
| Getting the Notebooks and the Course Material | |
| Git and Github Overview (Optional) |
| Introduction to Python Data Types | |
| Numbers: Simple Arithmetic | |
| Numbers - FAQ | |
| Numbers Quiz | |
| Variable Assignments | |
| Introduction to Strings | |
| Quick Print Check | |
| Indexing and Slicing with Strings | |
| String Indexing | |
| String Slicing | |
| String Properties and Methods | |
| Strings -FAQ | |
| Strings Quiz | |
| Print Formatting with Strings | |
| Print Formatting FAQs | |
| Print Formatting | |
| Lists in Python | |
| Lists | |
| Lists - FAQ | |
| Lists Quiz | |
| Dictionaries in Python | |
| Dictionaries | |
| Dictionaries - FAQ | |
| Dictionaries Quiz | |
| Tuples with Python | |
| Tuples Quiz | |
| Sets in Python | |
| Sets | |
| Booleans in Python | |
| Sets and Booleans Quiz | |
| I/O with Basic Files in Python | |
| File I/O | |
| Resources for More Basic Practice | |
| Python Objects and Data Structures Assessment Test Overview | |
| Python Objects and Data Structures Assessment Test Solutions |
| Comparison Operators in Python | |
| Chaining Comparison Operators in Python with Logical Operators | |
| Comparison Operators Quiz |
| If Elif and Else Statements in Python | |
| While Loops in Python | |
| Useful Operators in Python | |
| List Comprehensions in Python | |
| Python Statements Test Overview | |
| Python Statements Test Solutions |
| Methods and the Python Documentation | |
| Introduction to Functions | |
| def Keyword | |
| Basics of Python Functions | |
| Logic with Python Functions | |
| Tuple Unpacking with Python Functions | |
| Interactions between Python Functions | |
| Overview of Quick Function Exercises #1-10 | |
| Quick Check on Solutions Link | |
| Functions #1: print Hello World | |
| Functions #2: print Hello Name | |
| Functions #3 - simple Boolean | |
| Functions #4 - using Booleans | |
| Functions #5: simple math | |
| Functions #6: is even | |
| Functions #7: is greater | |
| *args and **kwargs in Python | |
| Functions #8: *args | |
| Functions #9: pick evens | |
| Functions #10: skyline | |
| Function Practice Exercises - Overview | |
| Function Practice Exercises - Solutions | |
| Function Practice - Solutions Level One | |
| Function Practice - Solutions Level Two | |
| Function Exercise Solutions - Challenge Problem | |
| Lambda Expressions, Map, and Filter Functions | |
| Nested Statements and Scope | |
| Methods and Functions Homework Overview | |
| Methods and Functions Homework - Solutions |
| Introduction to Warm Up Project Exercises | |
| Displaying Information | |
| Accepting User Input | |
| Validating User Input | |
| Simple User Interaction | |
| First Python Milestone Project Overview | |
| Milestone Project Help | |
| Solution Overview for MileStone Project 1 - Part One | |
| Solution Overview for MileStone Project 1 - Part Two |
| Object Oriented Programming - Introduction | |
| Object Oriented Programming - Attributes and Class Keyword | |
| Object Oriented Programming - Class Object Attributes and Methods | |
| Object Oriented Programming - Inheritance and Polymorphism | |
| Object Oriented Programming - Special (Magic/Dunder) Methods | |
| Object Oriented Programming - Homework | |
| Object Oriented Programming - Homework Solutions | |
| Object Oriented Programming - Challenge Overview | |
| Object Oriented Programming - Challenge Solution |
| Pip Install and PyPi | |
| Modules and Packages | |
| __name__ and "__main__" |
| Errors and Exception Handling | |
| Errors and Exceptions Homework | |
| Errors and Exception Homework - Solutions | |
| Update for Pylint Users | |
| Pylint Overview | |
| Running tests with the Unittest Library |
| Introduction to Milestone Project 2 Section Warmup | |
| Card Class | |
| Deck Class | |
| Player Class | |
| Game Logic - Part One | |
| Game Logic - Part Two | |
| Game Logic - Part Three | |
| Milestone Project 2 Overview | |
| Solution Walkthrough - Card and Deck classes | |
| Solution Walkthrough - Hand and Chip Classes | |
| Solution Walkthrough - Functions for Game Play | |
| Solutions Walkthrough - Final Gameplay Script |
| Decorators with Python Overview | |
| Decorators Homework |
| Generators with Python | |
| Generators Homework Overview | |
| Generators Homework Solutions |
| Introduction to Advanced Python Modules | |
| Python Collections Module | |
| Opening and Reading Files and Folders (Python OS Module) | |
| Python Datetime Module | |
| Python Math and Random Modules | |
| Python Debugger | |
| Python Regular Expressions Part One | |
| Python Regular Expressions Part Two | |
| Python Regular Expressions Part Three | |
| Timing Your Python Code | |
| Zipping and Unzipping files with Python | |
| Advanced Python Module Puzzle - Overview | |
| Advanced Python Module Puzzle - Solution |
| Introduction to Web Scraping | |
| Setting Up Web Scraping Libraries | |
| Python Web Scraping - Grabbing a Title | |
| Python Web Scraping - Grabbing a Class | |
| Python Web Scraping - Grabbing an Image | |
| Python Web Scraping - Book Examples Part One | |
| Python Web Scraping - Book Examples Part Two | |
| Python Web Scraping - Exercise Solutions |
| Introduction to Images with Python | |
| Working with Images with Python | |
| Python Image Exercises - Overview | |
| Python Image Exercises - Solution |
| Introduction to PDFs and Spreadsheets with Python | |
| Working with CSV Files in Python | |
| Working with PDF Files in Python | |
| PDFs and Spreadsheets Python Puzzle Exercise | |
| PDFs and Spreadsheets Python Puzzle Exercise - Solutions |
| Introduction to Emails with Python | |
| Sending Emails with Python | |
| Receiving Emails with Python |
| Final Capstone Project |
| Advanced Numbers | |
| Advanced Strings | |
| Advanced Sets | |
| Advanced Dictionaries | |
| Advanced Lists | |
| Advanced Python Objects Assessment Test | |
| Advanced Python Objects Test - Solutions |
| Introduction to GUIs | |
| Quick note about ipywidgets | |
| Interact Functionality with GUIs | |
| GUI Widget Basics | |
| List of Possible Widgets | |
| Widget Styling and Layouts | |
| Example of what a Widget can do! |
| NOTE ABOUT THIS SECTION | |
| Objects and Data Structures Assessment - Solutions | |
| Comparison Operators | |
| Chained Comparison Operators |
| BONUS LECTURE |
Learning Modules
| What is a Dev Environment? (Your First Installation) | |
| If You're Unable to Install Local by Flywheel | |
| About The Recent Big Changes To WordPress |
| A Note About URLs / My Address Bar | |
| Creating a New Theme | |
| PHP Functions |
| The Famous "Loop" in WordPress | |
| Header & Footer | |
| Optional: If You Want To Skip To One of The Final Chapters In The Course... | |
| Convert Static HTML Template into WordPress (Part 1) | |
| Convert Static HTML Template into WordPress (Part 2) |
| Interior Page Template | |
| Parent & Children Pages | |
| To Echo or Not To Echo | |
| Menu of Child Page Links | |
| A Few Quick Edits / Improvements | |
| Navigation Menus | |
| Navigation Menus (Continued) |
| Blog Listing Page (index.php vs front-page.php) | |
| Blog Continued | |
| Blog Archives (archive.php) | |
| Custom Queries | |
| Blog: Few Quick Edits & Improvements |
| Custom Post Types | |
| Using The Modern Block Editor For Our Custom Post Type | |
| Displaying Custom Post Types | |
| Quick Timeout: Misc Updates | |
| Custom Fields | |
| A Note About the WordPress Post Edit Screen | |
| Ordering (Sorting) Custom Queries | |
| Manipulating Default URL Based Queries | |
| Past Events Page (Custom Query Pagination) |
| Creating Relationships Between Content | |
| Displaying Relationships (Front-End) | |
| Quick Program Edits |
| Quick Note About The Next Lesson | |
| Professors Post Type | |
| Featured Image (Post Thumbnail) | |
| Featured Image Sizes & Cropping | |
| Page Banner Dynamic Background Image |
| Note About PHP Warning In The Next Lesson | |
| Reduce Duplicate Code - Create Our Own Function | |
| Solution To "Undefined array key" Warnings | |
| Quick Fix For Page Banner Function | |
| Using Our "pageBanner" Function | |
| Reduce Duplication - "get_template_part()" |
| Getting Our Computer & Project Ready for JavaScript | |
| Important Note About The Next Lesson | |
| Optional: The Finished Product Of This Course: All In One Import File |
| Note About Google Maps JavaScript API | |
| Campus Post Type | |
| Campus Map on Front-End | |
| Campuses Continued | |
| Final Campus Details |
| Live Search | |
| Quick Note About The Next Lesson | |
| Open and Close Search Overlay | |
| Preventing the Text Field Suggestions Pop-up | |
| Keyboard Events in JavaScript | |
| Managing Time in JavaScript | |
| Waiting / Loading Spinner Icon |
| Quick Note About The Next Lesson | |
| Load WP Content with JS | |
| Generate HTML Based on JSON | |
| Conditional Logic Within Template Literal | |
| Quick Misc Edits | |
| Synchronous vs Asynchronous (Part 1) | |
| Synchronous vs Asynchronous (Part 2) |
| REST API: Add New Custom Field | |
| REST API: Add New Custom Route (URL) | |
| Create Your Own Raw JSON Data | |
| WP_Query and Keyword Searching | |
| Working With Multiple Post Types |
| 3 Column Layout for Search Overlay | |
| Custom Layout & JSON based on Post Type | |
| Quick Note About The Next Lesson | |
| Search Logic That's Aware of Relationships | |
| Search Logic That's Aware of Relationships (Part 2) | |
| Completing Our Search Overlay | |
| jQuery Free Live Search |
| Traditional WordPress Searching | |
| Traditional WordPress Searching (Part 2) |
| User Roles and Permissions | |
| Open Registration | |
| Open Registration (Part 2) |
| "My Notes" Feature | |
| "My Notes" Front-end Part 1 | |
| "My Notes" Front-end Part 2 | |
| Quick Note About The Next Lesson | |
| Delete Posts with the REST API | |
| Edit / Update Posts with the REST API | |
| Creating New Notes | |
| Creating New Notes (Part 2) | |
| Note Permissions and Security (Part 1) | |
| Note Permissions and Security (Part 2) | |
| Per-User Post Limit | |
| Quick Note About CSS | |
| jQuery Free My Notes |
| Let Users "Like" Content (Part 1) | |
| Let Users "Like" Content (Part 2) | |
| Creating Custom POST and DELETE Endpoints | |
| Programmatically Create a Post | |
| Enforce Limit of One Like Per User/Teacher Combo | |
| Don't Forget About The "isset" Solution | |
| Completing the LikeBox | |
| Reminder To Use "isset" In Our LikeBox HTML Output | |
| jQuery Free LikeBox |
| Going Live with Our Website | |
| The Different Web Hosts & Plans To Consider | |
| Installing WordPress On Our Live Site | |
| Migrate Local WP Site To Live Site | |
| Getting Started With Git | |
| How To Login Into Our Live Site With SSH | |
| Turn Live Site Into Git Host (Bare Repo) | |
| Passwordless SSH Login |
| Note About Making The Slideshow Dynamic | |
| Challenge: Make Homepage Slideshow Dynamic | |
| What Is WP-CLI? |
| Introduction to Plugin Development | |
| Let's Create Our First Plugin | |
| Adding a Settings Page For Our Plugin | |
| Settings API (Saving Settings Data) | |
| Finishing Our Settings Form | |
| Actually Counting the Words, Characters, and Read Time | |
| Translations / Localization (For PHP) | |
| Admin Sub-Menu | |
| Custom Admin Menu Icon | |
| Solution To Undefined Array Key Message In Next Lesson | |
| Alternative: Manually Handling Admin Form Submit | |
| Finishing Word Filter Plugin |
| Introduction to JavaScript Plugin Development | |
| Introduction to JSX | |
| Block Type Attributes | |
| Let's Discuss the Output of Our Block (Part 1) | |
| Let's Discuss the Output of Our Block (Part 2) |
| Quick Note About Loading Block Asset Files | |
| Starting Our Multiple Choice Block Type | |
| Styling Our Block | |
| Event Handling & Updating Block Attributes | |
| Focus New Field For Immediate Typing | |
| Setting Up The Correct Answer | |
| If You're Using a Block Theme: Load Your JS In The Footer | |
| How To Use React on The Front-End of WordPress | |
| Passing Block Data From PHP Into JavaScript / React | |
| Letting Users Click On (Guess) An Answer | |
| Attention To Detail | |
| A Note About Animations / Transitions in React | |
| Let Admin Choose Background Color of Block | |
| Block Text Alignment & Block Preview | |
| Using The "block.json" File |
| Starting Our Featured Professor Plugin | |
| Loading a List of Professors | |
| Displaying Professor Info | |
| Professor Preview In Editor (Part 1) | |
| Professor Preview In Editor (Part 2) | |
| Control Post Meta With Block Type | |
| Add Related Posts to Professor Detail Page | |
| Translations / Localization (For JavaScript) |
| Understanding The Pros and Cons of the "Post" Paradigm | |
| Creating Our Own Custom Table | |
| Querying Our Table | |
| Building Dynamic Queries (Part 1) | |
| Quick Note About PHP Arrays | |
| PHP Warnings In The Next Lesson | |
| Building Dynamic Queries (Part 2) | |
| Reminder Of PHP Warning Solution | |
| Create Pet From Front-End | |
| Delete Pet From Front-End | |
| Converting Plugin To Be a Block Type Plugin Instead |
| Note About 2024 Block Best Practices | |
| What Is Full Site Editing? | |
| Important Note: theme.json File Needed | |
| Creating A Block Theme | |
| Where Should We Begin With Block Themes? | |
| Custom Banner Block (Part 1) | |
| Custom Banner Block (Part 2) | |
| Check For "isset" in Your Functions File | |
| Making Our Block Editable | |
| Generic Heading Block | |
| Finishing Generic Heading Block | |
| What Is "theme.json" In A Block Theme? (Part 1) | |
| What Is "theme.json" In A Block Theme? (Part 2) | |
| How To Disable Most Typography & Color Choices | |
| Custom Button Block (Part 1) | |
| Custom Button Block (Part 2) | |
| Color Picker For Button Block (Part 1) | |
| Color Picker For Button Block (Part 2) | |
| Quick Note About Link Chooser Popover | |
| Our PHP Render Approach | |
| User Uploaded Background Images (Part 1) | |
| About Undefined Array Key Warnings | |
| User Uploaded Background Images (Part 2) | |
| Reminder To Use "isset" In Our "banner.php" File | |
| Quick Details: Banner Block | |
| Events And Blogs Area (Part 1) | |
| Events And Blogs Area (Part 2) | |
| Header & Footer Blocks | |
| Slideshow Block (Part 1) | |
| Quick Note About isset() | |
| Slideshow Block (Part 2) | |
| Templates (Part 1) | |
| Quick Note About empty() | |
| Templates (Part 2) | |
| Note About The Next Several Lessons | |
| Single Page & Post Templates | |
| Don't Forget About Singular Content In Block Themes | |
| Remaining Templates | |
| Reminder To Use "isset" In Our "singleprofessor.php" File | |
| Only Allow Certain Block Types In Certain Editor Environments | |
| Quick Note About Custom Templates In The Next Lesson | |
| Creating A "Blank" Template For Landing Pages |
| The "Official" WordPress Block Dev Setup | |
| How To Setup Multiple Blocks | |
| Practice Makes Perfect | |
| Our Banner Block | |
| Slide & Slideshow Blocks | |
| Finishing Up | |
| Workflow Task Cleanup In package.json |
| What Is The Interactivity API? | |
| Creating Our Interactive Block | |
| What Is Context In The Interactivity API? | |
| Rendering HTML With The Interactivity API | |
| Automatically Convert PHP Data into JS Data | |
| Show Congrats & Sorry Based on Context | |
| Callbacks In The Interactivity API | |
| When To Use State Instead of Context |
| Challenge: Have an Update Plan in Place (Security) | |
| Challenge: Query Vars | |
| Finale: JavaScript Next Steps | |
| Bonus Lecture |
Learning Modules
| Code Download |
| Kafka Fundamentals |
| Theory Roundup | |
| Quiz on Theory |
| Important: Starting Kafka & Lectures Order | |
| FAQ for Setup Problems | |
| Mac OS X - Download and Setup Kafka in PATH | |
| Mac OS X - Start Zookeeper and Kafka | |
| Mac OS X - Using brew | |
| Linux - Download and Setup Kafka in PATH | |
| Linux - Start Zookeeper and Kafka | |
| Windows WSL2 - Download Kafka and PATH Setup | |
| Windows WSL2 - Start Zookeeper & Kafka | |
| Windows WSL2 - How to Fix Problems | |
| Windows WSL2 - Extra Instructions | |
| Windows non-WSL2 - Start Zookeeper and Kafka |
| Note: try out Kafka KRaft | |
| Mac OS X - Start Kafka in KRaft mode | |
| Linux - Start Kafka in KRaft mode | |
| Windows WSL2 - Start Kafka in KRaft mode |
| CLI Introduction | |
| WINDOWS WARNING: PLEASE READ | |
| Quiz on CLI |
| Kafka SDK List | |
| Creating Kafka Project | |
| Java Producer | |
| Java Producer Callbacks | |
| Java Producer with Keys | |
| Java Consumer | |
| Java Consumer - Graceful Shutdown | |
| Java Consumer inside Consumer Group | |
| Java Consumer Incremental Cooperative Rebalance & Static Group Membership | |
| Java Consumer Incremental Cooperative Rebalance - Practice | |
| Java Consumer Auto Offset Commit Behavior | |
| Programming - Advanced Tutorials | |
| Quiz on Java Programming 101 |
| Real World Project Overview | |
| Real World Exercise - Solution |
| IMPORTANT: Start Local Kafka with Conduktor using Docker | |
| Wikimedia Producer Project Setup | |
| Wikimedia Producer Implementation | |
| Wikimedia Producer Run | |
| Wikimedia Producer - Producer Config Intros | |
| Producer Acknowledgements Deep Dive | |
| Producer Retries | |
| Idempotent Producer | |
| Safe Kafka Producer Settings | |
| Wikimedia Producer Safe Producer Implementation | |
| Kafka Message Compression | |
| linger.ms and batch.size Producer settings | |
| Wikimedia Producer High Throughput Implementation | |
| Producer Default Partitioner & Sticky Partitioner | |
| [Advanced] max.block.ms and buffer.memory | |
| Quiz on Producer Configurations |
| OpenSearch Consumer - Project Overview | |
| OpenSearch Consumer - Project Setup | |
| Setting up OpenSearch on Docker | |
| Setting up OpenSearch on the Cloud | |
| OpenSearch 101 | |
| OpenSearch Consumer Implementation - Part 1 | |
| OpenSearch Consumer Implementation Part 2 | |
| Consumer Delivery Semantics | |
| OpenSearch Consumer Implementation Part 3 - Idempotence | |
| Consumer Offsets Commit Strategies | |
| OpenSearch Consumer Implementation Part 4 - Delivery Semantics | |
| OpenSearch Consumer Implementation Part 5 - Batching Data | |
| Consumer Offset Reset Behavior | |
| OpenSearch Consumer Implementation Part 6 - Replaying Data | |
| Consumer Internal Threads | |
| Consumer Replica Fetching - Rack Awareness | |
| Quiz on Consumer Configurations |
| Kafka Extended APIs - Overview | |
| Kafka Connect Introduction | |
| Kafka Connect Hands On: Warning | |
| Kafka Connect Wikimedia & ElasticSearch Hands On | |
| Kafka Streams Introduction | |
| Kafka Streams Hands-On | |
| Kafka Schema Registry Introduction | |
| Kafka Schema Registry Hands On | |
| Which Kafka API should I use? | |
| Quiz on Kafka Extended APIs |
| Choosing Partition Count & Replication Factor | |
| Kafka Topics Naming Convention | |
| Case Study - MovieFlix | |
| Case Study - GetTaxi | |
| Case Study - MySocialMedia | |
| Case Study - MyBank | |
| Case Study - Big Data Ingestion | |
| Case Study - Logging and Metrics Aggregation |
| Kafka Cluster Setup High Level Architecture Overview | |
| Kafka Monitoring & Operations | |
| Kafka Security | |
| Kafka Multi Cluster & MirrorMaker | |
| Advertised Listeners: Kafka Client & Server Communication Protocol |
| Advanced Kafka |
| Changing a Topic Configuration | |
| Segment and Indexes | |
| Log Cleanup Policies | |
| Log Cleanup Delete | |
| Log Compaction Theory | |
| Log Compaction Practice | |
| Unclean Leader Election | |
| Large Messages in Kafka |
| What's Next? | |
| THANK YOU! | |
| Bonus Lecture |
Learning Modules
| Slides and Code Download |
| RabbitMQ and Similar Products | |
| AMQP |
| Prerequisites | |
| Basic configuration and Installation Hands On | |
| Configuration | |
| Configuration file Hands On | |
| Plugins | |
| Plugins - Web Admin Hands On | |
| Web Admin Overview and Default User Password | |
| RabbitMQ RESTful API | |
| Exchanges, Queues, Bindings, Routing Keys | |
| First Queue and First Consumption Hands On |
| Common Patterns | |
| Patterns: Simple Queue Hands On | |
| Patterns: Work Queues / Task Queues Hands On | |
| Patterns: Publish / Subscribe based on Routing Hands On | |
| Patterns: Publish / Subscribe based on Topics Hands On | |
| Patterns: Publish / Subscribe based on Headers Hands On | |
| Patterns: RPC - Remote Procedure Call Hands On |
| Custom Exchanges - Consistent Hash Exchange | |
| Dead Letter Exchange (DLX) | |
| Delay Schedule, Delay Publication Model | |
| Data safety - Transactions & Publisher Confirms | |
| Vhosts | |
| Policies | |
| Lazy queues - memory optimization | |
| Priority Queues | |
| NT service |
| Overview | |
| Cluster Scale-Out Hands On | |
| Cluster Scale-In Hands On | |
| Shovels Hands On | |
| Federated Exchange Hands On | |
| Federated Queue Hands On | |
| Cluster, Federation, Shovel Summary | |
| Highly Available (Mirrored) Queues Hands On | |
| Quorum Queues Hands On | |
| Partitions Hands On |
| Tools | |
| PerfTest Hands On |
| Overview | |
| Collecting metrics | |
| Memory model | |
| Alarms |
| Overview | |
| Security - Permissions | |
| Security Hands On |
| Reliable system | |
| Backup & Restore | |
| Backup & Restore Hands On | |
| Upgrades | |
| Upgrades Hands On | |
| Tuning |
| Thank You! |
Learning Modules
| Course Resources | |
| Quiz - Data in Microservices | |
| Big Problems with Data | |
| Sync Communication Between Services | |
| Event-Based Communication | |
| A Crazy Way of Storing Data | |
| Pros and Cons of Async Communication |
| Important - Optional Boilerplate | |
| App Overview | |
| Project Setup | |
| Posts Service Creation | |
| Testing the Posts Service | |
| Implementing a Comments Service | |
| Quick Comments Test | |
| Note on the React App | |
| Addressing Default Export and ReactDom.render Warnings | |
| React Project Setup | |
| Building Post Submission | |
| Handling CORS Errors | |
| Fetching and Rendering Posts | |
| Creating Comments | |
| Displaying Comments | |
| Completed React App | |
| Request Minimization Strategies | |
| An Async Solution | |
| Common Questions Around Async Events | |
| Event Bus Overview | |
| Important Note about Node and Unhandled Promise Rejections | |
| A Basic Event Bus Implementation | |
| Emitting Events | |
| Emitting Comment Creation Events | |
| Receiving Events | |
| Creating the Data Query Service | |
| Parsing Incoming Events | |
| Using the Query Service | |
| Adding a Simple Feature | |
| Issues with Comment Filtering | |
| A Second Approach | |
| How to Handle Resource Updates | |
| Creating the Moderation Service | |
| Adding Comment Moderation | |
| Reminder about Error Catching | |
| Handling Moderation | |
| Updating Comment Content | |
| A Quick Test | |
| Rendering Comments by Status | |
| Dealing with Missing Events | |
| Required Error Handling Update for Query Service | |
| Implementing Event Sync | |
| Event Syncing in Action |
| Deployment Issues | |
| Why Docker? | |
| Why Kubernetes? | |
| Don't Know Docker? Watch This. | |
| Note About Docker Build Output and Buildkit | |
| Dockerizing the Posts Service | |
| Review Some Basic Commands | |
| Dockerizing Other Services |
| Warning on Docker Desktop for Linux | |
| Installing Kubernetes | |
| IMPORTANT Note for Minikube and MicroK8s Users | |
| A Kubernetes Tour | |
| Important Kubernetes Terminology | |
| Notes on Config Files | |
| Creating a Pod | |
| ErrImagePull, ErrImageNeverPull and ImagePullBackoff Errors | |
| Understanding a Pod Spec | |
| Common Kubectl Commands | |
| A Time-Saving Alias | |
| Introducing Deployments | |
| Creating a Deployment | |
| Common Commands Around Deployments | |
| Updating Deployments | |
| Preferred Method for Updating Deployments | |
| Networking With Services | |
| Creating a NodePort Service | |
| Accessing NodePort Services | |
| Setting Up Cluster IP Services | |
| Building a Deployment for the Event Bus | |
| Adding ClusterIP Services | |
| How to Communicate Between Services | |
| Updating Service Addresses | |
| Verifying Communication | |
| Adding Query, Moderation and Comments | |
| Testing Communication | |
| Load Balancer Services | |
| Load Balancers and Ingress | |
| Important - DO NOT SKIP - Ingress Nginx Installation Info | |
| Installing Ingress-Nginx | |
| Ingress v1 API Required Update + pathType Warning | |
| Writing Ingress Config Files | |
| Important Note About Port 80 | |
| Hosts File Tweak | |
| Important Note to Add Environment Variable | |
| Deploying the React App | |
| Unique Route Paths | |
| Final Route Config | |
| Introducing Skaffold | |
| Skaffold API version Update | |
| Skaffold Setup | |
| First Time Skaffold Startup | |
| A Few Notes on Skaffold |
| Big Ticket Items | |
| App Overview | |
| Resource Types | |
| Service Types | |
| Events and Architecture Design | |
| Note on Typescript | |
| Auth Service Setup | |
| Auth K8s Setup | |
| Adding Skaffold | |
| Note on Code Reloading | |
| Ingress v1 API Required Update | |
| Ingress-Nginx Setup | |
| Hosts File and Security Warning |
| Note on Remote Development | |
| Remote Dev with Skaffold | |
| Free Google Cloud Trial and Credits | |
| Google Cloud Initial Setup | |
| Kubernetes Cluster Creation with Autopilot | |
| Kubectl Contexts | |
| Initializing the GCloud SDK | |
| Installing the GCloud Context | |
| Updating the Skaffold Config | |
| More Skaffold Updates | |
| Creating a Load Balancer | |
| Final Config and Test |
| Creating Route Handlers | |
| Scaffolding Routes | |
| Adding Validation | |
| Handling Validation Errors | |
| Postman HTTPS Issues | |
| Surprising Complexity Around Errors | |
| Other Sources of Errors | |
| Solution for Error Handling | |
| Building an Error Handling Middleware | |
| Communicating More Info to the Error Handler | |
| Encoding More Information In an Error | |
| Subclassing for Custom Errors | |
| Determining Error Type | |
| Property 'param' does not exist on type 'AlternativeValidationError' | |
| Converting Errors to Responses | |
| Moving Logic Into Errors | |
| serializeErrors' not assignable to the same property in base type 'CustomError' | |
| Verifying Our Custom Errors | |
| Final Error Related Code | |
| How to Define New Custom Errors | |
| Uh Oh... Async Error Handling |
| Creating Databases in Kubernetes | |
| Connecting to MongoDB | |
| Understanding the Signup Flow | |
| Getting TypeScript and Mongoose to Cooperate | |
| Creating the User Model | |
| Type Checking User Properties | |
| Adding Static Properties to a Model | |
| Defining Extra Document Properties | |
| What's That Angle Bracket For? | |
| User Creation | |
| Proper Error Handling | |
| Note on Password Hashing | |
| Reminder on Password Hashing | |
| Adding Password Hashing | |
| Comparing Hashed Password | |
| Mongoose Pre-Save Hooks |
| Fundamental Authentication Strategies | |
| Huge Issues with Authentication Strategies | |
| So Which Option? | |
| Solving Issues with Option #2 | |
| Reminder on Cookies vs JWT's | |
| Microservices Auth Requirements | |
| Issues with JWT's and Server Side Rendering | |
| Cookies and Encryption | |
| Adding Session Support | |
| Generating a JWT | |
| JWT Signing Keys | |
| Securely Storing Secrets with Kubernetes | |
| Creating and Accessing Secrets | |
| Accessing Env Variables in a Pod | |
| Common Response Properties | |
| Formatting JSON Properties | |
| The Signin Flow | |
| Common Request Validation Middleware | |
| Sign In Logic | |
| Quick Sign In Test | |
| Current User Handler | |
| Returning the Current User | |
| Signing Out | |
| Creating a Current User Middleware | |
| Augmenting Type Definitions | |
| Requiring Auth for Route Access |
| Scope of Testing | |
| Testing Goals | |
| Testing Architecture | |
| Index to App Refactor | |
| Replacing --only=prod Install Flag | |
| A Few Dependencies | |
| Required MongoMemoryServer Updates | |
| Test Environment Setup | |
| Our First Test | |
| An Important Note | |
| Testing Invalid Input | |
| Requiring Unique Emails | |
| Changing Node Env During Tests | |
| Tests Around Sign In Functionality | |
| Cookie Request is Possibly Undefined Error | |
| Testing Sign Out | |
| Issues with Cookies During Testing | |
| No Overload Matches This Call Error with Cookie | |
| Easy Auth Solution | |
| globalThis has no index signature TS Error | |
| Auth Helper Function | |
| Testing Non-Authed Requests |
| Starting the React App | |
| Reminder on Server Side Rendering | |
| Suggestion Regarding a Default Export Warning | |
| Basics of Next JS | |
| Building a Next Image | |
| Running Next in Kubernetes | |
| Small Update for Custom Webpack Config | |
| Note on File Change Detection | |
| Adding Global CSS | |
| Adding a Sign Up Form | |
| Handling Email and Password Inputs | |
| Successful Account Signup | |
| Handling Validation Errors | |
| The useRequest Hook | |
| Using the useRequest Hook | |
| An onSuccess Callback | |
| Overview on Server Side Rendering | |
| A note about ECONNREFUSED errors | |
| Fetching Data During SSR | |
| Why the Error? | |
| Two Possible Solutions | |
| Cross Namespace Service Communication | |
| When is GetInitialProps Called? | |
| On the Server or the Browser | |
| Ingress-Nginx Namespace and Service - Important Update | |
| Specifying the Host | |
| Passing Through the Cookies | |
| A Reusable API Client | |
| Content on the Landing Page | |
| The Sign In Form | |
| A Reusable Header | |
| Moving GetInitialProps | |
| Issues with Custom App GetInitialProps | |
| Handling Multiple GetInitialProps | |
| Passing Props Through | |
| Error: Invalid with child | |
| Building the Header | |
| Conditionally Showing Links | |
| Signing Out | |
| React App Catchup & Checkpoint |
| Shared Logic Between Services | |
| Options for Code Sharing | |
| NPM Organizations | |
| Publishing NPM Modules | |
| Project Setup | |
| Typo in package.json "files" Field - Do Not Skip | |
| An Easy Publish Command | |
| Relocating Shared Code | |
| Updating Import Statements | |
| NPM Update Command | |
| Updating the Common Module |
| Ticketing Service Overview | |
| Project Setup | |
| Running the Ticket Service | |
| Mongo Connection URI | |
| Quick Auth Update | |
| Test-First Approach | |
| Creating the Router | |
| Adding Auth Protection | |
| Faking Authentication During Tests | |
| A Required Session Fix and a Global Signin Reminder | |
| Building a Session | |
| Testing Request Validation | |
| Validating Title and Price | |
| Reminder on Mongoose with TypeScript | |
| Defining the Ticket Model | |
| Creation via Route Handler | |
| Testing Show Routes | |
| Unexpected Failure! | |
| What's that Error?! | |
| Better Error Logging | |
| Complete Index Route Implementation | |
| Ticket Updating | |
| Handling Updates | |
| Permission Checking | |
| Final Update Changes | |
| Manual Testing |
| What Now? | |
| NATS Server Status - IMPORTANT NOTE | |
| Three Important Items | |
| Creating a NATS Streaming Deployment | |
| Big Notes on NATS Streaming | |
| Building a NATS Test Project | |
| Port-Forwarding with Kubectl | |
| Publishing Events | |
| Small Required Command Change | |
| Listening For Data | |
| Accessing Event Data | |
| Client ID Generation | |
| Queue Groups | |
| Manual Ack Mode | |
| Client Health Checks | |
| Graceful Client Shutdown | |
| Core Concurrency Issues | |
| Common Questions | |
| [Optional] More Possible Concurrency Solutions | |
| Solving Concurrency Issues | |
| Concurrency Control with the Tickets App | |
| Event Redelivery | |
| Durable Subscriptions |
| Reusable NATS Listeners | |
| The Listener Abstract Class | |
| Extending the Listener | |
| Quick Refactor | |
| Leveraging TypeScript for Listener Validation | |
| Subjects Enum | |
| Custom Event Interface | |
| Enforcing Listener Subjects | |
| Quick Note: 'readonly' in Typescript | |
| Enforcing Data Types | |
| Where Does this Get Used? | |
| Custom Publisher | |
| Using the Custom Publisher | |
| Awaiting Event Publication | |
| Common Event Definitions Summary | |
| Updating the Common Module | |
| Restarting NATS |
| Publishing Ticket Creation | |
| More on Publishing | |
| NATS Client Singleton | |
| Node Nats Streaming Installation | |
| Remember Mongoose? | |
| TS Error - Did you forget to include 'void' in your type argument | |
| Singleton Implementation | |
| Accessing the NATS Client | |
| Graceful Shutdown | |
| Successful Listen! | |
| Ticket Update Publishing | |
| Failed Event Publishing | |
| Handling Publish Failures | |
| Fixing a Few Tests | |
| Redirecting Imports | |
| Providing a Mock Implementation | |
| Test-Suite Wide Mocks | |
| Ensuring Mock Invocations | |
| NATS Env Variables |
| The Orders Service | |
| Scaffolding the Orders Service | |
| A Touch More Setup | |
| Ingress Routing Rules | |
| Scaffolding a Few Route Handlers | |
| Subtle Service Coupling | |
| Associating Orders and Tickets | |
| Order Model Setup | |
| The Need for an Enum | |
| Creating an Order Status Enum | |
| More on Mongoose Refs | |
| Defining the Ticket Model | |
| Order Creation Logic | |
| Finding Reserved Tickets | |
| Convenience Document Methods | |
| Order Expiration Times | |
| globalThis has no index signature TS Error | |
| Test Suite Setup | |
| Small Update for "Value of type 'typeof ObjectId' is not callable" | |
| Asserting Tickets Exist | |
| Asserting Reserved Tickets | |
| Testing the Success Case | |
| Fetching a User's Orders | |
| A Slightly Complicated Test | |
| Fetching Individual Orders | |
| Does Fetching Work? | |
| Cancelling an Order | |
| Can We Cancel? |
| Orders Service Events | |
| Creating the Events | |
| Implementing the Publishers | |
| Publishing the Order Creation | |
| Publishing Order Cancellation | |
| Testing Event Publishing |
| Heads Up Regarding Some Mongoose TS Errors | |
| Time for Listeners! | |
| Reminder on Listeners | |
| Blueprint for Listeners | |
| A Few More Reminders | |
| Simple onMessage Implementation | |
| ID Adjustment | |
| Ticket Updated Listener Implementation | |
| Initializing the Listeners | |
| A Quick Manual Test | |
| Clear Concurrency Issues | |
| Reminder on Versioning Records | |
| Optimistic Concurrency Control | |
| Mongoose Update-If-Current | |
| Implementing OCC with Mongoose | |
| Test functions cannot both take a 'done' callback and return something Error | |
| Testing OCC | |
| One More Test | |
| Who Updates Versions? | |
| Including Versions in Events | |
| Updating Tickets Event Definitions | |
| Property 'version' is missing TS Errors After Running Skaffold | |
| Applying a Version Query | |
| Did it Work? | |
| Abstracted Query Method | |
| [Optional] Versioning Without Update-If-Current | |
| Testing Listeners | |
| A Complete Listener Test | |
| Testing the Ack Call | |
| Testing the Ticket Updated Listener | |
| Success Case Testing | |
| Out-Of-Order Events | |
| The Next Few Videos | |
| Fixing a Few Tests | |
| Listeners in the Tickets Service | |
| Building the Listener | |
| Strategies for Locking a Ticket | |
| Reserving a Ticket | |
| Setup for Testing Reservation | |
| Test Implementation | |
| Missing Update Event | |
| Private vs Protected Properties | |
| Publishing While Listening | |
| Mock Function Arguments | |
| Order Cancelled Listener | |
| A Lightning-Quick Test | |
| Don't Forget to Listen! | |
| Rejecting Edits of Reserved Tickets |
| The Expiration Service | |
| Expiration Options | |
| Initial Setup | |
| Skaffold errors - Expiration Image Can't be Pulled | |
| A Touch of Kubernetes Setup | |
| File Sync Setup | |
| Listener Creation | |
| What's Bull All About? | |
| Creating a Queue | |
| Queueing a Job on Event Arrival | |
| Testing Job Processing | |
| Delaying Job Processing | |
| Defining the Expiration Complete Event | |
| Publishing an Event on Job Processing | |
| Handling an Expiration Event | |
| Emitting the Order Cancelled Event | |
| Testing the Expiration Complete Listener | |
| A Touch More Testing | |
| Listening for Expiration |
| The Payments Service | |
| globalThis has no index signature TS Error | |
| Initial Setup | |
| Replicated Fields | |
| Another Order Model! | |
| Update-If-Current | |
| Replicating Orders | |
| Testing Order Creation | |
| Marking an Order as Cancelled | |
| Cancelled Testing | |
| Starting the Listeners | |
| Payments Flow with Stripe | |
| Implementing the Create Charge Handler | |
| Validating Order Payment | |
| Testing Order Validation Before Payment | |
| Testing Same-User Validation | |
| Stripe Setup | |
| Creating a Stripe Secret | |
| Creating a Charge with Stripe | |
| Manual Testing of Payments | |
| Automated Payment Testing | |
| Mocked Stripe Client | |
| A More Realistic Test Setup | |
| Realistic Test Implementation | |
| Tying an Order and Charge Together | |
| Testing Payment Creation | |
| Publishing a Payment Created Event | |
| More on Publishing | |
| Marking an Order as Complete | |
| Important Info About the Next Lecture - Don't Skip | |
| Don't Cancel Completed Orders! |
| A Few More Pages | |
| Reminder on Data Fetching with Next | |
| Two Quick Fixes | |
| Scaffolding a Form | |
| Sanitizing Price Input | |
| Ticket Creation | |
| Listing All Tickets | |
| Reminder on Invalid with child Errors | |
| Linking to Wildcard Routes | |
| Creating an Order | |
| Programmatic Navigation to Wildcard Routes | |
| The Expiration Timer | |
| Displaying the Expiration | |
| Showing a Stripe Payment Form | |
| Module not found: Can't resolve 'prop-types' | |
| Configuring Stripe | |
| Test Credit Card Numbers | |
| Paying for an Order | |
| Filtering Reserved Tickets | |
| Header Links | |
| Rendering a List of Orders |
| Development Workflow | |
| Git Repository Approaches | |
| Creating a GitHub Action | |
| Adding a CI Test Script | |
| Tests in GitHub Actions Hang - Jest did not exit | |
| Running Tests on PR Creation | |
| Output of Failing Tests | |
| Running Tests in Parallel | |
| Verifying a Test Run | |
| Selective Test Execution | |
| Deployment Options | |
| Creating a Hosted Cluster | |
| Reminder on Kubernetes Context | |
| Reminder on Swapping Contexts | |
| The Deployment Plan | |
| Building an Image in an Action | |
| Testing the Image Build | |
| Restarting the Deployment | |
| Applying Kubernetes Manifests | |
| Prod vs Dev Manifest Files | |
| Manual Secret Creation | |
| Don Forget Ingress-Nginx! | |
| Testing Automated Deployment | |
| Additional Deploy Files | |
| A Successful Deploy! | |
| Buying a Domain Name | |
| Three Important Changes Needed to Deploy - Do Not Skip! | |
| Configuring the Domain Name | |
| I Really Hope This Works | |
| Next Steps |
| Finished Code and Diagrams | |
| Why Use Docker? | |
| What is Docker? | |
| Docker for Mac / Windows | |
| Installing Docker on macOS | |
| Installing Docker with WSL2 on Windows 10/11 | |
| Installing Docker on Linux | |
| Using the Docker Client | |
| But Really... What's a Container? | |
| How's Docker Running on Your Computer? | |
| Docker Run in Detail | |
| Overriding Default Commands | |
| Listing Running Containers | |
| Container Lifecycle | |
| Restarting Stopped Containers | |
| Removing Stopped Containers | |
| Retrieving Output Logs | |
| Stopping Containers | |
| Multi-Command Containers | |
| Executing Commands in Running Containers | |
| The Purpose of the 'it' Flag | |
| Getting a Command Prompt in a Container | |
| Starting with a Shell | |
| Container Isolation | |
| Creating Docker Images | |
| Buildkit for Docker Desktop | |
| Building a Dockerfile | |
| Dockerfile Teardown | |
| What's a Base Image? | |
| The Build Process in Detail | |
| A Brief Recap | |
| Rebuilds with Cache | |
| Tagging an Image | |
| Quick Note for Windows Users | |
| Manual Image Generation with Docker Commit | |
| Project Outline | |
| Node Server Setup | |
| A Few Planned Errors | |
| Required Node Base Image Version | |
| Base Image Issues | |
| A Few Missing Files | |
| Copying Build Files | |
| Container Port Forwarding | |
| Specifying a Working Directory | |
| Unnecessary Rebuilds | |
| Minimizing Cache Busting and Rebuilds |
| How to Get Help | |
| TypeScript Overview | |
| Environment Setup | |
| Important Update About ts-node and Axios | |
| A First App | |
| Executing Typescript Code | |
| One Quick Change | |
| Catching Errors with TypeScript | |
| Catching More Errors! | |
| Do Not Skip - Course Overview | |
| Types | |
| More on Types | |
| Examples of Types | |
| Where Do We Use Types? | |
| Type Annotations and Inference | |
| Annotations With Variables | |
| Object Literal Annotations | |
| Annotations Around Functions | |
| Understanding Inference | |
| The Any Type | |
| Fixing the "Any" Type | |
| Delayed Initialization | |
| When Inference Doesn't Work | |
| More on Annotations Around Functions | |
| Inference Around Functions | |
| Annotations for Anonymous Functions | |
| Void and Never | |
| Destructuring with Annotations | |
| Annotations Around Objects | |
| Arrays in TypeScript | |
| Why Typed Arrays? | |
| Multiple Typees in Arrays | |
| When to Use Typed Arrays | |
| Tuples in TypeScript | |
| Tuples in Action | |
| Why Tuples? | |
| Interfaces | |
| Long Type Annotations | |
| Fixing Annotations With Interfaces | |
| Syntax Around Interfaces | |
| Functions in Interfaces | |
| Code Reuse with Interfaces | |
| General Plan with Interfaces | |
| Classes | |
| Basic Inheritance | |
| Class Method Modifiers | |
| Fields in Classes | |
| Fields with Inheritance | |
| Where to Use Classes | |
| Updated Parcel Instructions | |
| App Overview | |
| Bundling with Parcel | |
| Project Structure | |
| IMPORTANT Info About Faker Installation | |
| Generating Random Data | |
| Type Definition Files | |
| Using Type Definition Files | |
| Export Statements in TypeScript | |
| Defining a Company | |
| Important Note About Google Maps Key | |
| Adding Google Maps Support | |
| Required Update for New @types Library | |
| Google Maps Integration with TypeScript | |
| Exploring Type Definition Files | |
| Hiding Functionality | |
| Why Use Private Modifiers? Here's Why | |
| Adding Markers | |
| Duplicate Code | |
| One Possible Solution | |
| Restricting Access with Interfaces | |
| Implicit Type Checks | |
| Showing Popup Windows | |
| Updating Interface Definitions | |
| Optional Implements Clauses | |
| App Wrapup |
| Bonus! |
Learning Modules
| Note on Strapi 5 update (currently beta) |
| Install and manage NodeJs with NVM | |
| Project repository (for reference) | |
| More on Strapi installation | |
| How to use Typescript (optional) | |
| Admin panel: users, roles and initial tour | |
| How to update Strapi |
| Data fields: foreword | |
| Data fields | |
| Adding fields to a content type | |
| Creating the Tag collection type | |
| Relation fields | |
| Components | |
| Using the Content Manager | |
| Creating Service and Course content types | |
| Creating a single content type | |
| Creating a component for Posts Selection | |
| Creating the Home Page content entry | |
| Fixing the Home Page | |
| Creating a global configuration type | |
| Creating Header and Footer types | |
| SEO and page challenge | |
| Finishing the blog application | |
| Strapi architecture: generated code overview |
| Install some tools | |
| Authentication & Authorization: the theory | |
| Performing User Authentication via API | |
| Performing our first authenticated operation | |
| API tokens |
| CRUD operations on Collection Types | |
| CRUD operations on Single Types | |
| API parameters: an introduction | |
| Sort the API response | |
| Filter your API responses | |
| Populate your API responses with relations and more | |
| Select fields for your API responses | |
| Paginate through content via API | |
| Deal with draft content via API |
| GraphQL queries on public data | |
| User Authentication with GraphQL | |
| First authenticated GraphQL query | |
| Getting nested components via GraphQL | |
| Getting dynamic zones via GraphQL | |
| GraphQL Mutations | |
| GraphQL operators |
| Request and Response | |
| Data models and APIs | |
| Lifecycle hooks | |
| Configuring core routes | |
| Creating custom routes | |
| Policies | |
| The Strapi object | |
| Middleware | |
| Controllers: creating custom controllers | |
| Controllers: extending core controllers | |
| Controllers: replacing core controllers | |
| Services | |
| Entity Service and Query Engine APIs | |
| Premium posts: introduction | |
| Premium posts: solution 1 | |
| Premium posts: solution 2 | |
| Premium posts: solution 3 | |
| Premium posts: the findOne controller | |
| Post likes: part 1 | |
| Post likes: part 2 | |
| Lifecycle hooks: the theory | |
| Lifecycle hooks exercise: part 1 (challenge) | |
| Lifecycle hooks exercise: part 2 (challenge solution) | |
| Lifecycle hooks exercise: part 3 (first programmatic hook) | |
| Lifecycle hooks exercise: part 4 (second programmatic hook) | |
| Lifecycle hooks exercise: part 5 (declarative hook) | |
| Webhooks: an overview |
| Customizing the GraphQL CRUD operations | |
| Extensions: Nexus vs GraphQL SDL | |
| Extending the schema (custom mutation) | |
| Creating a custom resolver | |
| Applying an auth scope to GraphQL operations | |
| Shaping a GraphQL response | |
| Reorganizing GraphQL extension code |
| Admin Panel Configuration: introduction | |
| Admin server configurations | |
| Admin panel translations | |
| Changing admin logos and more | |
| Changing admin color scheme |
| Plugin route, controller and service | |
| Fetching data from the Github API | |
| Adapting the API response | |
| Creating the Project content type | |
| Creating a test Project | |
| Fetching related projects | |
| Dealing with markdown content | |
| Admin panel: plugin icon and first component | |
| The Strapi design system | |
| Fetching data from the admin panel | |
| Showing data in a table | |
| Setting up the action icons | |
| Implementing the checkbox logic | |
| Applying the proper auth policy to our route | |
| Generating a single project | |
| Providing UI feedback to the admin user | |
| Deleting a project | |
| Showing a confirmation dialog before deleting | |
| Showing buttons for bulk actions | |
| Creating projects in bulk | |
| Deleting projects in bulk | |
| Admin RBAC: update premise | |
| Admin RBAC: restricting plugin use to specific roles | |
| Admin RBAC: restricting routes to specific roles | |
| Fixing error handling | |
| Exposing projects with public routes | |
| Plugin localization | |
| Extract the plugin as a separate package | |
| Publish the plugin to npm registry | |
| Install the plugin as a dependency (and publish to the Strapi Market) |
| Creating a Github repo for our project | |
| Reference repository for this deployment section | |
| Environment configurations | |
| Database creation and configuration | |
| Server configuration | |
| Admin configuration | |
| First Strapi deployment | |
| Configure the email plugin | |
| Configure an external upload provider (Cloudinary) | |
| Configure a custom domain | |
| Deploying admin as a static site: configuration | |
| Deploying admin as a static site: creating the site | |
| Make absolute admin URLs work | |
| Infrastructure as Code: Make your Strapi deployment reusable [Optional] |
| Strapi admin: initial tour |
Learning Modules
| What is MongoDB? | |
| Join our Online Learning Community | |
| General Setup Instructions & Installing MongoDB on macOS | |
| Installing MongoDB on Windows | |
| Installing the MongoDB Shell | |
| Installing mongoimport | |
| Shell vs Drivers |
| Module Introduction | |
| Understanding Databases, Collections & Documents | |
| The Shell & MongoDB Drivers for Different Languages | |
| Creating Databases & Collections | |
| Understanding JSON Data | |
| Comparing JSON & BSON | |
| Create, Read, Update, Delete (CRUD) & MongoDB | |
| Finding, Inserting, Deleting & Updating Elements | |
| Understanding "insertMany()" | |
| Diving Deeper Into Finding Data | |
| "update" vs "updateMany()" | |
| Understanding "find()" & the Cursor Object | |
| Understanding Projection | |
| Embedded Documents & Arrays - The Theory | |
| Working with Embedded Documents | |
| Working with Arrays | |
| Accessing Structured Data | |
| Time to Practice - The Basics & CRUD Operations | |
| Wrap Up | |
| Useful Resources & Links |
| Resetting Your Database | |
| Module Introduction | |
| Why Do We Use Schemas? | |
| Structuring Documents | |
| Data Types - An Overview | |
| Data Types in Action | |
| Data Types & Limits | |
| How to Derive your Data Structure - Requirements | |
| Understanding Relations | |
| One To One Relations - Embedded | |
| One To One - Using References | |
| One To Many - Embedded | |
| One To Many - Using References | |
| Many To Many - Embedded | |
| Many To Many - Using References | |
| Summarizing Relations | |
| Using "lookUp()" for Merging Reference Relations | |
| Planning the Example Exercise | |
| Implementing the Example Exercise | |
| Understanding Schema Validation | |
| Adding Collection Document Validation | |
| Changing the Validation Action | |
| Wrap Up | |
| Useful Resources & Links |
| Module Introduction | |
| Finding Available Options | |
| Setting "dbpath" & "logpath" | |
| Exploring the MongoDB Options | |
| MongoDB as a Background Service | |
| Using a Config File | |
| Shell Options & Help | |
| Useful Resources & Links |
| Module Introduction | |
| Exploring the MongoDB Compass | |
| Useful Resources & Links |
| Module Introduction | |
| Creating Documents - An Overview | |
| Understanding "insert()" Methods | |
| Working with Ordered Inserts | |
| Understanding the "writeConcern" | |
| The "writeConcern" in Practice | |
| What is Atomicity? | |
| Time to Practice - Create Operations | |
| Importing Data | |
| Wrap Up | |
| Useful Resources & Links |
| Module Introduction | |
| Methods, Filters & Operators | |
| Operators - An Overview | |
| Query Selectors & Projection Operators | |
| Understanding "findOne()" & "find()" | |
| Working with Comparison Operators | |
| Querying Embedded Fields & Arrays | |
| Understanding "$in" and "$nin" | |
| "$or" and "$nor" | |
| Understanding the "$and" Operator | |
| Using "$not" | |
| Diving Into Element Operators | |
| Working with "$type" | |
| Understanding Evaluation Operators - "$regex" | |
| Understanding Evaluation Operators - "$expr" | |
| Time to Practice - Read Operations | |
| Diving Deeper Into Querying Arrays | |
| Using Array Query Selectors - "$size" | |
| Using Array Query Selectors - "$all" | |
| Using Array Query Selectors - "$elemMatch" | |
| Time to Practice - Array Query Selectors | |
| Understanding Cursors | |
| Applying Cursors | |
| Sorting Cursor Results | |
| Skipping & Limiting Cursor Results | |
| Using Projection to Shape our Results | |
| Using Projection in Arrays | |
| Understanding "$slice" | |
| Useful Resources & Links |
| Module Introduction | |
| Updating Fields with "updateOne()", "updateMany()" and "$set" | |
| Updating Multiple Fields with "$set" | |
| Incrementing & Decrementing Values | |
| Using "$min", "$max" and "$mul" | |
| Getting Rid of Fields | |
| Renaming Fields | |
| Understanding "upsert()" | |
| Time to Practice - Update Operations | |
| Updating Matched Array Elements | |
| Updating All Array Elements | |
| Finding & Updating Specific Fields | |
| Adding Elements to Arrays | |
| Removing Elements from Arrays | |
| Understanding "$addToSet" | |
| Wrap Up | |
| Useful Resources & Links |
| Module Introduction | |
| Understanding "deleteOne()" & "deleteMany()" | |
| Deleting All Entries in a Collection | |
| Useful Resources & Links |
| Module Introduction | |
| What Are Indexes & Why Do We Use Them? | |
| Adding a Single Field Index | |
| Indexes Behind the Scenes | |
| Understanding Index Restrictions | |
| Creating Compound Indexes | |
| Using Indexes for Sorting | |
| Understanding the Default Index | |
| Configuring Indexes | |
| Understanding Partial Filters | |
| Applying the Partial Index | |
| Understanding the Time-To-Live (TTL) Index | |
| Query Diagnosis & Query Planning | |
| Understanding Covered Queries | |
| How MongoDB Rejects a Plan | |
| Using Multi-Key Indexes | |
| Understanding Text Indexes | |
| Text Indexes & Sorting | |
| Creating Combined Text Indexes | |
| Using Text Indexes to Exclude Words | |
| Setting the Default Language & Using Weights | |
| Building Indexes | |
| Wrap Up | |
| Useful Resources & Links |
| Module Introduction | |
| Adding GeoJSON Data | |
| Running Geo Queries | |
| Adding a Geospatial Index to Track the Distance | |
| Adding Additional Locations | |
| Finding Places Inside a Certain Area | |
| Finding Out If a User Is Inside a Specific Area | |
| Finding Places Within a Certain Radius | |
| Time to Practice - Geospatial Data | |
| Wrap Up | |
| Useful Resources & Links |
| Module Introduction | |
| What is the Aggregation Framework? | |
| Getting Started with the Aggregation Pipeline | |
| Using the Aggregation Framework | |
| Understanding the Group Stage | |
| Diving Deeper Into the Group Stage | |
| Time to Practice - The Aggregation Framework | |
| Working with $project | |
| Turning the Location Into a geoJSON Object | |
| Transforming the Birthdate | |
| Using Shortcuts for Transformations | |
| Understanding the $isoWeekYear Operator | |
| $group vs $project | |
| Pushing Elements Into Newly Created Arrays | |
| Understanding the $unwind Stage | |
| Eliminating Duplicate Values | |
| Using Projection with Arrays | |
| Getting the Length of an Array | |
| Using the $filter Operator | |
| Applying Multiple Operations to our Array | |
| Understanding $bucket | |
| Diving Into Additional Stages | |
| How MongoDB Optimizes Your Aggregation Pipelines | |
| Writing Pipeline Results Into a New Collection | |
| Working with the $geoNear Stage | |
| Wrap Up | |
| Useful Resources & Links |
| Module Introduction | |
| Number Types - An Overview | |
| MongoDB Shell & Data Types | |
| Understanding Programming Language Defaults | |
| Working with int32 | |
| Working with int64 | |
| Doing Maths with Floats int32s & int64s | |
| What's Wrong with Normal Doubles? | |
| Working with Decimal 128bit | |
| Wrap Up | |
| Useful Resources & Links |
| Module Introduction | |
| Understanding Role Based Access Control | |
| Roles - Examples | |
| Creating a User | |
| Built-In Roles - An Overview | |
| Assigning Roles to Users & Databases | |
| Updating & Extending Roles to Other Databases | |
| Time to Practice - Security | |
| Adding SSL Transport Encryption | |
| Encryption at REST | |
| Wrap Up | |
| Useful Resources & Links |
| Module Introduction | |
| What Influences Performance? | |
| Understanding Capped Collections | |
| What are Replica Sets? | |
| Understanding Sharding | |
| Deploying a MongoDB Server | |
| Using MongoDB Atlas | |
| Backups & Setting Alerts in MongoDB Atlas | |
| Connecting to our Cluster | |
| Wrap Up | |
| Useful Resources & Links |
| Module Introduction | |
| What are Transactions? | |
| A Typical Usecase | |
| How Does a Transaction Work? | |
| Useful Resources & Links |
| Module Introduction | |
| Splitting Work Between the Driver & the Shell | |
| Preparing our Project | |
| Installing Visual Studio Code | |
| Installing the Node.js Driver | |
| Connecting Node.js & the MongoDB Cluster | |
| Storing Products in the Database | |
| Storing the Price as 128bit Decimal | |
| Fetching Data From the Database | |
| Creating a More Realistic Setup | |
| Getting a Single Product | |
| Editing & Deleting Products | |
| Implementing Pagination | |
| Adding an Index | |
| Signing Users Up | |
| Adding an Index to Make the Email Unique | |
| Adding User Sign In | |
| Wrap Up | |
| Useful Resources & Links |
| Module Introduction | |
| Stitch & MongoDB Realm | |
| What is Stitch? | |
| Preparations | |
| Start Using Stitch | |
| Adding Stitch to our App & Initializing It | |
| Adding Authentication | |
| Sending Data Access Rules | |
| Fetching & Converting Data | |
| Deleting Products | |
| Finding a Single Product | |
| Adding Products | |
| Updating Products | |
| Switching to User Email & Password Authentication | |
| Adding User Sign Up & Confirmation | |
| Adding User Login | |
| Rules & Real Users | |
| The Current State of Authentication | |
| Functions & Triggers | |
| Wrap Up | |
| Useful Resources & Links |
| Course Roundup | |
| Course Slides | |
| Bonus: More Content! |
Learning Modules
| Join Our Community! | |
| Course Resources | |
| Database Terminology | |
| Analyzing CREATE TABLE | |
| Inserting Data Into a Table | |
| Retrieving Data with Select | |
| Create, Insert, and Select! | |
| Calculated Columns | |
| Calculating Phone Revenue | |
| Using Calculated Columns | |
| Exercise Solution | |
| String Operators and Functions |
| Filtering Rows with "Where" | |
| More on the "Where" Keyword | |
| Compound "Where" Clauses | |
| A "Where" Exercise Overview | |
| Practicing Where Statements | |
| A "Where" Solution | |
| "Where" With Lists | |
| A More Challenging 'Where' | |
| A "Where" With Lists Solution | |
| Calculations in "Where" Clauses | |
| Trying Calculations in Where Clauses | |
| Solving Calculations | |
| Updating Rows | |
| Deleting Rows | |
| Try Updating Records In a Table! | |
| A Solution for Updating Rows | |
| Practice Deleting Records | |
| Solution for Deleting Rows |
| The Plan Moving Forward | |
| Approaching Database Design | |
| Let's Design Some Schema | |
| One-to-Many and Many-to-One Relationships | |
| A 'Has One' or 'Has Many'? | |
| One-to-One and Many-to-Many Relationships | |
| Identifying One-to-One and Many-to-Many Relationships | |
| Primary Keys and Foreign Keys | |
| Understanding Foreign Keys | |
| Foreign Keys; How Do They Work? | |
| Auto-Generated ID's | |
| Creating Foreign Key Columns | |
| Running Queries on Associated Data | |
| Exercise Overview | |
| Creating and Using Foreign Keys | |
| Foreign Key Creation Solution | |
| Foreign Key Constraints Around Insertion | |
| Constraints Around Deletion | |
| Commands You’ll Need for the Next Video | |
| Testing Deletion Constraints | |
| Setting Foreign Keys to Null on Delete | |
| What Happens On Delete? | |
| Adding Some Complexity |
| Adding Some Data | |
| Queries with Joins and Aggregations | |
| Joining Data from Different Tables | |
| Another Quick Join | |
| Exercise Overview | |
| Practice Joining Data | |
| A Joinful Solution | |
| Alternate Forms of Syntax | |
| Missing Data in Joins | |
| Why Wasn't It Included | |
| Four Kinds of Joins | |
| Each Join in Practice | |
| Does Order Matter? | |
| Test Your Joining Knowledge | |
| Exercise Overview | |
| Joins, Joins, Join! | |
| Two Possible Solutions | |
| Where with Join | |
| Three Way Joins | |
| A Bit of Practice | |
| Three Way Exercise | |
| Exercise Solution |
| Aggregating and Grouping | |
| Picturing Group By | |
| Selecting Columns After Grouping | |
| Aggregate Functions | |
| Combining Group By and Aggregates | |
| A Gotcha with Count | |
| Visualizing More Grouping | |
| Exercise Overview | |
| Practice For Grouping and Aggregating | |
| Grouping Solution | |
| Adding a Layer of Difficulty | |
| Grouping With a Join! | |
| Solution | |
| Filtering Groups with Having | |
| Having In Action | |
| More on Having! | |
| A Having Exercise Overview | |
| Practice Yourself Some Having | |
| A Quick Solution |
| A New Dataset | |
| Investigating This Dataset | |
| Some Group By Practice | |
| Group By Review | |
| Group By Review Solution | |
| Remember Joins? | |
| Inner Join Review | |
| Of Course You Remember! |
| The Basics of Sorting | |
| Two Variations on Sorting | |
| Offset and Limit | |
| Exercise Overview | |
| Sorting, Offsetting, and Limiting | |
| Exercise Solution |
| Handling Sets with Union | |
| A Few Notes on Union | |
| Commonalities with Intersect | |
| Removing Commonalities with Except | |
| Union Exercise Overview | |
| Merging Results with Union | |
| Exercise Solution |
| What's a Subquery? | |
| Thinking About the Structure of Data | |
| What's the Data Look Like? | |
| Subqueries in a Select | |
| Exercise Overview | |
| Embedding in Select | |
| Select Solution | |
| Subqueries in a From | |
| From Subqueries that Return a Value | |
| Example of a Subquery in a From | |
| Exercise Overview | |
| Subquery Froms | |
| Exercise Solution | |
| Subqueries in a Join Clause | |
| More Useful - Subqueries with Where | |
| Data Structure with Where Subqueries | |
| Exercise Overview | |
| Subquery Where's | |
| Exercise Solution | |
| The Not In Operator with a List | |
| A New Where Operator | |
| Finally Some! | |
| Is It A Valid Subquery? | |
| Exercise Overview | |
| Practice Your Subqueries! | |
| A Quick Solution | |
| Probably Too Much About Correlated Subqueries | |
| More on Correlated Subqueries | |
| A Select Without a From? | |
| Exercise Overview | |
| From-less Selects | |
| Exercise Solution |
| Selecting Distinct Values | |
| Exercise Overview | |
| Some Practice with Distinct | |
| A Distinct Solution |
| The Greatest Value in a List | |
| And the Least Value in a List! | |
| The Case Keyword |
| PostgreSQL Installation on macOS | |
| pgAdmin Setup on macOS | |
| Postgres installation on Windows |
| What'd We Just Do? | |
| Data Types | |
| Fast Rules on Numeric Data Types | |
| More on Number Data Types | |
| Reminder on Character Types | |
| Boolean Data Types | |
| Times, Dates, and Timestamps | |
| Really Awesome Intervals |
| Thinking About Validation | |
| Creating and Viewing Tables in PGAdmin | |
| Applying a Null Constraint | |
| Solving a Gotcha with Null Constraints | |
| Creating NULL Constraints | |
| Default Column Values | |
| Applying a Unique Constraint to One column | |
| Multi-Column Uniqueness | |
| Is It Unique? | |
| Adding a Validation Check | |
| Checks Over Multiple Columns | |
| Does It Pass a Check? | |
| So Where Are We Applying Validation? |
| Approaching More Complicated Designs | |
| Using a SQL Design Tool | |
| A Config-based Schema Designer | |
| Here's the Plan | |
| Rebuilding Some Schema |
| Requirements of a Like System | |
| How Not to Design a Like System | |
| Designing a Like System | |
| Building a Similar System | |
| Making a Reaction System Instead | |
| Polymorphic Associations | |
| Polymorphic Association Alternative Implementation | |
| The Simplest Alternative | |
| Polymorphic Associations | |
| So Which Approach? |
| Additional Features Around Posts | |
| Adding Captions and Locations | |
| Photo Mentions vs Caption Mentions | |
| Considerations on Photo Tags vs Caption Tags | |
| Update For Tags |
| Designing a Hashtag System | |
| Tables for Hashtags | |
| Including the Hashtag Table | |
| A Few More User Columns | |
| Why No Number of Followers or Posts? |
| Designing a Follower System |
| Back to Postgres | |
| Creating Tables with Checks | |
| Posts Creation | |
| Comments Creation | |
| Likes Creation | |
| Photo Tags and Caption Tags | |
| Creating Hashtags, Hashtag Posts, and Followers |
| Quick Note About Adding Some Data | |
| Adding Some Data | |
| Restoring from Scratch | |
| Highest User ID's Exercise | |
| Solution for User ID's | |
| Posts by a Particular User | |
| Solving for Posts by User | |
| Likes Per User | |
| Solution for Likes Per User |
| Thinking About Performance | |
| Where Does Postgres Store Data? | |
| Heaps, Blocks, and Tuples | |
| Terminology Check | |
| Block Data Layout | |
| Heap File Layout |
| Full Table Scans | |
| What's an Index | |
| How an Index Works | |
| Creating an Index | |
| Benchmarking Queries | |
| Downsides of Indexes | |
| Index Types | |
| Automatically Generated Indexes | |
| Using Automatically Created Indexes | |
| Behind the Scenes of Indexes |
| The Query Processing Pipeline | |
| Explain and Explain Analyze | |
| Explain Vs Explain Analyze | |
| Solving an Explain Mystery |
| Developing an Intuitive Understanding of Cost | |
| Calculating Cost by Hand | |
| A Touch More on Costs | |
| Calculating Costs | |
| Startup vs Total Costs | |
| Costs Flow Up | |
| Use My Index! |
| Common Table Expressions | |
| A Quick Solution | |
| So What's a CTE? |
| Recursive CTE's | |
| Recursive CTE's Step by Step | |
| Why Use Recursive CTE's? | |
| Writing the Query | |
| Walking Through Recursion |
| Most Popular Users | |
| A Possible Solution for Merging Tables | |
| Creating a View | |
| When to Use a View? | |
| Deleting and Changing Views |
| Materialized Views | |
| Grouping by Week | |
| Reminder on Left Joins | |
| Writing a Slow Query | |
| Creating and Refreshing Materialized Views | |
| Views vs Materialized Views |
| What are Transactions Used For? | |
| Some Sample Data | |
| Opening and Closing Transactions | |
| Transaction Cleanup on Crash | |
| Closing Aborted Transactions |
| A Story on Migrations | |
| Migration Files | |
| Issues Solved by Migrations | |
| A Few Notes on Migrations Libraries | |
| A Note About Node Installation | |
| Project Creation | |
| Generating and Writing Migrations | |
| Applying and Reverting Migrations | |
| Generating and Applying a Second Migration |
| Schema vs Data Migrations | |
| Dangers Around Data Migrations | |
| Properly Running Data and Schema Migrations | |
| Creating a Posts Table | |
| A Small Web Server | |
| Web Server Setup Instructions | |
| Adding the Loc Column | |
| Writing Values to Both Columns | |
| Transaction Locks | |
| Updating Values | |
| Migrations Setup Instructions | |
| Updating the App Server | |
| Dropping the Last Columns |
| Section Goal | |
| Initial Setup | |
| One Fast Migration | |
| Building the Users Router | |
| Understanding Connection Pools | |
| Validating Connection Credentials | |
| Query and Close |
| The Repository Pattern | |
| Creating a Repository | |
| Accessing the API | |
| Casing Issues | |
| Fixing Casing | |
| Finding Particular Users |
| SQL Injection Exploits | |
| Handling SQL Injection with Prepared Statements | |
| Preventing SQL Injection | |
| Reminder on Post Requests | |
| Inserting Users | |
| Handling Updates | |
| And, Finally, Delete |
| A Note on Testing | |
| Assertions Around User Count | |
| Connecting to a DB For Tests | |
| Disconnecting After Tests | |
| Multi-DB Setup | |
| Assumptions Around Content | |
| Issues with Parallel Tests | |
| Isolation with Schemas | |
| Creating and Accessing Schemas | |
| Controlling Schema Access with Search Paths | |
| Routing Schema Access | |
| Strategy for Isolation | |
| Programmatic Schema Creation | |
| Escaping Identifiers | |
| Test Helpers | |
| Cleaning up Schemas and Roles | |
| Finally... Parallel Tests! (Final Lecture) |
| Bonus! |
Learning Modules
| IMPORTANT |
| New Section Introduction - Beginning the Implementation of the Home Component | |
| An Example of a Firestore array-contains Query | |
| Converting Firestore Query Results to a Domain Model | |
| Finishing the Implementation of the Home Component | |
| The Firebase Local Emulator - Why do we need it? | |
| Setting Up a Firebase Project with firebase init | |
| Introduction to the Firebase Local Emulator | |
| AngularFire CRUD Example - The Create Course Form | |
| AngularFire CRUD Create Service - API Design | |
| AngularFire CRUD Create - Service Implementation | |
| AngularFire CRUD Update - Service Implementation | |
| AngularFire CRUD Update - Building the Edit Course Dialog | |
| AngularFire CRUD Update - Final Implementation and Demo | |
| AngularFire CRUD Delete - Implementation and Demo | |
| Understanding Firestore Transactional Batched Writes | |
| Course Screen - Pre-Fetching Data with a Course Resolver | |
| Course Screen - Router Resolver Implementation and Demo | |
| How to Implement a Firestore Paginated Query | |
| Firestore Data Pagination Example - Implementation Conclusion and Demo |
| Introduction to Firebase Authentication | |
| Implementing Authentication Using Firebase UI | |
| Implementing an Angular User Service - API Design | |
| User Service - Adapting the UI to the User Authentication Status | |
| Introduction to Firestore Security Rules | |
| Firestore Security Rules Fundamentals - Nested Rules | |
| Firestore Security Rules Fundamentals - Rule Order and Access Types | |
| Checking if a User Is Authenticated Using Firestore Security Rules | |
| Implementing Firestore Schema Validation With Firestore Security Rules | |
| How to Implement a User White List Using Firestore Security Rules | |
| Implementing Role Based Access Control (RBAC) with Firestore Security Rules | |
| How to Write Security Rules For Collection Group Queries | |
| RBAC UI Implementation - The Roles Observable | |
| Showing certain UI Features only to Administrator Users | |
| Protecting Access to Admin Screens With the AngularFire Authentication Guard |
| Introduction to Firebase Storage | |
| File Upload with Firebase Storage - Implementation Finished and Demo | |
| Implementing a File Upload Progress Indicator for Firebase Storage | |
| How to Create a Safe Download Url in Firebase Storage | |
| Firebase Storage Security Rules |
| Why do We Need Firebase Cloud Functions? | |
| How Do Firebase Cloud Functions Work? | |
| Firebase Cloud Functions - Hello World | |
| Firebase Cloud Functions - Introduction to Database Triggers | |
| How To Initialize a Firestore Connection From a Firebase Cloud Function | |
| Firebase Cloud Functions Add Document Trigger Implementation | |
| How To Minimize the Cold Startup Time Of Firebase Cloud Functions | |
| Firebase Cloud Functions - Update Triggers | |
| Firebase Cloud Functions - Delete Trigger | |
| How to Create an HTTP Endpoint with Firebase Cloud Functions | |
| Calling a Firebase Cloud Function REST Endpoint | |
| Implementing a Create User REST Endpoint with Firebase Cloud Functions | |
| Setting Up an Angular Http Interceptor | |
| Securing a Firebase Cloud Function Endpoint using Express Middleware | |
| Firebase Cloud Functions Secure REST Endpoint - Final Demo |
| Introduction to Firebase Service Accounts | |
| Setting The Claims of the Initial Root Admin Using a Node Script | |
| Production Deployment With Firebase Hosting | |
| Final Application Test In Production |
| Bonus Lecture (Updated March 2025) | |
| Conclusions and Key Takeaways |
Learning Modules
| Download PPT for this Module | |
| Delete resources and set budget |
| Introduction to NoSQL | |
| SQL vs NoSQL Database | |
| 4 types of NoSQL Databases | |
| NoSQL Offerings by Microsoft Azure |
| Cosmos DB - PPT and Demo Resources | |
| Cosmos DB Features | |
| Cosmos DB - Multi Model 5 APIs | |
| Table Storage vs CosmosDB | |
| Provision CosmosDB Account |
| Cosmos DB - Horizontally Scalable | |
| Cosmos DB - Partition and Partitioning key | |
| Cosmos DB - Dedicated vs Shared throughput | |
| Cosmos DB - Avoiding hot partition | |
| Cosmos DB - Single partition vs Cross partition | |
| Cosmos DB - Composite Key | |
| Cosmos DB - Partition key best practice |
| Cosmos DB - Automatic Indexing | |
| Demo Insert and query data in your cosmos DB | |
| Cosmos DB - Time to Live feature | |
| Cosmos DB - Manual vs Automatics Failover | |
| Cosmos DB - 5 consistent levels | |
| Cosmos DB - Azure CLI | |
| Cosmos DB - Pricing |
| Cosmos DB - Monitoring through AMS | |
| Cosmos DB - Monitoring through account portal | |
| Cosmos DB - Security |
| Practice Test 1 | |
| Practice Test 2 |
| Bonus Section |
Learning Modules
| 0104 Understanding The System Requirements | |
| 0105 How To Access Your Working Files | |
| 0106 Opening The Main Virtual Machine | |
| 0107 Pop Quiz |
| 0201 Understanding That Cassandra Is A Distributed Database | |
| 0202 Learning What Snitch Is For | |
| 0203 Learning What Gossip Is For | |
| 0204 Learning How Data Gets DIstributed | |
| 0205 Learning About Replication | |
| 0206 Learning About Virtual Nodes | |
| 0207 Pop Quiz |
| 0301 Downloading Cassandra | |
| 0302 Ensuring Oracle Java 7 Is Installed | |
| 0303 Installing Cassandra | |
| 0304 Viewing The Main Configuration File | |
| 0305 Providing Cassandra With Permission To Directories | |
| 0306 Starting Cassandra | |
| 0307 Checking Status | |
| 0308 Accessing The Cassandra system.log File | |
| 0309 Pop Quiz |
| 0401 Understanding Ways To Communicate With Cassandra | |
| 0402 Using Cqlsh | |
| 0403 Pop Quiz |
| 0501 Understanding A Cassandra Database | |
| 0502 Defining A Keyspace | |
| 0503 Deleting A Keyspace | |
| 0504 Pop Quiz | |
| 0505 Lab: Create A Second Database |
| 0601 Creating A Table | |
| 0602 Defining Columns And Data Types | |
| 0603 Defining A Primary Key | |
| 0604 Recognizing A Partition Key | |
| 0605 Specifying A Descending Clustering Order | |
| 0606 Pop Quiz | |
| 0607 Lab: Create A Second Table |
| 0701 Understanding Ways To Write Data | |
| 0702 Using The INSERT INTO Command | |
| 0703 Using The COPY Command | |
| 0704 How Data Is Stored In Cassandra | |
| 0705 How Data Is Stored On Disk | |
| 0706 Pop Quiz | |
| 0707 Lab: Insert Data |
| 0801 Understanding Data Modeling In Cassandra | |
| 0802 Using A WHERE Clause | |
| 0803 Understanding Secondary Indexes | |
| 0804 Creating A Secondary Index | |
| 0805 Defining A Composite Partition Key | |
| 0806 Pop Quiz |
| 0901 Understanding Cassandra Drivers | |
| 0902 Exploring The DataStax Java Driver | |
| 0903 Setting Up A Development Environment | |
| 0904 Creating An Application Page | |
| 0905 Acquiring The DataStax Java Driver Files | |
| 0906 Getting The DataStax Java Driver Files Through Maven | |
| 0907 Providing The DataStax Java Driver Files Manually | |
| 0908 Connecting To A Cassandra Cluster | |
| 0909 Executing A Query | |
| 0910 Displaying Query Results - Part 1 | |
| 0911 Displaying Query Results - Part 2 | |
| 0912 Using An MVC Pattern | |
| 0913 Pop Quiz | |
| 0914 Lab: Create A Second Application - Part 1 | |
| 0915 Lab: Create A Second Application - Part 2 | |
| 0916 Lab: Create A Second Application - Part 3 |
| 1001 Updating Data | |
| 1002 Understanding How Updating Works | |
| 1003 Deleting Data | |
| 1004 Understanding Tombstones | |
| 1005 Using TTLs | |
| 1006 Updating A TTL | |
| 1007 Pop Quiz | |
| 1008 Lab: Update And Delete Data |
| 1101 Understanding Hardware Choices | |
| 1102 Understanding RAM And CPU Recommendations | |
| 1103 Selecting Storage | |
| 1104 Deploying In The Cloud | |
| 1105 Pop Quiz |
| 1201 Understanding Cassandra Nodes | |
| 1202 Having A Network Connection - Part 1 | |
| 1203 Having A Network Connection - Part 2 | |
| 1204 Having A Network Connection - Part 3 | |
| 1205 Specifying The IP Address Of A Node In Cassandra | |
| 1206 Specifying Seed Nodes | |
| 1207 Bootstrapping A Node | |
| 1208 Cleaning Up A Node | |
| 1209 Using cassandra-stress | |
| 1210 Pop Quiz | |
| 1211 Lab: Add A Third Node |
| 1301 Understanding Cassandra Monitoring Tools | |
| 1302 Using Nodetool | |
| 1303 Using JConsole | |
| 1304 Learning About OpsCenter | |
| 1305 Pop Quiz |
| 1401 Understanding Repair | |
| 1402 Repairing Nodes | |
| 1403 Understanding Consistency - Part 1 | |
| 1404 Understanding Consistency - Part 2 | |
| 1405 Understanding Hinted Handoff | |
| 1406 Understanding Read Repair | |
| 1407 Pop Quiz | |
| 1408 Lab: Repair Nodes For A Keyspace |
| Understanding Removing A Node | |
| Decommissioning A Node | |
| Putting A Node Back Into Service | |
| Removing A Dead Node | |
| Pop Quiz | |
| Lab: Put A Node Back Into Service |
| Redefining For Multiple Data Centers - Part 1 | |
| Redefining For Multiple Data Centers - Part 2 | |
| Changing Snitch Type | |
| Modifying cassandra-rackdc.properties | |
| Changing Replication Strategy - Part 1 | |
| Changing Replication Strategy - Part 2 | |
| Pop Quiz |
| Accessing Documentation | |
| Reading Blogs And Books | |
| Watching Video Recordings | |
| Posting Questions | |
| Attending Events | |
| Wrap Up |
Learning Modules
| Course Slides & Study Material | |
| Course Study Plan |
| Ui/UX Designers | |
| Front-End, Back-End, & Mobile Developers | |
| Project Manager & Scrum Master | |
| Roles in the Software Development Team Quiz |
| V-Model | |
| Agile Software Development | |
| Incremental & Iterative Development | |
| Introduction to Scrum | |
| Difference between Sequential, Iterative, & Incremental Development | |
| Summary | |
| How Software is Developed - Software Development Lifecycle Models Quiz |
| Difference between Static & Dynamic Testing | |
| Validation & Verification | |
| Objectives of Testing | |
| Testing & Debugging | |
| Test Process | |
| Test Levels | |
| Testing Types | |
| What's Next | |
| Basic Concepts of Software Testing Quiz |
| Creating Test Scenarios | |
| Tools to help in creating Test Scenarios | |
| Setting Up Trello | |
| Facebook Valid Sign Up Test Scenarios Part 2 | |
| Facebook Invalid Sign Up Test Scenarios Part 1 | |
| Facebook Invalid Sign Up Test Scenarios Part 2 | |
| Facebook Invalid Sign Up Test Scenarios Part 3 | |
| Facebook Login Valid Scenarios | |
| Facebook Invalid Login Scenarios | |
| Search Functionality [Udemy Test Scenarios] | |
| Category Search [Udemy Test Scenarios] | |
| Course Search [Udemy Test Scenarios] | |
| Instructor Search [Udemy] | |
| Test Scenario Conclusion | |
| Test Scenario Writing Quiz |
| Introduction to Black-Box Techniques | |
| Equivalence Partitioning Definition | |
| Equivalence Partitioning Examples | |
| Equivalence Partitioning Practical Examples | |
| Boundary-Value Analysis | |
| Boundary-Value Analysis Example #1 | |
| Note About Next Lecture | |
| Boundary-Value Analysis Example #2 | |
| Notes About Equivalence Partitioning & Boundary-Value Analysis | |
| Decision Table Testing | |
| Decision Table Testing Example | |
| State-Transition Testing | |
| Pairwise Testing | |
| Black Box Techniques Summary | |
| Black-Box Test Techniques Quiz |
| How to Write a Test Case | |
| Writing First Sign Up Test Case | |
| Valid Sign Up Test Cases | |
| Valid Sign Up Test Cases Part 2 | |
| Invalid Sign Up Test Cases Part 1 | |
| Invalid Sign Up Test Cases Part 2 | |
| Invalid Sign Up Test Cases Part 3 | |
| Test Case Document Link | |
| It's your turn! Write your own test cases. | |
| Task Solution | |
| Test Case Writing Quiz |
| Introduction to Zephyr Scale | |
| Signing Up to Jira | |
| Adding Zephyr Scale to Jira | |
| Creating Test Cases in Zephyr Scale | |
| Test Case Details | |
| Permissions | |
| Creating Folders | |
| Test Cycles | |
| Importing & Exporting Test Cases | |
| Configurations Part 1 | |
| Configurations Part 2 | |
| Reusing Test Cases - Call to Test | |
| Adding Parameters to Test Cases | |
| Creating BDD Test Cases | |
| Exporting Test Cases from Zephyr Scale to Cucumber | |
| Data-Driven Testing in Zephyr Scale | |
| Creating Data Sets in Zephyr Scale | |
| Clone, Archive & Delete Test Cases | |
| Creating Test Cases in Bulk | |
| Bidirectional Traceability in Zephyr Scale | |
| Tracking Progress using Test Cycles | |
| Editing, Cloning & Deleting Test Cycles | |
| Test Plans in Zephyr Scale | |
| Using AI to write & run Test Cases in Zephyr Scale | |
| Adjusting AI-based Test Cases | |
| Reports in Zephyr Scale | |
| Zephyr Scale Summary | |
| Zephyr Scale Quiz |
| Introduction to Defect Reporting | |
| Defect Report Writing | |
| Types of Defects | |
| Defect Triage Simulation | |
| Taking Screenshots & Recording Videos for the Defect Report | |
| Capturing Web Logs for the Defect Report | |
| Creating a Defect Report in Jira | |
| Creating a Defect Report in Azure DevOps | |
| Defect Lifecycle | |
| Accessibility Testing & Accessibility Defects using Axe DevTools | |
| Common Website Elements & Pages | |
| Conclusion & What's Next? | |
| Test Execution & Bug Reporting Quiz |
| Introduction to Test Reporting | |
| Know your Audience first | |
| Test Plan Template & Components | |
| Test Progress & Completion Reports | |
| Link to Sample Testing Report | |
| Testing Reports: Test Progress & Test Summary Report Quiz |
| Introduction | |
| Manual Tester Interview Questions | Q4 to Q6 | |
| Manual Tester Interview Questions | Q7 to Q9 | |
| Manual Tester Interview Questions | Q10 to Q12 | |
| Manual Tester Interview Questions | Q13 to Q15 | |
| Manual Tester Interview Questions | Q16 to Q18 | |
| Manual Tester Interview Questions | Q19 to Q21 | |
| Manual Tester Interview Questions | Q22 to Q24 | |
| Manual Tester Interview Questions | Q25 to Q27 | |
| Manual Tester Interview Questions | Q28 to Q30 | |
| Manual Tester Interview Questions | Q31 to Q33 | |
| Manual Tester Interview Questions | Q34 to Q36 | |
| Manual Tester Interview Questions | Q37 to Q39 | |
| Manual Software Testing Interview Questions Quiz |
| Introduction to Agile Project Management | |
| Agile 4 Values | |
| Agile 12 Principles | |
| Difference between Agile & Sequential Development | |
| Whole-Team Approach | |
| Early & Frequent Feedback | |
| Agile Requirements (Themes, Epics, & User Stories) | |
| INVEST Technique (How to review a User Story) | |
| Applying INVEST technique on a User Story | |
| Scrum Definition | |
| Scrum Practices | |
| Daily Stand-up Meeting | |
| Burn-down Chart | |
| Velocity Chart | |
| Retrospective Meeting | |
| Kanban | |
| Agile Testing Summary | |
| Basics of Agile & Agile Testing Quiz |
| Introduction and Overview about Jira | |
| Creating a Scrum Project & Adding User Stories to Backlog | |
| Creating Acceptance Criteria for Onboarding Screen | |
| Simulating Planning Poker for Onboarding Screen | |
| Reviewing Backlog and adding missing user stories | |
| Creating Location Service Acceptance Criteria | |
| Sign Up Acceptance Criteria | |
| Sprint Planning and Sprint Management | |
| Burn Up & Burn Down Chart | |
| Monitoring Sprint Progress & Velocity Chart | |
| Writing OTP Verification Acceptance Criteria | |
| Writing Acceptance Criteria for the rest of the application | |
| Exploratory Testing, Regression Testing, & Hardening(Stabilization) Iterations | |
| Kanban & Bug Tracking Projects in Jira | |
| Retrospective & Meeting Notes in Confluence | |
| How to use JIRA for Agile Testing |
| Types of Mobile Applications | |
| Types of Mobile Devices | |
| Mobile Testing Challenges | |
| Mobile Analytics Data | |
| Input Methods Test Scenarios | |
| Screen Orientation Test Scenarios | |
| Interrupts Test Scenarios | |
| Access Permissions for Device Features | |
| Testing for Power Consumption | |
| Testing for Notifications | |
| User Preferences provided by Operating System | |
| Interoperability & Co-Existence | |
| Various Connectivity Methods | |
| Installability Testing | |
| Performance Testing | |
| Usability Testing | |
| Conclusion | |
| Mobile Testing Basics Quiz |
| Introduction to API Testing | |
| Important Piece of Information | |
| What is an API? | |
| HTTP Protocol Basics | |
| XML Basics | |
| JSON Basics | |
| Comparison between JSON & XML | |
| SOAP & REST APIs | |
| HTTP Methods | |
| HTTP Status Codes | |
| API Testing Quiz |
| Introduction to Postman | |
| A journey inside Postman | |
| Adding Requests to Postman | |
| API Testing with Postman Quiz |
| Introduction to ReqRes Project | |
| Planning Tests for the Project | |
| Adding Requests to Postman | |
| Adding First Test Case | |
| Adding Tests to First Request Part 1 | |
| Adding Tests to First Request Part 2 | |
| Adding Tests to Second Request | |
| Adding tests to all Requests Part 1 | |
| Adding tests to all Requests Part 2 | |
| Sharing your Work |
| Trello API Project Introduction | |
| Create Board in Trello APIs | |
| Adding Key & Token as variables | |
| Creating Project Test Execution Schedule | |
| Delete a Board | |
| Adding Tests to Requests | |
| Postman Trello API Practical Project Quiz |
| What is Performance Testing | |
| Concept of Load Generation | |
| Creating Load Profiles | |
| Load Profiles Examples | |
| Performance Testing Quiz |
| How to Install JMeter | |
| Thread Group | |
| Samplers | |
| Listeners | |
| Adding Blazemeter Plugin | |
| Recording scripts using Blazemeter | |
| Replaying recorded scripts | |
| Difference between Average & Median | |
| Performance Testing using JMeter Quiz |
| Introduction | |
| Response time, Throughput, Utilization, & Robustness | |
| Performance Test Environment | |
| Serial & Parallel Execution of Threads | |
| User Defined Variables | |
| Action After Sampler Error | |
| Controllers - Simple Controller | |
| Loop Controller - Runtime Controller | |
| Throughput Controller - Once Only Controller - Interleave Controller | |
| Advanced Performance Testing using JMeter Quiz |
| Installing Java | |
| Installing Selenium | |
| Creating First Test Automation Script | |
| Browser Navigation | |
| Get Page Title & Get Page Source | |
| Different Selenium Projects | |
| Automating Different Browsers |
| Introduction & Printing a Message to the User | |
| Practical Exercise | |
| Variables in Java | |
| Data Types Part 1 | |
| Data Types Part 2 | |
| Primitive & Non-Primitive Data Types | |
| Getting Input from User | |
| Arithmetic Operations | |
| If Statement | |
| If...Else If | |
| Nested If | |
| Comparing more than One Condition | |
| Switch..Case | |
| Exercise on Conditional If & Switch Case | |
| For Loop | |
| While Loop | |
| Do...While Loop | |
| Introduction to Object-Oriented Programming | |
| Encapsulation | |
| Java programming for Software Testers Quiz |
| Introduction to Element Locators | |
| Finding Elements using ID | |
| Finding Elements using Name | |
| Finding Elements using ClassName | |
| Finding Elements using LinkText | |
| Finding Elements using Partial LinkText | |
| Finding Elements using TagName | |
| Finding Elements using XPath | |
| Finding Elements using CSS Selector | |
| Using Chropath to Locate Elements |
| Introduction to TestNG | |
| Writing First TestNG Test | |
| BeforeTest & AfterTest Annotations | |
| Creating TestNG XML File | |
| Priority Parameter |
| Introduction to Codeless Test Automation | |
| writing First Test Using Selenium IDE | Valid Login Scenario | |
| Codelss Test Automation using Selenium IDE Quiz |
| Introduction & Setup | |
| Exploring Katalon Studio Interface | |
| Writing First Test Case In Katalon Studio | |
| Adding Test Cases To Test Suites | |
| Taking Screenshots | |
| Test Automation Using Katalon Studio Quiz |
| What is SQL ? | |
| SELECT Command | |
| UPDATE Table | |
| INSERT INTO Table | |
| DISTINCT, IN, Not IN | |
| SUM, AVG, MIN, MAX | |
| LIKE, ORDER BY | |
| GROUP BY | |
| CREATE, ALTER, DROP Table | |
| INNER JOIN | |
| SQL For Testers Quiz |
| Introduction To Freelancing Websites | |
| Digivante Part 1 | |
| Digivante Part 2 | |
| TesterWork : Create Account & Add testing preferences | |
| TesterWork : Payout & Defects examples | |
| test.io: Registration Process | |
| test.io: Quiz & Apply to first project | |
| Freelance Testing websites Quiz |
| Introduction to Playwright | |
| Course Content | |
| Installing Playwright | |
| First Test with Playwright | |
| Important Playwright CLI Commands | |
| Clicking on Elements | |
| Ways of Writing Playwright Commands | |
| Playwright Annotations | |
| Focusing a Test | |
| Skipping a Test | |
| Tagging Tests | |
| Grouping Tests | |
| Playwright Configuration | |
| Creating a Global Configuration | |
| Using Configuration File | |
| Video Recording Tests Options | |
| Taking Screenshots | |
| Setting-Up Base-Url | |
| BeforeEach & AfterEach Hooks | |
| Customizing Node Scripts | |
| Executing Tests in Parallel Mode | |
| Customizing a Reporter in Playwright | |
| Playwright Built-in Reporters | |
| Introduction to Playwright Selectors | |
| Finding Locators | |
| Introduction to XPath Locators | |
| Locators Best Practices | |
| Introduction to Assertions | |
| Practicing Assertions | |
| Finding Assertions | |
| Exploring Playwright Documentation | |
| Playwright Inspector - Debugging Easily | |
| Debugging Selectors | |
| Recording Tests with Test Generator | |
| Authentication (Logging in Programmatically with Examples) | |
| Emulating Devices | |
| Using Traceviewer | |
| Other Emulation Options | |
| Local Configuration | |
| Additional CLI Options | |
| Parallelism & Shrading | |
| Retry Options | |
| Timeout Option | |
| Dealing with Checkboxes | |
| Dealing with Drag & Drop | |
| Dealing with Dropdown Lists | |
| Dealing with iFrames | |
| Downloading Files with Playwright | |
| Uploading Files with Playwright | |
| Generating PDFs using Playwright | |
| Hovering Over Elements | |
| Auto-waiting | |
| Dialogs with Playwright | |
| Installing Browsers | |
| NPX Playwright Options | |
| Opening Browsers with Playwright | |
| Other Input Fields | |
| Playwright Key Presses & Shortcuts | |
| Taking Screenshots through CLI | |
| Test Automation using Playwright Quiz |
| What is White Box Testing | |
| Statement Coverage | |
| Statement Coverage | Example #1 | |
| Statement Coverage | Example #2 | |
| Statement Coverage | Example #3 | |
| Statement Coverage | Example #4 | |
| Statement Coverage | Example #5 | |
| Statement Coverage | Example #6 | |
| Decision Coverage | |
| Decision Coverage | Example #1 | |
| Decision Coverage | Example #2 | |
| Decision Coverage | Example #3 | |
| Decision Coverage | Example #4 | |
| Statement & Decision Coverage Example using Python | |
| Condition Coverage | |
| Condition Coverage | Example #1 | |
| Condition Coverage Example #2 | |
| Path Coverage | |
| Path Coverage Example #1 | |
| Path Coverage Example #2 | |
| Path Coverage Example #3 | |
| Modified Condition Decision Coverage (MCDC) | |
| Loop Coverage | |
| White Box Test Techniques |
| What are the ISTQB Certificates? | |
| ISTQB Mobile Application Tester Certificate | |
| ISTQB Agile Certified Tester | |
| Your road to Certification | How to be a certified Tester Quiz |
| Writing a professional Tester CV | |
| Writing a cover letter | |
| Writing a Professional CV Quiz |
| Installation Process | |
| Installation Part 2 | |
| Vugen (Virtual User Generator) | |
| Controller | |
| Performance Testing using HP LoadRunner Quiz |
| Important note | |
| Introduction & Installation Process | |
| Mac Installation | |
| Create a Project | |
| Test Plan Document | |
| Builds & Releases | |
| Test Suites | |
| Test Case Writing | |
| Export & Import Test Suites & Test Cases to an XML File | |
| Assign Test Cases to a Test Plan | |
| Assign keywords to test cases | |
| Requirements Creation | |
| Platforms & Milestones | |
| Test Case Execution | |
| Testing Metrics & Reports | |
| How to use Testlink Quiz |
Learning Modules
Learning Modules
| Course Downloads |
| Creating a Local Lab Environment Using Vagrant and VirtualBox - Background | |
| Exercise 1 Instructions - Creating a Local Linux Shell Scripting Lab Environment | |
| Exercise 1 Walkthrough Part I Windows Users Only | |
| Exercise 1 Walkthrough Part I Mac Intel Users Only | |
| Exercise 1 Walkthrough Part I Linux (CentOS/RHEL) Users Only | |
| Exercise 1 Walkthrough Part I Mac Apple Silicon Users Only | |
| Exercise 1 Walkthrough Part II All Users, Except Apple Silicon Users | |
| Vagrant and VirtualBox Troubleshooting Tips |
| Section Introduction | |
| Getting Started with Shell Scripting: Naming, Permissions, Variables, Builtins. | |
| Special Variables, Pseudocode, Command Substitution, if Statement, Conditionals. | |
| Exit Statuses, Return Codes, String Test Conditionals, More Special Variables. | |
| Reading Standard Input, Creating Accounts, Username Conventions, More Quoting. | |
| Exercise 2 - Instructions | |
| Exercise 2 - Walkthrough |
| Random Data, Cryptographic Hash Functions, Text and String Manipulation. | |
| Positional Parameters, Arguments, for Loops, Special Parameters | |
| The while Loop, Infinite Loops, Shifting, Sleeping | |
| Exercise 3 - Instructions | |
| Exercise 3 - Walkthrough |
| Advanced Standard Input, Standard Output, and Standard Error - Part I | |
| Advanced Standard Input, Standard Output, and Standard Error - Part II | |
| Exercise 4 - Instructions | |
| Exercise 4 - Walkthrough |
| Case Statements | |
| Functions | |
| Parsing Command Line Options with getopts, Part 1 | |
| Parsing Command Line Options with getopts, Part 2 | |
| Deleting and Disabling Linux Accounts, Part 1 of 4 (Finding Files) | |
| Deleting and Disabling Linux Accounts, Part 2 of 4 (The userdel command) | |
| Deleting and Disabling Linux Accounts, Part 3 of 4 (Archives with tar) | |
| Deleting and Disabling Linux Accounts, Part 4 of 4 (Disabling Accounts) | |
| Deleting Users Exercise 5 Instructions | |
| Deleting Users Exercise 5 Walkthrough |
| Cut and Awk | |
| Cut and Awk Demonstration Script: Open Network Ports | |
| Sort and Uniq | |
| Parsing Log Files - Exercise 6 - Instructions | |
| Parsing Log Files - Exercise 6 - Walkthrough | |
| Sed |
| Configuring a Mini Network and Scripting for Remote Systems | |
| Scripting Remote Commands Exercise Instructions | |
| Scripting Remote Commands Walkthrough Part 1 | |
| Scripting Remote Commands Walkthrough Part 2 |
| Summary |
| What Shell Scripting Is and Why You Should Learn It |
| Bonus Lecture |
Learning Modules
| Where can I get the samples used in this course? |
| Note: About the Lab | |
| Start building your Lab - Create a Virtual Machine using VirtualBox | |
| Start building your Lab - Install CentOs | |
| Start building your Lab - Configure Putty | |
| Install Docker Compose | |
| Create a Docker Compose file for Jenkins | |
| Create a Docker Container for Jenkins | |
| Troubleshooting: Jenkins not coming up? | |
| Note: You should keep using putty | |
| Learn how to work with Docker and Jenkins | |
| Bonus |
| Introduction to Jenkins UI | |
| Keep playing with your first Job | |
| Redirect your first Job's output | |
| Learn how to execute a bash script from Jenkins | |
| Learn how to create a Jenkins list parameter with your script |
| Docker + Jenkins + SSH - I | |
| Troubleshooting: remote-host image not building correctly? | |
| Docker + Jenkins + SSH - II | |
| Docker + Jenkins + SSH - III | |
| Integrate your Docker SSH server with Jenkins | |
| Run your a Jenkins job on your Docker remote host through SSH |
| Introduction: MySQL + AWS + Shell Scripting + Jenkins | |
| Install MySQL Client and AWS CLI | |
| Create a MySQL Database | |
| Create a S3 Bucket on AWS | |
| Create a user (IAM) for AWS authentication | |
| Automate the backup and upload process with a shell script | |
| Integrate your script with AWS CLI | |
| Create a Jenkins job to upload your DB to AWS | |
| Execute your Job and be happy! | |
| Persist the script on the remote host | |
| Reuse your Job to upload different DB's to different buckets |
| Introduction: Jenkins + Ansible | |
| Install Ansible: Docker + Jenkins | |
| Make the ssh keys permanent on the Jenkins container | |
| Create a simple Ansible Inventory | |
| Create your first Ansible Playbook | |
| Integrate Ansible and Jenkins (Ansible Plugin) | |
| Power up! Add parameters to Ansible and Jenkins | |
| Missing the colors? Colorize your playbooks' output | |
| Challenge: Jenkins + Ansible + MySQL + PHP + NGINX + Shell Scripting | |
| Create the DB that will hold all the users | |
| Create a Bash Script to feed your DB - I | |
| Create a Bash Script to feed your DB - II | |
| Start building a Docker Nginx Web Server + PHP - I | |
| Start building a Docker Nginx Web Server + PHP - II | |
| Build a table using HTML, CSS and PHP to display users | |
| Integrate your Docker Web Server to the Ansible Inventory | |
| Test your playbook and see the magic! | |
| Ready? Let's create a Jenkins Job to build everything with a click! |
| Intro - Learn how to Enable/Disable Login in Jenkins | |
| Allow users to sign up | |
| Install a powerful security plugin | |
| Create users manually in the Jenkins DB | |
| Ever heard about roles? Let's create a Read Only role! | |
| Assign the role that you created to a particular user | |
| Create a role to execute jobs, and assign that role to your user | |
| Learn how to restrict Jobs to users using Project Roles. |
| Global environment variables in Jenkins | |
| Create your own custom global environment variables | |
| Modify the Jenkins URL | |
| Meet the Jenkins' cron: Learn how to execute Jobs automatically | |
| Learn how to trigger Jobs from external sources: Create a generic user | |
| Troubleshooting: Githooks throwing 403 forbidden errors? | |
| Trigger your Jobs from Bash Scripts (No parameters) | |
| Trigger your Jobs from Bash Scripts (With Parameters) |
| Introduction: Jenkins & Email | |
| Install a Mail Plugin | |
| Integrate Jenkins and AWS Simple Email Service | |
| Integrate Jenkins and Gmail | |
| Add notifications to your jobs |
| Introduction: Jenkins & Maven | |
| Install the Maven Plugin | |
| Install the GIT Plugin | |
| Learn how to clone a GIT/GITHUB repository from Jenkins | |
| Learn how to build a JAR using maven | |
| Learn how to test your code | |
| Deploy your Jar locally | |
| Display the result of your tests using a graph | |
| Archive the last successful artifact | |
| Send Email notifications about the status of your maven project |
| Create a Git Server using Docker | |
| Create your first Git Repository | |
| Create a Git User to interact with your Repository | |
| Upload the code for the Java App in your Repo | |
| Integrate your Git server to your maven Job | |
| Learn about Git Hooks | |
| Trigger your Jenkins job using a Git Hook |
| Introduction: Jenkins DSL | |
| Install the DSL Plugin | |
| What is a Seed Job in DSL? | |
| Understand the DSL Structure | |
| Description | |
| Parameters | |
| SCM | |
| Triggers | |
| Steps | |
| Mailer | |
| Recreate the Ansible Job using DSL | |
| Recreate the Maven Job using DSL | |
| Version your DSL code using Git | |
| Magic? Create Jobs only pushing the DSL code to your Git server! |
| Introduction to CI/CD | |
| Continuous Integration | |
| Continuous Delivery | |
| Continuous Deployment |
| Introduction to Pipeline | |
| Introduction to Jenkinsfile | |
| Install the Jenkins Pipeline Plugin | |
| Create your first Pipeline | |
| Add multi-steps to your Pipeline | |
| Retry | |
| Timeouts | |
| Environment variables | |
| Credentials | |
| Post actions |
| Introduction | |
| Learn how to install Docker inside of a Docker Container | |
| Define the steps for your Pipeline | |
| Build: Create a Jar for your Maven App using Docker | |
| Build: Write abash script to automate the Jar creation | |
| Build: Create a Dockerfile and build an image with your Jar | |
| Build: Create a Docker Compose file to automate the Image build process | |
| Build: Write a bash script to automate the Docker Image creation process | |
| Build: Add your scripts to the Jenkinsfile | |
| Test: Learn how to test your code using Maven and Docker | |
| Test: Create a bash script to automate the test process | |
| Test: Add your test script to Jenkinsfile | |
| Create a remote machine to deploy your containerized app | |
| Push: Create your own Docker Hub account | |
| Push: Create a Repository in Docker Hub | |
| Push: Learn how to Push/Pull Docker images to your Repository | |
| Push: Write a bash script to automate the push process | |
| Push: Add your push script to Jenkinsfile | |
| Deploy: Transfer some variables to the remote machine | |
| Deploy: Deploy your application on the remote machine manually | |
| Deploy: Transfer the deployment script to the remote machine | |
| Deploy: Execute the deploy script in the remote machine | |
| Deploy: Add your deploy script to Jenkinsfile | |
| Create a Git Repository to store your scripts and the code for the app | |
| Create the Jenkins Pipeline. Finally! | |
| Modify the path when mounting Docker volumes | |
| Create the Registry Password in Jenkins | |
| Add the private ssh key to the Jenkins container | |
| Add post actions to Jenkinsfile | |
| Execute your Pipeline manually | |
| Create a Git Hook to automatically trigger your Pipeline | |
| Start the CI/CD process by committing new code to Git! |
| More courses from Ricardo |
Learning Modules
| DevOps Project: Code, Steps, Documentation | |
| Know your Instructor! |
| Linux Basics | |
| DevOps Basics | |
| Desire to adopt DevOps Model |
| Git - Practical LAB |
| Bit Bucket Architecture | |
| Bit Bucket - Practical LAB |
| Maven Architecture | |
| Maven Build - Practical LAB |
| SonarQube Architecture | |
| Setup PostgreSQL - LAB | |
| SonarQube Analysis - Practical LAB |
| Jfrog Artifactory Architecture | |
| Jfrog Repository - Practical LAB |
| Apache Tomcat Architecture |
| Docker Architecture | |
| Build Container Image |
| Ansible Architecture | |
| Playbook Deployment - Create Container Image - LAB |
| Kubernetes Architecture | |
| Kubernetes - POD Deployment |
| Architecture | |
| Jenkins Installation - LAB | |
| Jenkins Pipeline Integration | |
| Prepare Deployment - Integrate Jenkins with Ansible and Kubernetes | |
| Jenkins Pipeline : Kubernetes Deployment integrate with Jenkins |
THE MEMBERS
Our Amazing Team
Prolytics amazing team is a group of dedicated professionals committed to excellence. With expertise, passion, and innovation, we empower students to achieve their goals, fostering a dynamic learning environment for future success.
Full Stack Development Courses Covered
Master essential Full Stack Development tools to build dynamic and scalable applications. Gain hands-on experience with advanced and latest tools. Our expert-led training ensures you stay ahead in the ever-evolving tech landscape, making you industry-ready.
TESTIMONIALS
What People Say
Prolytics transformed my career! The hands-on training and expert guidance helped me master industry-relevant skills. Thanks to their support, I landed a top IT job. Highly recommended!
Exceptional learning experience! Prolytics provided practical exposure, real-world projects, and in-depth knowledge. Their career support gave me the confidence to excel in my field.
Best institute for professional growth! The trainers were knowledgeable, the curriculum was industry-focused, and the learning environment was inspiring. Prolytics helped me achieve my dream career.
Highly valuable training programs! The courses were well-structured, up-to-date, and practical. Prolytics played a crucial role in my transition from a fresher to a skilled IT professional.
LOOKING FOR ENROLL NOW?
Register Course Online & Save Up To 20%!
Surprisigly great discounts, get enroll right now.
CALL US
NOW
7827272750