Forem: HARINI SRI K A 24CB016

AWS Service: Amazon Honeycode

HARINI SRI K A 24CB016 — Fri, 19 Dec 2025 09:06:16 +0000

Amazon Honeycode

Amazon Honeycode is a beginner-friendly AWS service that allows users to build applications without writing code. It is especially useful for business teams and students who want to create simple apps quickly.

Service Overview

Amazon Honeycode is a no-code application development service that enables users to build web and mobile apps using simple spreadsheets and visual components. It removes the need for complex programming and infrastructure management.

Key Features

No-code app development platform
Spreadsheet-based data model
Visual app builder for web and mobile
Built-in integration with AWS services
Secure user access and permissions

AWS Category / Cloud Domain

Category: Application Development
Cloud Domain: Low-Code / No-Code, Business Applications

Where It Fits in the Cloud / DevOps Lifecycle

Amazon Honeycode fits into the Application Development phase of the cloud lifecycle.

Rapid app development without DevOps overhead
Ideal for internal tools and workflows
Reduces development and deployment time
Requires minimal infrastructure management

Programming Language / Access Methods

No programming language required
Access via Web browser and mobile apps
Uses spreadsheet-style formulas for logic

Pricing Mode

Free tier: Limited users and storage
Paid model: Pay per user per month
Pricing based on number of app users

Why Amazon Honeycode Matters

Amazon Honeycode empowers non-developers to create applications quickly, reducing dependency on engineering teams and accelerating digital transformation.

Amazon Honeycode is a simple yet powerful AWS service for building applications without coding. It is ideal for students, business teams, and organizations looking for fast and easy app development.
Thank You @santhoshnc sir!!

DevSecOps Periodic Table

HARINI SRI K A 24CB016 — Fri, 19 Dec 2025 08:51:28 +0000

Harness in the DevSecOps Periodic Table

Overview of the Tool

Harness is a modern CI/CD and DevSecOps platform that helps teams automate software delivery with speed, reliability, and security. It focuses on continuous delivery, cloud cost management, and security testing.

Key Features

Continuous Integration (CI) & Continuous Delivery (CD)
Automated deployments with rollback support
Built-in security testing (SAST, DAST, SCA)
Cloud cost management & optimization
GitOps and pipeline-as-code support

How It Fits into DevOps / DevSecOps

Harness plays a key role in DevSecOps by integrating security checks directly into CI/CD pipelines. It ensures faster deployments while continuously validating code quality, security, and compliance.

Programming Language

Java (core backend)
Uses YAML for pipeline configuration
Supports applications written in any language

Parent Company

Harness Inc.

Open Source or Paid

Paid (Enterprise Tool)
Offers free/community tiers with limited features

Harness simplifies secure software delivery by combining automation, security, and intelligence in one DevSecOps platform.
Thankyou @santhoshnc sir!!

Getting Hands-on with MongoDB: CRUD Operations for College Students

HARINI SRI K A 24CB016 — Sun, 05 Oct 2025 18:51:07 +0000

Working with databases is an essential skill for any developer. Recently, I explored MongoDB, a popular NoSQL database, by performing basic CRUD (Create, Read, Update, Delete) operations using a simple students collection. Here’s a walkthrough of my learning journey.

The Students Collection Schema
{
"student_id": "S001",
"name": "Santhosh",
"age": 20,
"department": "CSBS",
"year": 2,
"cgpa": 9
}
db.students.insertMany([
{ "student_id": "S001", "name": "Santhosh", "age": 20, "department": "CSBS", "year": 2, "cgpa": 9 },
{ "student_id": "S002", "name": "Ananya", "age": 19, "department": "CSE", "year": 1, "cgpa": 8.5 },
{ "student_id": "S003", "name": "Rohit", "age": 21, "department": "ECE", "year": 3, "cgpa": 7.8 },
{ "student_id": "S004", "name": "Priya", "age": 22, "department": "CSE", "year": 3, "cgpa": 9.2 },
{ "student_id": "S005", "name": "Kiran", "age": 20, "department": "ME", "year": 2, "cgpa": 6.9 }
]);
Reading (Querying) Data
db.students.find().pretty();
db.students.find({ "cgpa": { $gt: 8 } }).pretty();
db.students.find({ "department": "CSE" }).pretty();
Updating Data
db.students.updateOne(
{ "student_id": "S002" },
{ $set: { "cgpa": 9.0 } }
);

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

Deleting Data
db.students.deleteOne({ "student_id": "S005" });
db.students.deleteMany({ "cgpa": { $lt: 7.5 } });
Exporting the Collection
MongoDB Atlas makes exporting simple:

Go to Collections → students → Export Collection.

Choose JSON or CSV format to save your data.

Conclusion

Working with MongoDB through this hands-on CRUD exercise was a great learning experience. I learned how to create, read, update, and delete documents in a NoSQL database, and how MongoDB’s flexible schema makes managing real-world data simple and efficient. Using MongoDB Atlas also made it easy to visualize the data and perform operations in a cloud environment.

This exercise strengthened my understanding of database concepts and gave me confidence to work with NoSQL databases in future projects.
thank you sir@santhoshnc !!!!

SQL Indexing, Hashing & Query Optimization

HARINI SRI K A 24CB016 — Sun, 05 Oct 2025 17:42:21 +0000

When working with large databases, query performance becomes critical. Retrieving data without optimization can be slow. This is where indexes come into play.

In this blog, we will explore:

B-Tree Index for primary key lookups

B+ Tree Index for range queries

Hash Index for equality searches

We will use a Students table with sample data and see how different indexes improve query performance.
CREATE TABLE Students (
roll_no INT PRIMARY KEY,
name VARCHAR(50),
dept VARCHAR(10),
cgpa DECIMAL(3,2)
);

INSERT INTO Students (roll_no, name, dept, cgpa) VALUES
(101, 'Alice', 'CSBS', 8.5),
(102, 'Bob', 'ECEN', 7.9),
...
(120, 'Tom', 'ECEN', 7.4);

B-Tree Index on roll_no
CREATE INDEX idx_roll_no ON Students(roll_no);
SELECT * FROM Students WHERE roll_no = 110;

B+ Tree Index on cgpa
CREATE INDEX idx_cgpa ON Students(cgpa);
SELECT * FROM Students WHERE cgpa > 8.0;

Hash Index on dept
CREATE INDEX idx_dept_hash ON Students(dept);
SELECT * FROM Students WHERE dept = 'CSBS';

Conclusion

In this blog, we:

Created a Students table with sample records

Applied B-Tree, B+ Tree, and Hash indexes

Ran queries to demonstrate performance improvement
Thank you @santhoshnc sir !!!

Transactions, Deadlocks & Log-Based Recovery in SQL

HARINI SRI K A 24CB016 — Sun, 05 Oct 2025 17:21:07 +0000

Databases are at the heart of almost every application. To ensure reliability, developers need to understand transactions, deadlocks, and log-based recovery. In this blog, we’ll explore these concepts using a simple Accounts table.
CREATE TABLE Accounts (
acc_no INT PRIMARY KEY,
name VARCHAR(50),
balance INT
) ENGINE=InnoDB;

INSERT INTO Accounts VALUES
(1, 'Alice', 1000),
(2, 'Bob', 1500),
(3, 'Charlie', 2000);
Transactions
-- 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';

-- Rollback before commit
ROLLBACK;
SELECT * FROM Accounts;

*Deadlock Simulation
*
BEGIN;

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

-- Try updating Bob's account (will wait if Session 2 locks it)
UPDATE Accounts SET balance = balance - 100 WHERE name='Bob';
BEGIN;

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

-- Try updating Alice's account (will wait if Session 1 locks it)
UPDATE Accounts SET balance = balance + 50 WHERE name='Alice';

At this point, both sessions are waiting on each other → deadlock.

Log-Based Recovery
BEGIN;

UPDATE Accounts
SET balance = balance + 200
WHERE name='Charlie';

ROLLBACK;
SHOW BINLOG EVENTS;

Conclusion

Transactions provide atomicity, ensuring all-or-nothing updates.

Deadlocks can occur in concurrent sessions; modern DBMS detect and resolve them.

Logs enable rollback and recovery, keeping databases consistent and reliable.
THANK YOU @santhoshnc sir for guiding us!!!

ACID Properties with SQL Transactions

HARINI SRI K A 24CB016 — Sun, 05 Oct 2025 16:36:00 +0000

Databases need to be reliable, consistent, and crash-proof. This is where ACID properties — Atomicity, Consistency, Isolation, and Durability — come in.

In this post, we’ll demonstrate ACID properties using an Accounts table in Oracle SQL.
DROP TABLE Accounts PURGE;

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

INSERT INTO Accounts VALUES (101, 'Arjun', 5000);
INSERT INTO Accounts VALUES (102, 'Sneha', 3000);
INSERT INTO Accounts VALUES (103, 'Kiran', 7000);
COMMIT;

SELECT * FROM Accounts;

DROP TABLE Accounts PURGE;

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

INSERT INTO Accounts VALUES (101, 'Arjun', 5000);
INSERT INTO Accounts VALUES (102, 'Sneha', 3000);
INSERT INTO Accounts VALUES (103, 'Kiran', 7000);
COMMIT;

SELECT * FROM Accounts;

1.Atomicity
SET SERVEROUTPUT ON;

BEGIN
DBMS_OUTPUT.PUT_LINE('--- Atomicity Test ---');
SAVEPOINT start_trans;

UPDATE Accounts SET balance = balance - 1000 WHERE acc_no = 101;
UPDATE Accounts SET balance = balance + 1000 WHERE acc_no = 102;

ROLLBACK TO start_trans;

FOR rec IN (SELECT * FROM Accounts ORDER BY acc_no) LOOP
    DBMS_OUTPUT.PUT_LINE(rec.acc_no || ' - ' || rec.name || ' : ' || rec.balance);
END LOOP;

END;

2.Consistency
BEGIN
DBMS_OUTPUT.PUT_LINE('--- Consistency Test ---');
INSERT INTO Accounts VALUES (104, 'Meena', -2000);
EXCEPTION
WHEN OTHERS THEN
DBMS_OUTPUT.PUT_LINE('Error: ' || SQLERRM);
END;
/

3.Isolation

BEGIN;
UPDATE Accounts SET balance = balance - 500 WHERE acc_no = 103;

4.Durability
BEGIN
DBMS_OUTPUT.PUT_LINE('--- Durability Test ---');
UPDATE Accounts SET balance = balance + 200 WHERE acc_no = 102;
COMMIT;
END;
/

SELECT * FROM Accounts WHERE acc_no = 102;

Conclusion:

ACID properties ensure that database transactions are safe, reliable, and consistent, even in case of failures or concurrent operations.
They are the backbone of all transactional databases.

Thank you @santhoshnc sir for guiding me!!!!!

Cursor + Trigger — SQL Practice

HARINI SRI K A 24CB016 — Sun, 05 Oct 2025 15:42:02 +0000

In this post, we’ll explore two powerful SQL concepts — Cursors and Triggers — with complete examples that you can run directly in Oracle LiveSQL.

CURSOR — Process Cursor with Condition
Problem Statement:

Create a cursor that displays employee names whose salary is greater than 50,000 from the Employee table.
CREATE TABLE Employee (
EmpID NUMBER PRIMARY KEY,
EmpName VARCHAR2(100),
Salary NUMBER(10,2)
);
INSERT INTO Employee VALUES (1, 'Arjun', 45000);
INSERT INTO Employee VALUES (2, 'Sneha', 52000);
INSERT INTO Employee VALUES (3, 'Kiran', 60000);
INSERT INTO Employee VALUES (4, 'Meena', 48000);
COMMIT;
SET SERVEROUTPUT ON;

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

*TRIGGER *— AFTER INSERT Trigger (Student Table)
Problem Statement:

Whenever a new student is added to the Students table, automatically insert a log entry into the Student_Audit table to keep track of the registration.
CREATE TABLE Students (
StudentID NUMBER PRIMARY KEY,
StudentName VARCHAR2(100),
Course VARCHAR2(100)
);
CREATE TABLE Student_Audit (
AuditID NUMBER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
StudentID NUMBER,
StudentName VARCHAR2(100),
ActionTaken VARCHAR2(100),
ActionDate DATE
);
CREATE OR REPLACE TRIGGER trg_AfterStudentInsert
AFTER INSERT ON Students
FOR EACH ROW
BEGIN
INSERT INTO Student_Audit (StudentID, StudentName, ActionTaken, ActionDate)
VALUES (:NEW.StudentID, :NEW.StudentName, 'New Student Registered', SYSDATE);
END;
INSERT INTO Students (StudentID, StudentName, Course)
VALUES (1, 'Harini', 'Computer Science');
COMMIT;
SELECT * FROM Student_Audit;

Conclusion:
Cursors help process data row by row, while triggers automatically perform actions when data changes.
Together, they make SQL more powerful by combining control and automation in database operations.
Thank you @santhoshnc sir for guiding me!!!!

"Database Normalization Explained: 1NF 3NF with SQL Example"

HARINI SRI K A 24CB016 — Sat, 04 Oct 2025 14:12:57 +0000

Database normalization is the process of organizing data to reduce redundancy and improve data integrity. In this tutorial, we’ll go step-by-step from Unnormalized Table → 1NF → 2NF → 3NF, and implement it using MySQL.

We’ll also write a JOIN query to display students along with their courses and instructors.

Insertion Anomaly: Cannot add a new course without assigning it to a student.

Update Anomaly: If an instructor’s phone number changes, multiple rows must be updated.
Deletion Anomaly: Removing a student could delete information about the course and instructor.

1.First Normal Form (1NF)

Rule: Each column should have atomic values.

Our table already satisfies 1NF.

CREATE TABLE StudentCourses_1NF (
StudentName VARCHAR(50),
CourseID VARCHAR(10),
CourseName VARCHAR(50),
Instructor VARCHAR(50),
InstructorPhone VARCHAR(15)
);

Second Normal Form (2NF)

Rule: Must be in 1NF, and remove partial dependencies.

CourseName, Instructor, InstructorPhone depend only on CourseID.

StudentName depends only on the student.
-- Students Table
CREATE TABLE Students (
StudentID INT PRIMARY KEY AUTO_INCREMENT,
StudentName VARCHAR(50)
);

-- Courses Table
CREATE TABLE Courses (
CourseID VARCHAR(10) PRIMARY KEY,
CourseName VARCHAR(50),
Instructor VARCHAR(50),
InstructorPhone VARCHAR(15)
);

-- Enrollments Table (linking students to courses)
CREATE TABLE Enrollments (
StudentID INT,
CourseID VARCHAR(10),
PRIMARY KEY (StudentID, CourseID),
FOREIGN KEY (CourseID) REFERENCES Courses(CourseID)
);

Third Normal Form (3NF)

Rule: Must be in 2NF, and remove transitive dependencies.

InstructorPhone depends on Instructor.

Move instructors to a separate table.
-- Students Table
CREATE TABLE Students (
StudentID INT PRIMARY KEY AUTO_INCREMENT,
StudentName VARCHAR(50)
);

-- Instructors Table
CREATE TABLE Instructors (
InstructorID INT PRIMARY KEY AUTO_INCREMENT,
InstructorName VARCHAR(50),
InstructorPhone VARCHAR(15)
);

-- Courses Table
CREATE TABLE Courses (
CourseID VARCHAR(10) PRIMARY KEY,
CourseName VARCHAR(50),
InstructorID INT,
FOREIGN KEY (InstructorID) REFERENCES Instructors(InstructorID)
);

-- Enrollments Table
CREATE TABLE Enrollments (
StudentID INT,
CourseID VARCHAR(10),
PRIMARY KEY (StudentID, CourseID),
FOREIGN KEY (StudentID) REFERENCES Students(StudentID),
FOREIGN KEY (CourseID) REFERENCES Courses(CourseID)
);

Insert Sample Data -- Insert Students INSERT INTO Students (StudentName) VALUES ('Arjun'), ('Priya'), ('Kiran');

-- Insert Instructors
INSERT INTO Instructors (InstructorName, InstructorPhone) VALUES
('Dr. Kumar', '9876543210'),
('Dr. Mehta', '9123456780'),
('Dr. Rao', '9988776655');

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

-- Insert Enrollments
INSERT INTO Enrollments (StudentID, CourseID) VALUES
(1, 'C101'),
(1, 'C102'),
(2, 'C101'),
(3, 'C103');

JOIN Query to List Students, Courses & Instructors SELECT s.StudentName, c.CourseName, i.InstructorName, i.InstructorPhone FROM Enrollments e JOIN Students s ON e.StudentID = s.StudentID JOIN Courses c ON e.CourseID = c.CourseID JOIN Instructors i ON c.InstructorID = i.InstructorID;

Conclusion

Normalization reduces redundancy and prevents anomalies.

1NF: Remove repeating groups

2NF: Remove partial dependencies

3NF: Remove transitive dependencies

Using MySQL and JOINs, we can fetch combined data efficiently.

This approach ensures a clean, scalable database structure, ready for real-world applications.
Thank you @santhoshnc sir for guiding mee!!!!

COLLEGE STUDENT AND COURSES MANAGEMENT SYSTEMS

HARINI SRI K A 24CB016 — Fri, 22 Aug 2025 09:03:50 +0000

I am build a basic College student and Student-Course Enrollment system using Oracle SQL.
we are performing the below operations:

Create tables
Insert data
Alter tables
Add constraints
Run simple queries

Step 1: Create Tables

sql
Students Table
CREATE TABLE Students (
StudentID NUMBER PRIMARY KEY,
Name VARCHAR2(50) NOT NULL,
Dept VARCHAR2(30),
DOB DATE,
Email VARCHAR2(50) UNIQUE
);

Courses Table
CREATE TABLE Courses (
CourseID NUMBER PRIMARY KEY,
CourseName VARCHAR2(50) NOT NULL,
Credits NUMBER(2)
);

Enrollments Table
CREATE TABLE Enrollments (
EnrollID NUMBER PRIMARY KEY,
StudentID NUMBER REFERENCES Students(StudentID),
CourseID NUMBER REFERENCES Courses(CourseID),
Grade CHAR(2)
);

Step 2: Insert Sample Data
sql
Copy code
-- Insert Students
INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (1, 'Divi', 'CB', TO_DATE('3/15/2007', 'MM-DD-YYYY'), 'divi.cb@example.com');

INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (2, 'Harini', 'CB', TO_DATE('11/22/2006', 'MM-DD-YYYY'), 'harini.cb@example.com');

INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (3, 'Diksha', 'CB', TO_DATE('7/9/2006', 'MM-DD-YYYY'), 'diksha.cb@example.com');

Insert Courses
INSERT INTO Courses (CourseID, CourseName, Credits)
VALUES (101, 'DBMS', 3);

INSERT INTO Courses (CourseID, CourseName, Credits)
VALUES (102, 'OS', 4);

INSERT INTO Courses (CourseID, CourseName, Credits)
VALUES (103, 'Data Structures', 5);

-- Commit changes
COMMIT;

Step 3: Modify Table and Add Constraint
sql
Copy code
-- Add phone number to Students
ALTER TABLE Students
ADD PhoneNo VARCHAR2(10);

-- Add check constraint to Courses
ALTER TABLE Courses
ADD CHECK (Credits BETWEEN 1 AND 5);

Step 4: Query the Data
sql
Copy code
-- Show student names in uppercase and email length
SELECT
UPPER(Name) AS Student_Name,
LENGTH(Email) AS Email_Length
FROM Students;

-- Show all courses
SELECT CourseID, CourseName, Credits
FROM Courses;

Show all students
SELECT StudentID, Name, Dept, DOB, Email, PhoneNo
FROM Students;

Summary
In this post, we built a simple database using Oracle SQL:

Created 3 tables

Inserted sample data

Added a column and constraint

Ran a few basic queries

Thank you @santhoshnc for guiding and supporting me!!