DEV Community: Baviya Varshini V

AWS Braket- AWS SERVICE

Baviya Varshini V — Thu, 18 Dec 2025 17:20:55 +0000

🔹 Service Overview

AWS Braket is a fully managed quantum computing service that lets developers, researchers, and enterprises build, test, and run quantum algorithms using real quantum hardware and high-performance simulators—all from AWS. You don’t manage quantum infrastructure; AWS provides access to multiple quantum technologies through a single API.

🔹 Key Features

1. Multiple Quantum Hardware Providers
Superconducting, trapped-ion, and neutral-atom devices

2. Quantum Simulators
Local simulators and managed simulators (state-vector, tensor network)

3. Unified SDK
Write once, run on simulators or real QPUs

4. Hybrid Workflows
Combine classical compute (EC2) with quantum tasks

5. Security & IAM Integration
Native AWS IAM, VPC, encryption

6. Experiment Tracking
Job history, results, and reproducibility

🔹AWS Category / Cloud Domain

Primary Category: Emerging Technologies

Cloud Domain:

Quantum Computing
Research & Advanced Computing
AI/ML (experimental & future-facing)

🔹 Where It Fits in the Cloud / DevOps Lifecycle
AWS Braket fits early-stage R&D and experimentation phases:

Research & Prototyping
Explore quantum algorithms (QAOA, VQE, Grover’s, etc.)

Development
Develop algorithms locally → test on simulators

Experimentation
Run workloads on real quantum hardware

Hybrid Optimization
Integrate with classical pipelines (EC2, Lambda, S3)

Future Production (Long-term)
Prepare teams for quantum-ready applications

🔹 Programming Language / Access Methods

✅ Primary Language
Python (via Amazon Braket SDK)

✅ Access Methods

AWS Console
AWS SDK (Boto3)
Python Braket SDK
Jupyter Notebooks (Amazon SageMaker compatible)
REST APIs (indirect via SDKs)

Example (Python – Simple Quantum Circuit)

from braket.circuits import Circuit

circuit = Circuit().h(0).cnot(0, 1)
print(circuit)

🔹 Pricing Model

AWS Braket uses a pay-as-you-go model:

💰 Cost Components

Simulator Usage
Charged per task and runtime

Quantum Hardware Usage

Charged per shot (execution)
Pricing varies by hardware provider

Storage
Results stored in Amazon S3 (standard S3 pricing)

🔹 Why Developers Should Care

Learn future-ready quantum skills
Experiment without owning quantum hardware
Strong integration with existing AWS workflows
Ideal for students, researchers, and advanced engineers

✨ Final Takeaway

AWS Braket is not about replacing classical computing today—it’s about preparing developers for the quantum future.If you’re curious about next-gen computing, Braket is AWS’s official gateway.

BMC Helix ITSM – Developer-Friendly Overview

Baviya Varshini V — Thu, 18 Dec 2025 16:19:05 +0000

🔹 What is BMC Helix ITSM?

BMC Helix ITSM is an enterprise-grade IT Service Management (ITSM) platform used to manage IT operations such as incidents, changes, problems, assets, and service requests.
It is built to support modern cloud, hybrid, and on-prem environments with automation and AI capabilities.
It follows ITIL best practices and is widely used by large enterprises to ensure stable, reliable IT services.

🔹 Key Features
1️⃣ Core ITSM Capabilities

Incident Management
Problem Management
Asset Management
CMDB (Configuration Management Database)

2️⃣ Automation & Intelligence

AI-based ticket classification and routing
Predictive analytics for incidents and changes
Workflow automation to reduce manual effort

3️⃣ User Experience

Self-service portal
Digital workplace
Role-based dashboards

4️⃣ Integration Support

REST APIs
Integration with monitoring, CI/CD, and cloud platforms
Works with DevOps and ITOM tools

🔹 How BMC Helix ITSM Fits into DevOps / DevSecOps

BMC Helix ITSM acts as a bridge between development, operations, and security teams.

✔ DevOps Integration

Links incidents and change requests with CI/CD pipelines
Helps track issues caused by deployments
Improves collaboration between developers and operations

✔ DevSecOps Support

Security incidents can be handled using the same ITSM workflows
Centralized visibility of operational and security events
Supports compliance and audit requirements.

🔹 Programming Languages & Technology Stack

BMC Helix ITSM is not a developer framework, so it does not expose a single programming language.
Internally, it is built using:

1. Cloud-native microservices architecture

2. Web technologies (PWA – Progressive Web App)

🔹 Parent Company

BMC Helix ITSM is developed by BMC Helix, Inc.
Originally part of BMC Software, a well-known enterprise IT solutions company.
BMC Helix became a focused cloud-first brand under BMC.

🔹 Is It Open Source or Paid?

❌ Not Open Source
✅ Commercial / Paid Tool

Proprietary enterprise software
Available as SaaS (cloud) or on-premises
Licensed based on users and features

🔹 Why Developers Should Care

Even though BMC Helix ITSM is not a coding tool:
Developers interact with it through incident tickets, change requests, and APIs.Important for DevOps, SRE, Cloud Engineers, and Security Engineers
Commonly used in MNCs and enterprise environments.

✨ Final Takeaway

BMC Helix ITSM is a powerful enterprise ITSM platform that ensures stable operations, while seamlessly supporting DevOps and DevSecOps workflows through automation, integration, and intelligence.

CRUD (Create, Read, Update, Delete) operations in MongoDB using a simple college student schema.

Baviya Varshini V — Sun, 05 Oct 2025 07:50:11 +0000

To gain hands-on experience in performing CRUD (Create, Read, Update, Delete) operations in MongoDB using a simple college student schema.

🧱 Schema (Collection: students)

Each document follows this structure:

{
  "student_id": "S001",
  "name": "Santhosh",
  "age": 20,
  "department": "CSBS",
  "year": 2,
  "cgpa": 9
}

⚙️ 1️⃣ CREATE (INSERT)
Insert at least 5 student records into the students collection:

db.students.insertMany([
  {
    "student_id": "S001",
    "name": "Santhosh",
    "age": 20,
    "department": "CSBS",
    "year": 2,
    "cgpa": 9
  },
  {
    "student_id": "S002",
    "name": "Baviya",
    "age": 19,
    "department": "CSE",
    "year": 1,
    "cgpa": 8.7
  },
  {
    "student_id": "S003",
    "name": "Karthik",
    "age": 21,
    "department": "ECE",
    "year": 3,
    "cgpa": 7.2
  },
  {
    "student_id": "S004",
    "name": "Anu",
    "age": 20,
    "department": "CSE",
    "year": 2,
    "cgpa": 9.3
  },
  {
    "student_id": "S005",
    "name": "Ravi",
    "age": 22,
    "department": "MECH",
    "year": 3,
    "cgpa": 6.8
  }
])

🔍 2️⃣ READ (QUERY)

Find all students with CGPA > 8:

db.students.find({ cgpa: { $gt: 8 } }).pretty()

Find students belonging to the Computer Science department:

db.students.find({ department: { $in: ["CSE", "CSBS"] } }).pretty()

✏️ 3️⃣ UPDATE
(a) Update the CGPA of a specific student

db.students.updateOne(
  { student_id: "S002" },
  { $set: { cgpa: 9.1 } }
)

(b) Increase the year of study for all 3rd-year students by 1

db.students.updateMany(
  { year: 3 },
  { $inc: { year: 1 } }
)

🗑️ 4️⃣ DELETE
(a) Delete one student record by student_id:

db.students.deleteOne({ student_id: "S005" })

(b) Delete all students having CGPA < 7.5

db.students.deleteMany({ cgpa: { $lt: 7.5 } })

AFTER DELETION:

💾 Understanding ACID Properties in Databases with SQL Examples

Baviya Varshini V — Sun, 05 Oct 2025 06:22:14 +0000

In this post, I’ll demonstrate ACID properties — Atomicity, Consistency, Isolation, and Durability — using a simple Accounts table and a few SQL commands.

Let’s dive in 👇

🧾 1. Table Creation

CREATE TABLE Accounts (
  acc_no INT PRIMARY KEY,
  name VARCHAR(50),
  balance INT CHECK (balance >= 0)
);

🧩 2. Insert Sample Data

INSERT INTO Accounts VALUES (101, 'Baviya', 3000);
INSERT INTO Accounts VALUES (102, 'Karthik', 4000);
INSERT INTO Accounts VALUES (103, 'Anu', 7000);

⚙️ 3. Atomicity Test (All or Nothing)

Goal: Start a transaction to transfer ₹1000 from Baviya to Karthik but rollback midway — no changes should remain.

-- Start Transaction
START TRANSACTION;

-- Subtract 1000 from Baviya
UPDATE Accounts SET balance = balance - 1000 WHERE acc_no = 101;

-- Add 1000 to Karthik
UPDATE Accounts SET balance = balance + 1000 WHERE acc_no = 102;

-- Now ROLLBACK (cancel transaction)
ROLLBACK;

-- Check balances again
SELECT * FROM Accounts;

🧱 4. Consistency Test (Valid State → Valid State)

Goal: Try inserting invalid (negative) balance.

INSERT INTO Accounts VALUES (104, 'InvalidUser', -500);

🔒 5. Isolation Test (One transaction shouldn’t see another’s uncommitted changes)
Session 1:

START TRANSACTION;
UPDATE Accounts SET balance = balance - 500 WHERE acc_no = 101;
-- Don’t commit yet!

Session 2:

SELECT * FROM Accounts WHERE acc_no = 101;
COMMIT;

💾 6. Durability Test (Data survives restart)

START TRANSACTION;
UPDATE Accounts SET balance = balance + 200 WHERE acc_no = 103;
COMMIT;

SELECT * FROM Accounts WHERE acc_no = 103;

✅ Conclusion

We successfully verified all ACID properties:

💾 Transactions, Deadlocks & Log-Based Recovery (Hands-on SQL Guide)

Baviya Varshini V — Fri, 03 Oct 2025 07:29:43 +0000

Databases guarantee data consistency using ACID properties.
In this blog, we’ll explore Transactions, Deadlocks, and Log-Based Recovery with simple examples.

We’ll use the following schema:

CREATE TABLE Accounts (
    acc_no INT PRIMARY KEY,
    name VARCHAR(50),
    balance INT
);

INSERT INTO Accounts VALUES
(1, 'Alice', 1000),
(2, 'Bob', 1500),
(3, 'Charlie', 2000);

1️⃣ Transaction – Atomicity & Rollback

Atomicity ensures that a transaction is all or nothing – either all operations succeed or none are applied.
👉 Example: Transfer 500 from Alice to Bob, but rollback before commit.

-- Start Transaction
BEGIN;

-- Deduct 500 from Alice
UPDATE Accounts SET balance = balance - 500 WHERE name = 'Alice';

-- Add 500 to Bob
UPDATE Accounts SET balance = balance + 500 WHERE name = 'Bob';

-- Check balances (before rollback)
SELECT * FROM Accounts;

-- Rollback the transaction
ROLLBACK;

-- Check balances again (should be unchanged)
SELECT * FROM Accounts;

✅ After rollback → Balances remain the same as original.

2️⃣ Deadlock Simulation

A deadlock happens when two transactions hold locks that the other one needs, and neither can proceed.
👉 Steps to simulate:

Session 1

BEGIN;
-- Lock Alice's account
UPDATE Accounts SET balance = balance - 100 WHERE name = 'Alice';

-- Try updating Bob (will wait because Session 2 locks it)
UPDATE Accounts SET balance = balance + 100 WHERE name = 'Bob';

Session 2

BEGIN;
-- Lock Bob's account
UPDATE Accounts SET balance = balance - 100 WHERE name = 'Bob';

-- Try updating Alice (will wait, creating deadlock)
UPDATE Accounts SET balance = balance + 100 WHERE name = 'Alice';

⚠️ At this point, the database detects a deadlock and aborts one transaction automatically.

ORA-00060: deadlock detected while waiting for resource

3️⃣ Log-Based Recovery

Databases maintain transaction logs (Redo & Undo logs) to ensure durability and recovery.
👉 Let’s test with a transaction and rollback.

-- Start transaction
BEGIN;

-- Try updating Charlie's account
UPDATE Accounts SET balance = balance + 300 WHERE name = 'Charlie';

-- Rollback
ROLLBACK;

✅ You’ll find entries for the UNDO operation confirming rollback was recorded in the log.

🎯 Conclusion

1.Transactions ensure data integrity using atomicity & rollback.
2.Deadlocks can occur when two sessions wait for each other’s locks – DBMS resolves them automatically.
3.Log-based recovery makes sure that even after crashes or rollbacks, the database can restore consistency.

🚀 Working with Cursors and Triggers in Oracle Live SQL

Baviya Varshini V — Fri, 03 Oct 2025 06:52:20 +0000

In this post, we’ll learn how to use Cursors and Triggers in Oracle SQL with simple examples.
Let’s dive in! ⚡

📌 1. Cursor with Condition

A cursor in Oracle is used when you want to process query results row by row.
👉 Example: Display employee names whose salary > 50,000 from the Employee table.

✅ Steps:

Declare a cursor with the condition.
Open the cursor.
Fetch each row into a variable.
Process inside a loop.
Close the cursor.

💻 Example (Oracle PL/SQL):

SET SERVEROUTPUT ON;

DECLARE
    CURSOR emp_cursor IS
        SELECT emp_name FROM Employee WHERE salary > 50000;
    v_emp_name Employee.emp_name%TYPE;
BEGIN
    OPEN emp_cursor;
    LOOP
        FETCH emp_cursor INTO v_emp_name;
        EXIT WHEN emp_cursor%NOTFOUND;
        DBMS_OUTPUT.PUT_LINE('Employee: ' || v_emp_name);
    END LOOP;
    CLOSE emp_cursor;
END;
/

📌 2. AFTER INSERT Trigger

A trigger in Oracle is a stored PL/SQL block that automatically executes when a specific event occurs on a table.
👉 Example: Whenever a new student is inserted into the Students table, add a log entry in Student_Audit table.

✅ Steps:

Create an audit table.
Write an AFTER INSERT trigger.
Insert log details inside the trigger.

💻 Example (Oracle PL/SQL):

CREATE TABLE Students (
    student_id NUMBER PRIMARY KEY,
    student_name VARCHAR2(100)
);

CREATE TABLE Student_Audit (
    audit_id NUMBER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    student_id NUMBER,
    student_name VARCHAR2(100),
    action_date DATE DEFAULT SYSDATE
);

Create the AFTER INSERT Trigger

CREATE OR REPLACE TRIGGER trg_after_student_insert
AFTER INSERT ON Students
FOR EACH ROW
BEGIN
    INSERT INTO Student_Audit (student_id, student_name)
    VALUES (:NEW.student_id, :NEW.student_name);
END;
/

INSERT INTO Students (student_id, student_name) 
VALUES (1, 'Alice');

INSERT INTO Students (student_id, student_name) 
VALUES (2, 'Bob');

Check the Audit Table

SELECT * FROM Student_Audit;

🎯 Conclusion

Cursors are useful when you need row-by-row processing.
Triggers automate tasks like auditing changes.

🚀 Understanding Indexing in Oracle (B-Tree, B+ Tree, Hash Cluster)

Baviya Varshini V — Fri, 03 Oct 2025 05:56:51 +0000

Indexes are one of the most important concepts in databases. They speed up queries, reduce table scans, and optimize performance. In this post, we’ll explore B-Tree, B+ Tree, and Hash Indexing (via Hash Cluster) in Oracle using Students table.

📌 Step 1: Create the Students Table

CREATE TABLE Students (
    roll_no INT PRIMARY KEY,
    name VARCHAR2(50),
    dept VARCHAR2(10),
    cgpa NUMBER(3,2)
);

📌 Step 2: Insert 20 Sample Records

INSERT INTO Students VALUES (101, 'Alice', 'CSBS', 9.1);
INSERT INTO Students VALUES (102, 'Bob', 'IT', 7.5);
INSERT INTO Students VALUES (103, 'Charlie', 'CSE', 8.6);
INSERT INTO Students VALUES (104, 'David', 'ECE', 7.9);
INSERT INTO Students VALUES (105, 'Eva', 'CSBS', 8.3);
INSERT INTO Students VALUES (106, 'Frank', 'MECH', 6.5);
INSERT INTO Students VALUES (107, 'Grace', 'EEE', 8.8);
INSERT INTO Students VALUES (108, 'Helen', 'CIVIL', 7.0);
INSERT INTO Students VALUES (109, 'Ivy', 'CSE', 8.9);
INSERT INTO Students VALUES (110, 'Jack', 'CSBS', 9.0);
INSERT INTO Students VALUES (111, 'Karan', 'IT', 7.8);
INSERT INTO Students VALUES (112, 'Leo', 'CSE', 8.1);
INSERT INTO Students VALUES (113, 'Maya', 'ECE', 8.5);
INSERT INTO Students VALUES (114, 'Nina', 'MECH', 6.8);
INSERT INTO Students VALUES (115, 'Oscar', 'EEE', 8.7);
INSERT INTO Students VALUES (116, 'Paul', 'CIVIL', 7.2);
INSERT INTO Students VALUES (117, 'Queen', 'CSBS', 9.3);
INSERT INTO Students VALUES (118, 'Raj', 'CSE', 8.0);
INSERT INTO Students VALUES (119, 'Sara', 'IT', 7.6);
INSERT INTO Students VALUES (120, 'Tom', 'CSBS', 9.2);

📌 Step 3: B-Tree Index (on Roll Number)

Oracle’s default index type is a B-Tree index.

CREATE INDEX idx_rollno ON Students(roll_no);

Now query with the index:

SELECT * FROM Students WHERE roll_no = 110;

📌 Step 4: B+ Tree Index (on CGPA)

B+ Trees are used internally by Oracle when you create a normal index on numeric columns.

CREATE INDEX idx_cgpa ON Students(cgpa);

SELECT * FROM Students WHERE cgpa > 8.0;

📌 Step 5: Hash Index via Hash Cluster (on Department)
Oracle does not allow USING HASH in CREATE INDEX.
Instead, we use a Hash Cluster.

CREATE CLUSTER student_cluster (dept VARCHAR2(10))
SIZE 512
HASHKEYS 20;

CREATE TABLE Students_Hash (
    roll_no INT PRIMARY KEY,
    name VARCHAR2(50),
    dept VARCHAR2(10),
    cgpa NUMBER(3,2)
) CLUSTER student_cluster(dept);

INSERT INTO Students_Hash VALUES (101, 'Alice', 'CSBS', 9.1);
INSERT INTO Students_Hash VALUES (102, 'Bob', 'IT', 7.5);
INSERT INTO Students_Hash VALUES (103, 'Charlie', 'CSE', 8.6);
INSERT INTO Students_Hash VALUES (104, 'David', 'ECE', 7.9);
INSERT INTO Students_Hash VALUES (105, 'Eva', 'CSBS', 8.3);
INSERT INTO Students_Hash VALUES (106, 'Frank', 'MECH', 6.5);
INSERT INTO Students_Hash VALUES (107, 'Grace', 'EEE', 8.8);
INSERT INTO Students_Hash VALUES (108, 'Helen', 'CIVIL', 7.0);
INSERT INTO Students_Hash VALUES (109, 'Ivy', 'CSE', 8.9);
INSERT INTO Students_Hash VALUES (110, 'Jack', 'CSBS', 9.0);
INSERT INTO Students_Hash VALUES (111, 'Karan', 'IT', 7.8);
INSERT INTO Students_Hash VALUES (112, 'Leo', 'CSE', 8.1);
INSERT INTO Students_Hash VALUES (113, 'Maya', 'ECE', 8.5);
INSERT INTO Students_Hash VALUES (114, 'Nina', 'MECH', 6.8);
INSERT INTO Students_Hash VALUES (115, 'Oscar', 'EEE', 8.7);
INSERT INTO Students_Hash VALUES (116, 'Paul', 'CIVIL', 7.2);
INSERT INTO Students_Hash VALUES (117, 'Queen', 'CSBS', 9.3);
INSERT INTO Students_Hash VALUES (118, 'Raj', 'CSE', 8.0);
INSERT INTO Students_Hash VALUES (119, 'Sara', 'IT', 7.6);
INSERT INTO Students_Hash VALUES (120, 'Tom', 'CSBS', 9.2);

Query with Hash Access

SELECT * FROM Students_Hash WHERE dept = 'CSBS';

🔥 Conclusion

B-Tree Index → best for primary keys, unique lookups.
B+ Tree Index → efficient for range queries (e.g., CGPA > 8).
Hash Cluster → simulates Hash Index in Oracle for exact match lookups.

By combining these, you can optimize queries and improve performance in Oracle SQL.

📘 Database Normalization Example (1NF 3NF) with SQL in Oracle Live SQL

Baviya Varshini V — Wed, 01 Oct 2025 15:20:50 +0000

In this post, we’ll take a Student–Course–Instructor dataset, identify anomalies, and normalize it step by step from 1NF → 3NF, finally writing SQL queries and testing them in Oracle Live SQL.

🔎 The Raw Table

We start with this table:

⚠️ Anomalies in the Design

Insertion anomaly – Cannot insert a new course unless a student enrolls.
Update anomaly – Updating an instructor’s phone requires changing multiple rows.
Deletion anomaly – If Priya drops DBMS, we lose Dr. Kumar’s info.

✅ Step 1: 1NF

The table is already in 1NF (atomic values).

CREATE TABLE StudentCourse (
    StudentID VARCHAR2(10),
    StudentName VARCHAR2(50),
    CourseID VARCHAR2(10),
    CourseName VARCHAR2(50),
    Instructor VARCHAR2(50),
    InstructorPhone VARCHAR2(15),
    PRIMARY KEY (StudentID, CourseID)
);

✅ Step 2: 2NF

We remove partial dependencies:

StudentID → StudentName
CourseID → CourseName, Instructor, InstructorPhone

So we split into Student, Course, Enrollment.

CREATE TABLE Student (
    StudentID VARCHAR2(10) PRIMARY KEY,
    StudentName VARCHAR2(50)
);

CREATE TABLE Course (
    CourseID VARCHAR2(10) PRIMARY KEY,
    CourseName VARCHAR2(50),
    Instructor VARCHAR2(50),
    InstructorPhone VARCHAR2(15)
);

CREATE TABLE Enrollment (
    StudentID VARCHAR2(10),
    CourseID VARCHAR2(10),
    PRIMARY KEY (StudentID, CourseID),
    FOREIGN KEY (StudentID) REFERENCES Student(StudentID),
    FOREIGN KEY (CourseID) REFERENCES Course(CourseID)
);

✅ Step 3: 3NF

Now we remove transitive dependency: InstructorPhone depends on Instructor, not directly on Course.

So we create a separate Instructor table.

CREATE TABLE Instructor (
    InstructorID NUMBER PRIMARY KEY,
    InstructorName VARCHAR2(50),
    InstructorPhone VARCHAR2(15)
);

CREATE TABLE Course (
    CourseID VARCHAR2(10) PRIMARY KEY,
    CourseName VARCHAR2(50),
    InstructorID NUMBER,
    FOREIGN KEY (InstructorID) REFERENCES Instructor(InstructorID)
);

CREATE TABLE Student (
    StudentID VARCHAR2(10) PRIMARY KEY,
    StudentName VARCHAR2(50)
);

CREATE TABLE Enrollment (
    StudentID VARCHAR2(10),
    CourseID VARCHAR2(10),
    PRIMARY KEY (StudentID, CourseID),
    FOREIGN KEY (StudentID) REFERENCES Student(StudentID),
    FOREIGN KEY (CourseID) REFERENCES Course(CourseID)
);

✅ Insert Sample Data

-- Instructors (manual IDs)
INSERT INTO Instructor VALUES (1, 'Dr. Kumar', '9876543210');
INSERT INTO Instructor VALUES (2, 'Dr. Mehta', '9123456780');
INSERT INTO Instructor VALUES (3, 'Dr. Rao', '9988776655');

-- Courses
INSERT INTO Course VALUES ('C101', 'DBMS', 1);
INSERT INTO Course VALUES ('C102', 'Data Mining', 2);
INSERT INTO Course VALUES ('C103', 'AI', 3);

-- Students
INSERT INTO Student VALUES ('S01', 'Arjun');
INSERT INTO Student VALUES ('S02', 'Priya');
INSERT INTO Student VALUES ('S03', 'Kiran');

-- Enrollments
INSERT INTO Enrollment VALUES ('S01', 'C101');
INSERT INTO Enrollment VALUES ('S01', 'C102');
INSERT INTO Enrollment VALUES ('S02', 'C101');
INSERT INTO Enrollment VALUES ('S03', 'C103');

✅ Final Query with JOINs

To list all students with their courses and instructors:

SELECT s.StudentName, c.CourseName, i.InstructorName
FROM Enrollment e
JOIN Student s ON e.StudentID = s.StudentID
JOIN Course c ON e.CourseID = c.CourseID
JOIN Instructor i ON c.InstructorID = i.InstructorID;

🎯 Conclusion

We started with an unnormalized table.
Identified anomalies.
Converted step by step into 1NF → 2NF → 3NF.
Inserted clean sample data.
Wrote a JOIN query to fetch students, courses, and instructors.

This makes the database cleaner, consistent, and flexible ✅.