DEV Community: ABITHA N 24CB001

Amazon EC2 in Cloud Computing: Features, Use Cases, and Pricing

ABITHA N 24CB001 — Thu, 18 Dec 2025 14:53:29 +0000

📌Overview of service:
Amazon EC2 (Elastic Compute Cloud) provides virtual servers, called instances, that allow users to run applications in the cloud without owning physical hardware. With EC2, developers can quickly launch servers, configure them as needed, and scale them up or down based on demand.

EC2 removes the need for upfront hardware investment and gives full control over computing resources.

⭐Key Features of Amazon EC2:
Some important features of Amazon EC2 are:
● Scalable compute capacity – increase or decrease instances anytime
● Multiple instance types – optimized for compute, memory, or storage
● Flexible operating systems – supports Linux, Windows, and more
● High availability – deploy instances across multiple Availability Zones
● Security – integrated with IAM, security groups, and key pairs

🗂️AWS Category / Cloud Domain:
* Amazon EC2 belongs to the Compute category in AWS.
* Cloud Domain: Virtual Servers / Compute Infrastructure

🔄Where Amazon EC2 Fits in the Cloud / DevOps Lifecycle:
Amazon EC2 is used throughout the application lifecycle:
● Development – test and build applications
● Deployment – host web servers and backend services
● Scaling – handle increased traffic using auto scaling
● Operations – monitor and maintain running applications
● Disaster Recovery – launch instances from backups when needed

💻Programming Languages & Access Methods:
Amazon EC2 can be accessed using:
● AWS Management Console
● AWS CLI
● AWS SDKs, such as:
● Python (Boto3)
● Java
● JavaScript (Node.js)
● C#
● REST APIs
These options allow easy automation and integration with DevOps tools.

💰Pricing Model:
Amazon EC2 follows a pay-as-you-go pricing model. Pricing depends on:
● Instance type (CPU, memory, storage)
● Running time (per second or per hour)
● Pricing option, such as:
● On-Demand
● Reserved Instances
● Spot Instances
There is no long-term commitment for on-demand usage.

✅Conclusion:
Amazon EC2 is the foundation of many cloud applications and services. Its flexibility, scalability, and wide range of configuration options make it ideal for hosting everything from small websites to large enterprise systems. Learning EC2 is a key step in understanding AWS and cloud computing.

Atlassian Bamboo in the DevSecOps Periodic Table

ABITHA N 24CB001 — Thu, 18 Dec 2025 14:20:53 +0000

DevSecOps focuses on integrating development, security, and operations into a single continuous workflow. One of the key tools that supports this workflow is Atlassian Bamboo, a popular CI/CD tool that appears in the DevSecOps Periodic Table.

This blog provides a quick overview of Atlassian Bamboo, its features, and how it fits into DevOps and DevSecOps practices.

🔍Overview of the tool:
Atlassian Bamboo is a Continuous Integration and Continuous Deployment (CI/CD) server developed by Atlassian. It automates the process of building, testing, and deploying applications, helping development teams deliver software efficiently and reliably.

Bamboo is tightly integrated with other Atlassian tools such as Jira and Bitbucket, making it a strong choice for teams already using the Atlassian ecosystem.

⭐Key Features:
● Automated build, test, and deployment pipelines
● Seamless integration with Jira and Bitbucket
● Built-in deployment projects
● Support for multiple build agents
● Test result tracking and reporting
● Role-based access control

🔄How It Fits into DevOps / DevSecOps:
In the DevOps lifecycle, Atlassian Bamboo plays a crucial role in:
● Build
● Test
● Release
● Deploy
From a DevSecOps perspective, Bamboo helps by enabling:
● Automated security and quality checks in pipelines
● Controlled and auditable deployment workflows
● Integration with security scanning and testing tools
● This ensures that security is embedded early and continuously throughout the software delivery process.

💻Programming Language:

Java (core implementation)

Supports projects written in:
● Java
● Python
● JavaScript
● NET
● PHP

🏢Parent Company:
● Atlassian Corporation
● An Australian software company known for tools like Jira, Confluence and Bitbucket.

💰Open Source or Paid?
Atlassian Bamboo is a commercial CI/CD tool.

❌ Not open source
✅ Paid tool Offers a free trial, but requires a license for long-term use.

MONGODB

ABITHA N 24CB001 — Tue, 07 Oct 2025 07:21:25 +0000

I decided to use MongoDB for building my blog. As I have never worked with MongoDB before, I still have to figure out how to get everything to work. So, the only thing left to do now is getting started with MongoDB. How do we set it up, add users, and create our database.

First, lets download the community server which is free and open source. I will be using the Windows version for my desktop and this article. After installing the software, I also installed mongosh since I am an avid command line user. After adding mongosh to my PATH variablesIt is halfway when trying to boot the server again, that I figured that using mongosh might not have been the brightest of ideas. MongoDB is already new to me and using beta software that does not support all commands yet is not making things any easier. So, I switched to the legacy mongo shell, since the documentation is up to date for that. I managed to boot the server again and logging into my database!Creating a Database
I got my authentication ready, the final step now is to create a database. You can easily create a new database in MongoDB with the use command. If the database doesn't exist yet, it creates it. Keep in mind though that MongoDB will save the database only when you put data in it. Until then, it is not saved and does not show up when using the show dbs command.

With MongoDB running on my desktop, I can finally start with a little proof of concept. I will use that proof of concept to figure out how to connect to MongoDB and add my first set of data using Spring Boot. That should allow me to get a better grip on the technologies to start implementing it for the actual project. You know... less hacky and a bit more clean. However, that is for another post!

Transactions, Deadlocks & Log-Based Recovery

ABITHA N 24CB001 — Tue, 07 Oct 2025 07:11:05 +0000

**Databases are powerful because they ensure data integrity even when multiple users access the system at the same time. This is managed through transactions, deadlock detection, and log-based recovery.

In this blog, I demonstrate these concepts using a single Accounts table in Oracle Live SQL.**

📌 Schema Setup
We first create a table to simulate account balances:
CREATE TABLE Accounts (
acc_no INT PRIMARY KEY,
name VARCHAR2(50),
balance INT
);

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

COMMIT;

1️⃣ Transaction – Atomicity & Rollback
Goal: Transfer ₹500 from Alice to Bob. Rollback before commit to ensure no partial update.
-- Start transaction
UPDATE Accounts
SET balance = balance - 500
WHERE name = 'Alice';

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

-- Rollback the transaction
ROLLBACK;

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

✅ Balances remain:

Alice → 1000
Bob → 1500

Lesson: Atomicity ensures that either all operations in a transaction succeed, or none do.

2️⃣ Deadlock Simulation
Goal: Simulate a deadlock between two sessions.
Session 1: Lock Alice’s account and try to update Bob’s.
Session 2: Lock Bob’s account and try to update Alice’s.

🔥 Oracle detects circular wait → deadlock → one session is rolled back automatically.
Lesson: Deadlocks can occur when two transactions wait on each other’s locks. DBMS automatically resolves them.

3️⃣ Log-Based Recovery
Goal: Show that updates are tracked for recovery using logs.
-- Start transaction
UPDATE Accounts SET balance = balance + 1000 WHERE name = 'Alice';

-- Rollback
ROLLBACK;

-- Verify
SELECT * FROM Accounts;

✅ Even after rollback, balances are restored, demonstrating undo capability via internal logs.
Note: In Oracle Live SQL, redo/undo logs are internal. The rollback proves that log-based recovery works.

🎯 Summary
Through these demos, I explored:
✅ Atomicity & Rollback – all-or-nothing transactions
✅ Deadlocks – isolation and conflict resolution
✅ Log-Based Recovery – durability and undo operations

Special thanks to @santhoshnc Sir for guiding us to try these experiments hands-on in Oracle Live SQL.

Database Hashing

ABITHA N 24CB001 — Tue, 07 Oct 2025 07:03:19 +0000

I started my writing journey on Hashnode, but I've been wanting to expand my audience by widely publishing articles across the interwebs. I discovered dev.to as another great platform to share developer-related content.Dev.to has dedicated support for posting to the community from RSS. Additionally, dev.to supports canonical linking to protect SEO rankings. Luckily, Hashnode provides an RSS feed so republishing content from Hashnode onto dev.to is easy and fast.

You can find your Hashnode RSS example, my. You can also find it linked on your blog page. See the arrow in the screenshot below for the location. After creating a dev.to account, open the settings and head to the Extensions tab. Under the Extensions tab, you will find Publishing to DEV Community from RSS. Simply copy your Hashnode RSS feed into the RSS Feed URL field and hit Save Feed Settings. After a few seconds, your Hashnode articles will appear as drafts in the dev.to dashboard.

Understanding ACID Properties in SQL with Examples

ABITHA N 24CB001 — Tue, 07 Oct 2025 06:46:49 +0000

ACID properties — Atomicity, Consistency, Isolation, Durability — ensure that database transactions are reliable, safe, and predictable. Let’s explore them with a practical Accounts table.

Create Sample Accounts Table CREATE TABLE Accounts ( acc_no INT PRIMARY KEY, name VARCHAR2(50), balance INT CHECK (balance >= 0) -- enforce positive balance );

Insert sample data
INSERT INTO Accounts VALUES (101, 'Alice', 5000);
INSERT INTO Accounts VALUES (102, 'Bob', 3000);
INSERT INTO Accounts VALUES (103, 'Charlie', 7000);

COMMIT;

Atomicity

Definition: Either all operations in a transaction succeed, or none do.

Scenario: Transfer 1000 from Alice to Bob, but simulate a failure midway.

-- Start transaction
BEGIN
-- Deduct 1000 from Alice
UPDATE Accounts
SET balance = balance - 1000
WHERE acc_no = 101;

-- Simulate error (e.g., divide by zero)
-- This will cause the transaction to fail
-- Uncomment the following line to simulate failure
-- DECLARE x NUMBER := 1/0; END;

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

COMMIT; -- Will not reach here if error occurs
EXCEPTION
WHEN OTHERS THEN
ROLLBACK; -- Ensures no partial update
DBMS_OUTPUT.PUT_LINE('Transaction failed, rolled back.');
END;
/
✅ After rollback, balances remain unchanged — Atomicity is maintained.

Consistency

Definition: Transactions must leave the database in a valid state.

Scenario: Try inserting a negative balance.

-- This will fail due to the CHECK constraint
INSERT INTO Accounts VALUES (104, 'David', -500);

The database rejects this, ensuring Consistency.

Isolation

Definition: Concurrent transactions should not interfere with each other.

Scenario: Two sessions:

Session 1: Update Alice’s balance

UPDATE Accounts
SET balance = balance + 2000
WHERE acc_no = 101;
-- Do not commit yet

Session 2: Read Alice’s balance

SELECT balance FROM Accounts WHERE acc_no = 101;

Session 2 will not see the uncommitted change (depending on isolation level, default is READ COMMITTED).

This prevents dirty reads — demonstrating Isolation.

Durability

Definition: Once a transaction is committed, data persists even after a crash.

-- Commit a transaction
UPDATE Accounts
SET balance = balance + 1000
WHERE acc_no = 102;

COMMIT;

Restart the database.

Run:
SELECT * FROM Accounts;

Changes persist — Durability is guaranteed.

Summary Table
ACID Property Example Action
Atomicity Transfer money → rollback on error
Consistency CHECK constraint prevents negative balance
Isolation Concurrent reads/writes don’t interfere
Durability Committed changes persist after DB restart

💡Tip: Try changing isolation levels (READ COMMITTED, SERIALIZABLE) to observe how concurrent transactions behave differently.

Database cursor amd trigger

ABITHA N 24CB001 — Tue, 07 Oct 2025 06:32:27 +0000

A cursor in a Database Management System (DBMS) is a special control structure used to traverse and manipulate the rows in a result set one at a time. While standard SQL operations are typically set-based and act on all rows simultaneously, a cursor enables row-by-row processing, making it ideal for scenarios that require sequential logic, conditional operations, or custom computations on each individual row. Cursors are especially useful in complex business workflows where fine-grained control over data handling is necessary.

Step 1: Create Employee Table
CREATE TABLE Employee ( Emp_ID NUMBER PRIMARY KEY, Emp_Name VARCHAR2(50), Salary NUMBER );

Step 2: Insert Sample Data
INSERT INTO Employee (Emp_ID, Emp_Name, Salary) VALUES (1, 'Ramesh', 60000); INSERT INTO Employee (Emp_ID, Emp_Name, Salary) VALUES (2, 'Suresh', 45000); INSERT INTO Employee (Emp_ID, Emp_Name, Salary) VALUES (3, 'Anita', 75000); INSERT INTO Employee (Emp_ID, Emp_Name, Salary) VALUES (4, 'Kavya', 50000);

Step 3: Create and Process Cursor
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;

DBMS_OUTPUT.PUT_LINE prints each employee’s name and salary.

DEFINITION OF TRIGGER IN DBMS

A trigger in DBMS is a special stored procedure that automatically executes in response to events like INSERT, UPDATE, or DELETE on a table or view. It’s commonly used to enforce business rules, maintain data integrity, and log changes without manual intervention.

Step 1: Create Students Table
CREATE TABLE Students ( Student_ID NUMBER PRIMARY KEY, Student_Name VARCHAR2(50), Course VARCHAR2(50) );

Step 2: Create Student_Audit Table
CREATE TABLE Student_Audit ( Audit_ID NUMBER GENERATED ALWAYS AS IDENTITY PRIMARY KEY, Student_ID NUMBER, Student_Name VARCHAR2(50), Action VARCHAR2(50), Action_Time TIMESTAMP );

Step 3: Create 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, Action, Action_Time) VALUES (:NEW.Student_ID, :NEW.Student_Name, 'INSERT', SYSTIMESTAMP); END;

Step 4: Test Trigger
INSERT INTO Students (Student_ID, Student_Name, Course) VALUES (1, 'Ravi', 'Computer Science'); INSERT INTO Students (Student_ID, Student_Name, Course) VALUES (2, 'Meena', 'Electrical Engineering');

Step 5: Verify Audit Table
SELECT * FROM Student_Audit;

Database normalization

ABITHA N 24CB001 — Tue, 07 Oct 2025 06:20:06 +0000

Database normalization is the process of structuring a relational database to reduce redundancy and improve data integrity.
In this blog, we'll normalize a student-course-instructor dataset from Unnormalized Form 1NF ← 2NF ←

3NF, and implement it in SQL.

Step 1: Base Table

The initial unnormalized table includes details of students, their courses, instructors, and corresponding grades.Step 2: Identifying Anomalies

Insertion anomaly: A new course cannot

be added unless it is linked to a student.

Update anomaly: Modifying a course

name requires updating it in several rows.

Deletion anomaly: Removing a student

may also remove valuable course details if that student was the only enrollee.

1 First Normal Form (1NF)

Rule: Eliminate repeating groups, ensure atomic values.

So, we split multi-valued attributes into separate rows:Step 2: Identifying Anomalies

Insertion anomaly: A new course cannot

be added unless it is linked to a student.

Update anomaly: Modifying a course

name requires updating it in several rows.

Deletion anomaly: Removing a student

may also remove valuable course details if that student was the only enrollee.1 First Normal Form (1NF)

Rule: Eliminate repeating groups, ensure atomic values.

So, we split multi-valued attributes into separate rows:SQL Table in 1 NF,

CREATE TABLE Students_1NF (

Student_ID INT,

Student_Name VARCHAR2(100),

Course_ID INT,

Course_Name VARCHAR2(100),

Instructor VARCHAR2(100),

Grade CHAR(2),

PRIMARY KEY (Student_ID, Course_ID) );2 Second Normal Form (2NF)

Rule: Remove partial dependency → non-key attributes should depend on thewhole primary key.

Here, student_id depends on student info, course_id depends on course info, and instructor depends on the course.

So, we split into three tables:

SQL Create Tables (2NF):

CREATE TABLE Students ( StudentID VARCHAR2(10) PRIMARY KEY, StudentName VARCHAR2(100) );

CREATE TABLE Courses ( CourseID VARCHAR2(10) PRIMARY KEY, CourseName VARCHAR2(100), Instructor VARCHAR2(100), InstructorPhone VARCHAR2(15) );

CREATE TABLE Enrollments ( StudentID VARCHAR2(10), CourseID VARCHAR2(10),PRIMARY KEY (StudentID, CourseID), FOREIGN KEY (StudentID) REFERENCES Student(StudentID), FOREIGN KEY (CourseID) REFERENCES Course (CourseID) );3 Third Normal Form (3NF)

Rule: Remove transitive dependenciesnon-key attributes depending on other non-key attributes).

Here, instructor_phone depends on instructor, not on course_id. So we separate Instructor data:

SQL Create Tables (3NF):

REATE TABLE Instructors ( InstructorID VARCHAR2(10) PRIMARY KEY, InstructorName VARCHAR2(100), InstructorPhone VARCHAR2(15)

);

CREATE TABLE Courses3NF ( CourseID VARCHAR2(10) PRIMARY KEY, CourseName VARCHAR2(100), InstructorID VARCHAR2(10), FOREIGN KEY (InstructorID) REFERENCES Instructor(InstructorID) );CREATE TABLE Students3NF ( StudentID VARCHAR2(10) PRIMARY KEY, StudentName VARCHAR2(100) );

CREATE TABLE Enrollments3NF ( StudentID VARCHAR2(10), CourseID VARCHAR2(10), PRIMARY KEY (StudentID, CourseID), FOREIGN KEY (StudentID) REFERENCES Student3NF(StudentID), FOREIGN KEY (CourseID) REFERENCES Course3NF(CourseID) );Step 6: Insert Sample Data

Instructors

INSERT INTO Instructor VALUES ('101', 'Dr.

Kumar', '9876543210');

INSERT INTO Instructor VALUES ('102', 'Dr.

Mehta', '9123456780');

INSERT INTO Instructor VALUES ('103', 'Dr.

Rao', '9988776655');

Courses

INSERT INTO Course3NF VALUES ('C101', 'DBMS', '101');

INSERT INTO Course3NF VALUES ('C102',

'Data Mining', '102');

INSERT INTO Course3NF VALUES ('C103', 'ΑΙ', '103');

Students

INSERT INTO Student3NF VALUES ('S01', 'Arjun');

INSERT INTO Student3NF VALUES ('S02',

'Priva'):Enrollment

INSERT INTO Enrollment3NF VALUES ('S01', 'C101');

INSERT INTO Enrollment3NF VALUES ('S01', 'C102');

INSERT INTO Enrollment3NF VALUES ('S02', 'C101');

INSERT INTO Enrollment3NF VALUES ('S03', 'C103');Step 7: Query with JOINS

SELECT s.StudentName, c.CourseName, i.InstructorName

FROM Enrollment3NF e

JOIN Student3NF s ON e. StudentID =s.StudentID

JOIN Course3NF c ON e. CourseID = c.CourselD

JOIN Instructor i ON c.InstructorID = i.InstructorID;** Wrap Up**

We started with an unnormalized table and step-by-step applied:

1NF ← Removed repeating groups

2NF ← Removed partial dependencies

3NF ← Removed transitive dependencies

Result

A clean, normalized database3NF

← Removed transitive dependencies

← Result A clean, normalized database with reduced redundancy, better integrity, and easier queries

Special thanks to @santhoshnc for mentoring me on database normalization concepts!

SQL #Oracle

DBMS

DatabaseNormalization

1NF

2NF

3NF

BCNF

4NF

5NF

DataModeling

Student-Course Management Database

ABITHA N 24CB001 — Mon, 08 Sep 2025 11:07:38 +0000

`In this blog post,I created a simple Student-Course Management Database, step by step, using Oracle Live SQL.What This Project Includes
 *Creating STUDENTS, COURSES, and ENROLLMENTS tables
*Inserting data
Adding constraints (e.g., PRIMARY KEY, CHECK)
*Querying data with SELECT
*Altering tables to add new columns

 1: Creating Tables
CREATE TABLE Students (
  StudentID NUMBER PRIMARY KEY,
  Name VARCHAR2(50) NOT NULL,
  Dept VARCHAR2(30),
  DOB DATE,
  Email VARCHAR2(50) UNIQUE
);

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

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


This gives us three connected tables:
STUDENTS with student details
COURSES listing the available courses
ENROLLMENTS to track who enrolled in what course and their grades

✍️ Step 2: Inserting Student Data
INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (1, 'HARINI', 'Computer Science', TO_DATE('3/15/2007', 'MM/DD/YYYY'), 'harini16cs@gmail.com');

INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (2, 'DIVYA', 'AIDS', TO_DATE('11/22/2007', 'MM/DD/YYYY'), 'divya12ad@gmail.com');

INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (3, 'DIKSHA', 'IT', TO_DATE('7/9/2008', 'MM/DD/YYYY'), 'diksha11it@gmail.com');

🧠 Step 3: Modifying Tables – Add a Phone Number Column
ALTER TABLE Students
ADD PhoneNo VARCHAR2(10);


This command added a new column to store student phone numbers.

🛡️ Step 4: Adding Constraints – Validating Credits
ALTER TABLE Courses
ADD CHECK (Credits BETWEEN 1 AND 5);

This ensures that no course is added with 0 or more than 5 credits — a simple yet important data validation rule.

📘 Step 5: Inserting Courses
INSERT INTO Courses (CourseID, CourseName, Credits)
VALUES (101, 'MACHINE LEARNING', 3);

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

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

🔍 Step 6: Querying Data

Let’s get all student information including the new PhoneNo column:

SELECT StudentID, Name, Dept, DOB, Email, PhoneNo
FROM Students;

Output Example:

STUDENTID   NAME    DEPT    DOB EMAIL   PHONENO
1   HARINI  Computer Science    3/15/2007   harini16cs@gmail.com
    (null)
2   DIVYA   AIDS    11/22/2007  divya12ad@gmail.com
    (null)
3   DIKSHA  IT  7/9/2008    diksha11it@gmail.com
    (null)

Note: I haven’t added phone numbers yet, so they appear as null.`