Full Stack Web Development - Gigabyte.

What is the internet?
How does the web work?
The role of HTML and CSS
Setting up a development environment (code editor, browser)
HTML Basics
Structure of an HTML document
Elements, attributes, and values

Text formatting (headings, paragraphs, emphasis)
Lists (ordered and unordered)
Links (anchors)
Images

Creating input fields (text, number, email, etc.)
Buttons (submit, reset)
Labels
Form validation

Introduction to CSS
Selectors (element, class, ID)
Properties and values
Styling text (font, color, size)
Styling elements (background, border, margin, padding)

Block, inline, and inline-block elements
Float and clear properties
CSS Grid
Advanced CSS Topics

Positioning (relative, absolute, fixed)
Units of measurement (pixels, percentages, ems, rems)
Color theory and color models
Media queries for responsive design

Plan and design a basic website (e.g., a personal portfolio or a score board)
Implement the HTML structure
Apply CSS styles for layout and appearance
Test and debug the website

What is JavaScript?
Why is it called JavaScript?
What can in-browser JavaScript do?
JavaScript and VS Code
Code structure

Variables: let, var, const
Data Types:
Number
String
Boolean
Null
Undefined
Objects
typeof operator
Operators:
Mathematical Operators & their precedence
Comparison Operators
Logical Operators

if statement
if...else statement (including ternary operator)
else if ladder
switch case

while loop
do...while loop
for loop

Functions:
Function Declaration
Local variables
Outer variables
Parameters
Default values
Returning a value
Naming a function  
Objects: the basics

Objects: continued
Strings: properties and methods

Arrays: creation, access, manipulation
Array functions: map, filter, reduce, etc.

Classes
Constructors
Getters and setters
Inheritance

Querying and selecting elements
Traversing elements
Creating elements
Updating elements
Removing elements

Event listeners
onClick event
Mouse events
Keyboard events

What is a database?
Define a database and its components (tables, records, fields)
Explain the role of a DBMS (Database Management System)
Introduction to SQL
SQL as a language for interacting with databases
Basic SQL syntax and structure
Common SQL commands (SELECT, FROM, WHERE, ORDER BY)
Data types in SQL
Numeric (INT, DECIMAL, FLOAT)
Character (CHAR, VARCHAR)
Date and Time (DATE, TIME, DATETIME)
Boolean (BIT)
Creating tables
Using the CREATE TABLE statement
Defining columns, data types, and constraints (PRIMARY KEY, FOREIGN KEY, NOT NULL)

Inserting data
Using the INSERT INTO statement
Handling NULL values
Updating data
Using the UPDATE statement
Updating multiple rows
Deleting data
Using the DELETE statement
Deleting rows based on conditions
Filtering data
Using the WHERE clause with comparison operators (=, <, >, <=, >=, !=)
Using logical operators (AND, OR, NOT)
Combining conditions

Sorting data
Using the ORDER BY clause to sort results
Ascending and descending order
Grouping data
Using the GROUP BY clause to group rows
Aggregate functions (COUNT, SUM, AVG, MIN, MAX)
Joins
Inner join, left join, right join, full outer join
Combining data from multiple tables
Subqueries
Nested queries within a SELECT, WHERE, or HAVING clause
Correlated subqueries

Indexes
Creating indexes to improve query performance
Types of indexes (clustered, non-clustered)
Performance tuning
Identifying performance bottlenecks
Query optimization techniques (explain plans, query rewriting)
Stored procedures
Creating and executing stored procedures
Passing parameters
Returning results
Functions
Creating and using functions
Scalar functions and table-valued functions

Transactions
Defining transactions
Committing and rolling back transactions
ACID properties
Atomicity, consistency, isolation, durability
Database design principles
Entity-relationship (ER) diagrams
Normalization (1NF, 2NF, 3NF)
Normalization techniques
Identifying functional dependencies
Eliminating anomalies

Database security
User accounts and permissions
Encryption
Auditing
Database backup
Creating backups
Restoring databases

Practice exercises
Applying SQL concepts to real-world scenarios
Troubleshooting common SQL errors
Question and answer Class
Addressing learners' questions and concerns

1. What is the .NET Framework?
2. Why use ?
3. Installing Visual Studio.
4. Creating a new Console App project
output & comments.

Variables
Constants
Data types
Type casting
Operators:
Arithmetic operators

operators continued:
Assignment Operators
Comparison Operators
Logical Operators
Control structures:
if statement
if...else statement
if...else ladder
switch case

Loops:
while loop
do...while loop
for loop
break and continue statements

Arrays
2D arrays
foreach loop

methods/functions:
Creating a method
Calling a method
Parameters and arguments
Default parameter values
Return values
Named arguments
Method overloading

What is OOP?
Classes and members
Constructors
Constructor parameters

Access modifiers
Encapsulation
Properties
Inheritance

Polymorphism
Abstraction
Interfaces

Exceptions: try...catch, throw
Generics: introduction, generic classes
Generic collections:
List
Dictionary
SortedList
Queue
Stack

Files and directories
Streams
Creating, opening, writing to, and reading from files
Serialization:
Object to binary file stream
Object to XML file stream
Object to JSON string

What is version control?
Why is it important?
What is Git?
What is GitHub?
Setting up Git and creating a GitHub account
Version control terminology:
Repository
Branch
Master
Stage
Commit
Clone
Push
Pull
Fetch
VS Code Integration

Staging and Committing Changes
Repository Management Commands
Branching and Merging
Viewing and Comparing Changes
Adding a Remote Repository

Working on an Existing Repository
Undoing Changes

Setting up the development environment
Creating a new ASP.NET Core Web API project
Understanding the project structure
Building a basic REST API endpoint
HTTP methods (GET, POST, PUT, DELETE)
JSON serialization and deserialization

Implementing CRUD operations (Create, Read, Update, Delete)
Handling HTTP status codes
Error handling and exception management
Data validation and input sanitization
Authentication and authorization (basic authentication, JWT)
Versioning REST APIs

Using HttpClient to make HTTP requests
Deserializing JSON responses
Asynchronous programming and task-based asynchronous pattern (TAP)
Consuming third-party APIs

What is React? Why use React?
React vs. other frameworks (Vue, Angular)
Setting up React using create-react-app
Overview of the folder structure
Running the first React app (npm start)
Introduction to JSX

What are React components? Functional vs. Class components
Creating a functional component
Understanding JSX and embedding expressions
Component properties (props)
Nesting and reusing components

What is state? Difference between state and props
Using the useState hook for functional components
Handling state updates
Conditional rendering based on state
Introduction to lifecycle methods (for awareness)

Handling events in React (onClick, onChange, etc.)
Passing arguments to event handlers
Handling form submission
Understanding synthetic events

Using conditional rendering (if-else, ternary operators)
Rendering lists using map
Using keys in lists
Dynamic list rendering and managing state

Introduction to React Router
Setting up routes
Navigation using Link and NavLink
Passing parameters to routes
Handling 404 pages

Inline styling
CSS stylesheets
CSS Modules
Styled-components (optional)
Best practices for styling React apps

Using fetch and axios for GET requests
Using useEffect for data fetching
Handling loading and error states
Displaying fetched data in components

Creating and submitting data using POST requests
Updating data with PUT requests
Deleting data with DELETE requests
Handling API responses and errors

What is Redux? Why use it?
Setting up Redux in a React app
Creating actions, reducers, and the Redux store
Connecting Redux to React components with useDispatch and useSelector

Introduction to Redux Thunk for async actions
Dispatching actions in asynchronous code
Handling API calls with Redux
Best practices for managing async actions

Authentication concepts (login, logout, user roles)
Handling user sessions using tokens (JWT)
Protecting routes using PrivateRoute components
Storing authentication state in Redux

Implementing role-based access (admin vs. user)
Using localStorage to persist user sessions
Logout functionality and session expiration
Handling authentication errors

Preparing the app for deployment (building the app)
Deploying to vercel
Handling environment variables for deployment

What is Cloud Computing?
Types of Clouds
Cloud Computing Models – SaaS / PaaS / IaaS
Data Centres and Availability Zones
Overview of a Cloud Platform (Microsoft Azure)
Exploring Various Cloud Resources

What is DevOps?
Azure DevOps Walkthrough

Continuous Integration
Continuous Deployment

AI and its Applications
Machine Learning Concepts
Difference Between Machine Learning and AI

Generative AI, LLM, and Prompt Engineering
Natural Language Processing
AI-Based Hands-on Project

Design and implement a user-friendly interface using modern web technologies

Build efficient database schemas using SQL or NoSQL databases.

Develop RESTful APIs for seamless frontend-backend communication.

Master version control and collaboration using Git.

Deploy your application to the Azure cloud for scalability and security.

Learn how to handle real-world interview scenarios thru practice sessions with tech leads and hiring managers from top-tier organizations.

Meet & Greet: Learn how to effectively greet the interviewers and establish the first impression.

How to Present Yourself: Learn how to present yourself professionally, including mastering body language, attire, and clear communication to make a strong first impression.

We will train you to answer complex technical questions confidently, emphasizing problem-solving and practical knowledge application.

Behavioral Questions: Learn how to respond to behavioral questions using the STAR method, showcasing your interpersonal skills, teamwork, and ability to handle workplace challenges

Project Summary: Provide a brief overview of the project's goals, objectives, and the problem it aims to solve. Highlight key features and the project's impact or outcome.

Roles and Responsibilities: Clearly state your role in the project, focusing on specific tasks or modules you were responsible for. Emphasize contributions like coding, testing, or deployment.

Tech Stack Used: Mention the technologies, frameworks, and tools used in the project. Explain why you chose this tech stack and how it contributed to the project’s efficiency and scalability.

OOP Concepts Implementation: Describe how you applied Object-Oriented Programming principles (Encapsulation, Abstraction, Inheritance, Polymorphism) in your project, and how it improved code structure and reusability.

OOP Concepts
Classes & Objects
Encapsulation
Inheritance
Constructors

Polymorphism
Interfaces
Abstraction

Arrays
String
List
Dictionary

Queue
Stack
Linked List
Space & Time Complexity

Recursive Functions
Searching Algorithms
Linear Search
Binary Search

Sorting Algorithms
Bubble Sort
Selection Sort

Sorting Algorithms:
Insertion Sort
Quick Sort

1. Introduction to Python
What is Python?
Applications of Python in the real world.
2. Setting Up Python Environment
Installing Python and IDEs (IDLE, VS Code).
Writing and running your first Python program.
3. Basic Syntax and Operations
Variables and data types (int, float, str, bool).
Input and output (input(), print()).
Basic arithmetic operations.
4. Hands-On Practice:
Write a program to calculate the area of a rectangle.
Create a program to greet the user.

1. Conditional Statements
if, elif, else statements.
Examples: Grade calculator, Discount eligibility validator.
2. Loops
for and while loops.
break, continue statements.
3. Logical Operators
and, or, not usage in conditions.
4. Hands-On Practice:
Write a program to calculate the factorial of a number.
Create a program to print multiplication tables.

1. Functions
Defining and calling functions.
Function arguments and return values.
2. Lists
Creating and modifying lists.
Basic list operations (append, remove, sort).
3. Dictionaries & Tuples
Creating dictionaries.
Accessing, adding, and updating dictionary items.
4. Hands-On Practice:
Create a program to manage a to-do list using lists.
Build a dictionary-based student record system.

1. File Handling Basics
Reading and writing text files.
Handling errors with try-except.
2. Mini Projects
Create a program to save and retrieve user notes.
Build a simple expense tracker.
3. Hands-On Practice
Write a program to log daily tasks into a file.
Read a file and count the number of words.

1. CapsStone Project.
A mini library management system.
2. Project Report.
Students present their projects to the group.