Basic CSS

• Inline CSS
• Internal CSS
• External CSS
• How to Debug CSS Code
• The Anatomy of CSS Syntax
• CSS Selectors
• Classes vs. Ids
• Text and Font
• Images In CSS
• Padding , margin
• px vs em vs rem

Intermediate CSS

• Flexbox
• Responsive UI
• Box Model

Javascript

• Basics: Variables, Data Types, Operators & Functions
• Efficient Development & Debugging
• Working with Control Structures (if Statements, Loops, Error Handling)
• Past (ES3, ES5) & Present (ES6+) of JavaScript
• Functions Advance
• Working with the DOM (Browser HTML Code) in JavaScript
• Arrays & Iterables
• Objects
• Class and OOPS
• Events
• Number and String
• Promises and call back
• Http request
• Js Tooling and workflow
• Browser storage
• Typescript intro

Bootstrap

• Intro
• Typography
• CSS Component
• Grid System
• Forms
• Tables
• Javascript Widget
• Project :1

Introduction to TypeScript

• Overview of TypeScript
• Why TypeScript?

Installation of tools

• Installing VS – an IDE
• Installing TypeScript using npm

Datatypes in TypeScript

• User-defined Datatypes
• Primitive Data types
• Tuples and Unions
• Variables and Operators

Decision Makers and Loops

• if, if-else, switch statements
• for, while loops
• forEach in TypeScript

Functions in TypeScript

• Defining and Calling a Function
• Returning functions
• Parameterized functions
• Arrow functions

Inbuilt methods in TypeScript

• String methods
• Array methods
• Other inbuilt methods

Oops in TypeScript

• Introduction to Classes and Objects
• Interfaces
• Inheritance

Winding up with TypeScript

• Revising the TypeScript Concepts
• Bridging TypeScript to Angular

Installation

• Angular Inroduction
• Installing the latest version of nodeJS
• Installing Angular 9 using a node package manager (npm)
• Installing an IDE like Visual studio code
• List of commands for creating, running and building a project

Angular Fundamentals

• Create a new Angular project
• Building blocks of angular
• The folder structure of an Angular Project
• Linking bootstrap with Angular
• Linking icons, fonts with the Projects

Angular Components and Modules

• Creating new components
• Structure of a component
• Calling a component
• Nesting components
• Component lifecycle
• Introduction to Modules

Displaying Data and Event Handling

• Interpolation
• Property Binding
• Attribute Binding
• Style Binding
• Event Binding
• Two way binding

Pipes

• InBuild pipes
• Custom Pipes

Component Communication

• Using @Input @output
• View child
• Reference variable
• Services

Directive

• ngIF
• ngFor
• ngClass
• ngStyle
• Custom Directive

Forms

• Template-driven forms
• Reactive forms
• Adding validations to forms
• Displaying error messages

Navigation using Routers

• Introduction to Angular routings
• Nested routes
• Relative path vs Absolute paths
• Lazy loading modules
• Pre-loading modules
• Preventing unauthorized access using protected routes

Angular Observables and RxJS

• Introduction to Observables
• Using observables to pass data
• Type-ahead suggestions using Observables
• Introduction to RxJS library

Server Interactions using HTTP

• Creating a Service
• Introduction to Http Client Services
• HTTP get vs post
• Requesting and sending data to the server
• Sending get Request
• Sending put Request
• Adjusting Request Headers

Deployment of the Application

• Building the Application
• Steps to host the application on some server
• Hosting the Application

Building a Real-time Application

• Creating the Project Setup
• Creating modules and grouping Components
• Implementing Lazy Loading and adding Routings
• Adding necessary Material Components
• Completing the contents
• Hosting the Website

Introduction

• Required Javascript
• Modules
• var/let/const
• Arrow function
• Export and Import
• Understanding Classes
• Spread operator
• Array

React Fundamentals

• Modules
• Components
• Project Creation
• JSX
• React Works
• Custom Components
• Adding Basic CSS Styling
• Outputting Dynamic Data
• Passing Data via "props"
• Splitting Components
• Splitting Components
• Organizing Files

Events

• Key Events
• Listening to Events & Working with Event Handlers
• Working with "State"
• "useState" Hook
• Form Inputs
• Listing Form Inputs
• Working with Multiple States
• Using One State Instead
• Handling Form Submission
• Adding Two-Way Binding
• Child-to-Parent Component Communication (Bottom-up)
• Lifting The State Up

List Rendering

• Rendering List Data in UI
• Using Stateful Lists
• Using "Keys"
• Conditional Content
• Adding Conditional Return Statements
• Adding Dynamic Styles

Styling React Components

• Dynamic Inline Styles
• CSS Classes Dynamically
• Introducing Styled Components
• Styled Components & Dynamic Props
• Styled Components & Media Queries
• Using CSS Modules
• Dynamic Styles with CSS Modules

Debugging

• Understanding React Error Messages
• Analyzing Code Flow & Warnings
• Working with Breakpoints

Fragment, Portal & Ref

• Creating a Wrapper Component
• React Fragments
• Introducing React Portals
• Working with Portals
• Working with "ref"s
• Controlled vs Uncontrolled Components

Handing Side Effects, Using Reducer & Using the context api

• What are "Side Effects" & Introducing useEffect
• Using the useEffect() Hook
• useEffect & Dependencies
• Using the useEffect Cleanup Function
• Using the useReducer() Hook
• useReducer & useEffect
• Adding Nested Properties As Dependencies To useEffect
• useReducer vs useState for State Management
• Using the React Context API
• Making Context Dynamic
• Building & Using a Custom Context Provider Component
• Learning the "Rules of Hooks"

Optimization Technique

Class-based Component

• Class-based Component
• Working with State & Events
• The Component Lifecycle (Class-based Components Only!)
• Lifecycle Methods In Action
• Class-based Components & Context

HTTP Calls

• Connecting Backend
• Sending a GET Request
• Using async / await
• Handling Loading & Data States
• Handling Http Errors
• Using useEffect() For Requests
• Sending a POST Request
• Sending a PUT Request

Building Custom react hook

Working with forms and user input

• Form Submission
• Getting User Input Values
• Adding Basic Validation
• Providing Validation Feedback
• Managing The Overall Form Validity
• Applying Hook

Redux

• Advanced Redux
• React Router

Installing React Router

• Defining & Using Routes
• Working with Links
• Using NavLinks
• Adding Dynamic Routes with Params
• Extracting Route Params
• Using "Switch" and "exact" For Configuring Routes
• Nested Routes
• Adding a "Not Found" Page
• Working with Query Parameters
• Getting Creative With Nested Routes
• Writing More Flexible Routing Code

Introduction

• Overview of Node.js
• Node.js Environment Setup
• Understanding Node.js Architecture and Event-Driven I/O
• Running Your First Node Script

JavaScript Essentials for Node.js

• Variables (var, let, const)
• Arrow Functions and Scope in Node.js
• Modules (require and module.exports)
• Export and Import (ES6 syntax with Node support)

Node.js Core Modules

• Working with File System (fs)
• Working with Path Module
• Working with Events and EventEmitter
• Using HTTP Module
• Using OS Module
• Using URL Module

Building HTTP Servers

• Creating a Basic HTTP Server
• Handling Requests and Responses
• Working with URL Parameters and Query Strings
• Serving HTML Files and Static Assets
• Implementing Routing Basics without Frameworks

Working with Asynchronous Code

• Callbacks and Callback Hell
• Promises and Async Patterns in Node
• async/await for Clean Asynchronous Code

Express.js Fundamentals

• Installing and Setting Up Express
• Routing with Express
• Middleware Basics (Body Parsing, Logging, etc.)
• Serving Static Files in Express
• Handling Errors and Creating Error Handlers
• Using Request and Response Methods

Working with APIs

• Creating RESTful APIs with Express
• GET, POST, PUT, DELETE Requests
• Sending JSON Data
• Working with Postman for API Testing

Data Handling and Databases

• Introduction to Databases (SQL and NoSQL)
• Setting up MongoDB or MySQL Database
• Using Mongoose or Sequelize ORM
• Performing CRUD Operations with a Database
• Data Validation with Joi or Validator.js
• Querying Databases

Advanced Data Handling

• Working with File Uploads in Node
• Handling Data Validation and Sanitization
• Pagination and Filtering Data in APIs

Working with Authentication

• Introduction to Authentication and Authorization
• Using JSON Web Tokens (JWT)
• Setting up User Registration and Login
• Implementing Password Hashing with bcrypt
• Role-Based Access Control

Session Management and Security

• Using Sessions and Cookies
• Cross-Site Scripting (XSS) Protection
• Cross-Site Request Forgery (CSRF) Protection
• Environment Variables and Security Configuration

Advanced Express

• Setting up Advanced Routing
• Using Router-level Middleware
• Creating Modular and Organized Code Structure
• Error Handling with Custom Error Classes

Real-Time Data with WebSockets

• Introduction to WebSocket
• Using Socket.io for Real-Time Data Transfer
• Building a Basic Chat Application

Unit Testing and Debugging

• Setting up Testing Environment with Jest or Mocha
• Writing Unit Tests and Integration Tests
• Testing with Supertest
• Debugging Node.js Applications with Debugger and Console Logging

Working with Node CLI

• Creating a Command-Line Interface (CLI)
• Parsing CLI Arguments
• Building Interactive CLI Tools with Inquirer.js

Building and Using Custom Middleware

• Understanding the Middleware Pattern
• Creating Custom Middleware for Logging, Authentication, etc.
• Using Third-Party Middleware

Error Handling and Debugging

• Structured Error Handling in Node.js
• Using the Express Error Handling Middleware
• Understanding and Using HTTP Status Codes
• Debugging Techniques for Production

Deploying Node.js Applications

• Preparing for Production Deployment
• Using PM2 for Process Management
• Setting up Environment Variables in Production
• Introduction to Dockerizing Node.js Apps
• Deploying to Cloud Providers (e.g., Heroku, AWS)

Optimization and Best Practices

• Understanding Event Loop and Concurrency
• Using Clustering for Scaling Node.js Apps
• Avoiding Memory Leaks
• Best Practices for Folder Structure
• Security Best Practices (Helmet.js, Rate Limiting, etc.)

Node.js Frameworks and Tools

• Introduction to Other Frameworks like NestJS
• Comparing Frameworks: Express vs. Koa
• Integrating with GraphQL (optional)

Microservices with Node.js

• Introduction to Microservices Architecture
• Setting up a Basic Microservice
• Communicating Between Microservices
• API Gateway and Load Balancing
• Using Redis for Caching and Pub/Sub

Building Advanced Features and Custom Modules

• Creating and Publishing Your Own NPM Modules
• Advanced Authentication: OAuth (Google, Facebook, etc.)
• Building Background Jobs with Bull or Agenda

Introduction to MongoDB

• What is MongoDB?
• NoSQL vs. SQL Databases
• Document-Based Data Model

Installing MongoDB and Setting Up

• Running MongoDB Locally and Accessing MongoDB CLI
• Setting Up a Free MongoDB Cluster on MongoDB Atlas

Connecting Node.js to MongoDB

• Installing MongoDB Node.js Driver
• Creating a MongoDB Connection in Node.js
• Using MongoDB Atlas with Node.js
• Handling Connection Errors

MongoDB Basics

• Understanding Databases and Collections
• Documents and the BSON Format
• Inserting Data with insertOne and insertMany
• Reading Data with findOne and find
• Updating Data with updateOne and updateMany
• Deleting Data with deleteOne and deleteMany

Working with Queries

• Filtering Data with Query Operators ($eq, $gt, $lt, etc.)
• Using Logical Operators ($or, $and, $not)
• Projection to Select Specific Fields
• Sorting Results with sort
• Limiting Results with limit
• Pagination with skip and limit

Advanced Data Modeling

• Embedded Documents vs. References
• One-to-One, One-to-Many, and Many-to-Many Relationships
• Schema Design Best Practices in MongoDB
• Data Normalization vs. Denormalization
• Using the $lookup Operator for Aggregation-Based Joins

Indexing in MongoDB

• Introduction to Indexes and Performance Benefits
• Creating Indexes with createIndex
• Types of Indexes: Single-Field and Compound Indexes
• Text Indexes for Full-Text Search
• Understanding and Using Geospatial Indexes
• Analyzing Query Performance with Explain

Aggregation Framework

• Introduction to the Aggregation Pipeline
• Common Aggregation Operators ($match, $group, $project, $sort)
• Using Pipelines for Complex Data Transformations
• Grouping Data with $group and $sum
• Filtering Data in Aggregation with $match
• Combining Multiple Aggregation Stages

Working with Mongoose (ODM)

• Installing and Setting Up Mongoose
• Creating Schemas and Models
• Defining Data Types and Validations
• Adding Custom Schema Methods and Statics
• Using Virtuals for Derived Properties
• Pre and Post Middleware (Hooks) in Mongoose

CRUD Operations with Mongoose

• Creating Documents with .save() and .create()
• Reading Documents with .find(), .findOne(), and Query Methods
• Updating Documents with .updateOne(), .updateMany(), and .findByIdAndUpdate()
• Deleting Documents with .deleteOne(), .deleteMany(), and .findByIdAndDelete()

Validation and Error Handling

• Built-in Schema Validations
• Custom Validations in Mongoose
• Error Handling in MongoDB and Mongoose
• Handling Unique Constraints and Duplicate Key Errors
• Defining Default Values in Schema

Schema Relationships with Mongoose

• One-to-One, One-to-Many, and Many-to-Many Relationships
• Referencing Documents with ObjectId
• Populate Method for Document Referencing
• Nesting Schemas for Embedded Documents
• Using populate() for Parent-Child Relationships

Advanced Mongoose Queries

• Query Helpers and Advanced Query Customizations
• Using Aggregation in Mongoose
• Working with GeoJSON and Geospatial Queries
• Lean Queries for Performance Optimization
• Pagination with Mongoose Plugins

Transactions in MongoDB

• Introduction to ACID Transactions in MongoDB
• Setting Up and Using Transactions in Node.js
• Error Handling and Rollbacks in Transactions
• Limitations and Best Practices for Transactions

Indexing and Optimization

• Choosing Optimal Indexes in Mongoose
• Using Compound Indexes in Schema
• Managing Unique Indexes
• Monitoring Query Performance with Mongoose
• TTL (Time-to-Live) Indexes for Expiring Data

Data Backup and Restore

• Exporting and Importing Data with mongodump and mongorestore
• Backup Strategies for Production
• Using MongoDB Atlas Backup Services
• Automating Backups

Security Best Practices

• Authentication and Authorization in MongoDB
• Setting Up Role-Based Access Control (RBAC)
• Encrypting Data at Rest and In Transit
• Using Environment Variables for Sensitive Configs
• Regularly Updating MongoDB for Security Patches

Deployment and Scaling

• Deploying MongoDB on Docker
• Configuring MongoDB for Replica Sets
• Sharding for Scalable Databases
• Optimizing MongoDB on Cloud Services
• Using MongoDB Atlas for Managed Clusters

Introduction

• Overview of Full-Stack Development
• Benefits of Using Java for Full-Stack Development
• Introduction to Front-End and Back-End Technologies
• Setting Up the Development Environment

Java Basics and Core Concepts

• Introduction to Java Programming
• Basic Syntax and Data Types
• Control Flow Statements: Loops, Conditionals
• Object-Oriented Programming Concepts
• Classes and Objects
• Exception Handling
• Collections Framework (Lists, Maps, Sets)

Building the Back-End with Java

• Introduction to Java Enterprise Edition (Java EE)
• Working with Java Servlets and JSP (JavaServer Pages)
• Introduction to Spring Framework
• Overview of Spring
• Spring Boot for Rapid Application Development
• Dependency Injection
• Spring MVC: Controllers, Views, and Models
• Working with Databases
• Introduction to JDBC (Java Database Connectivity)
• Using JPA (Java Persistence API) and Hibernate
• CRUD Operations and Transactions

Creating RESTful APIs with Spring Boot

• Introduction to RESTful Web Services
• Building REST APIs with Spring Boot
• Handling HTTP Requests and Responses
• Implementing CRUD Operations in REST APIs
• API Documentation with Swagger
• Securing APIs with Spring Security

Front-End Development Basics

• Introduction to Front-End Technologies
• HTML5: Structure and Semantics
• CSS3: Styling and Layout Techniques
• JavaScript Basics: Syntax, DOM Manipulation, Events
• Responsive Design Principles

Building Modern Front-End with JavaScript Frameworks

• Introduction to Front-End Frameworks
• Working with React.js
• CSS3: Styling and Layout Techniques
• Setting Up React with Create React App
• Components, Props, and State
• Handling Events and Forms
• React Hooks: useState, useEffect
• Routing with React Router
• State Management with Redux (optional)

Integrating Front-End and Back-End

• Connecting React.js with Spring Boot APIs
• Using Axios or Fetch for HTTP Requests
• Handling Responses and Updating UI
• Implementing Authentication and Authorization
• Managing State and Handling Errors

Building and Deploying the Full-Stack Application

• Integrating Front-End and Back-End
• Full-Stack Project Architecture
• Connecting Front-End and Back-End
• Handling Data Flow Between Client and Server
• Deployment Strategies
• Packaging and Deploying Java Applications
• Hosting Front-End Applications
• Using Cloud Platforms (e.g., Heroku, AWS, Azure)
• Continuous Integration/Continuous Deployment (CI/CD) Basics

Advanced Topics and Best Practices

• Performance Optimization Techniques
• Testing in Full-Stack Development
• Unit Testing with JUnit and Mockito
• Front-End Testing with Jest and React Testing Library
• Integration and End-to-End Testing
• Best Practices for Security, Scalability, and Maintainability

Project Work and Final Assessment

• Guided Project: Building a Complete Full-Stack Application
• Project Requirements and Specifications
• Development Phases: Planning, Design, Implementation, Testing
• Code Reviews and Feedback
• Final Assessment
• Demonstrating Knowledge and Skills
• Project Presentation and Evaluation

Introduction

• Overview of Full-Stack Development
• Benefits of Using Python for Full-Stack Development
• Introduction to Front-End and Back-End Technologies
• Setting Up the Development Environment

Python Basics and Core Concepts

• Introduction to Python Programming
• Basic Syntax and Data Types
• Control Flow Statements: Loops, Conditionals
• Functions and Modules
• Object-Oriented Programming Concepts
• Classes and Objects
• Inheritance, Polymorphism, Encapsulation, Abstraction
• Exception Handling
• Working with Collections (Lists, Dictionaries, Sets)

Building the Back-End with Python

• Introduction to Web Frameworks in Python
• Working with Flask
• Overview of Flask
• Setting Up Flask Project
• Routing and Views
• Handling Forms and User Input
• Session Management
• Introduction to Django
• Overview of Django
• Setting Up Django Project
• Django Models, Views, and Templates (MVT)
• Django ORM (Object-Relational Mapping)
• User Authentication and Authorization

Creating RESTful APIs with Flask and Django

• Introduction to RESTful Web Services
• Building REST APIs with Flask
• Overview of Flask
• Using Flask-RESTful or Flask-RESTX
• Handling HTTP Requests and Responses
• Implementing CRUD Operations
• API Documentation with Swagger or OpenAPI
• Building REST APIs with Django
• Using Django REST Framework (DRF)
• Serializers and ViewSets
• Handling Authentication and Permissions

Front-End Development Basics

• Introduction to Front-End Technologies
• HTML5: Structure and Semantics
• CSS3: Styling and Layout Techniques
• JavaScript Basics: Syntax, DOM Manipulation, Events
• Responsive Design Principles

Building Modern Front-End with JavaScript Frameworks

• Introduction to Front-End Frameworks
• Working with React.js
• Setting Up React with Create React App
• Components, Props, and State
• Handling Events and Forms
• React Hooks: useState, useEffect
• Routing with React Router
• State Management with Redux (optional)

Integrating Front-End and Back-End

• Connecting React.js with Flask/Django APIs
• Using Axios or Fetch for HTTP Requests
• Handling API Responses and Updating UI
• Implementing Authentication and Authorization
• Managing State and Handling Errors

Building and Deploying the Full-Stack Application

• Integrating Front-End and Back-End
• Full-Stack Project Architecture
• Connecting Front-End and Back-End
• Handling Data Flow Between Client and Server
• Deployment Strategies
• Packaging and Deploying Python Applications (Flask/Django)
• Hosting Front-End Applications
• Using Cloud Platforms (e.g., Heroku, AWS, Azure)
• Continuous Integration/Continuous Deployment (CI/CD) Basics

Advanced Topics and Best Practices

• Performance Optimization Techniques
• Testing in Full-Stack Development
• Unit Testing with Pytest for Python
• Front-End Testing with Jest and React Testing Library
• Integration and End-to-End Testing
• Best Practices for Security, Scalability, and Maintainability

Project Work and Final Assessment

• Guided Project: Building a Complete Full-Stack Application
• Project Requirements and Specifications
• Development Phases: Planning, Design, Implementation, Testing
• Code Reviews and Feedback
• Final Assessment
• Demonstrating Knowledge and Skills
• Project Presentation and Evaluation

Tools

• GitHub
• Jira
• Basic photoshop
• npm