DEV Community: DIKSHA P 24CB010

AWS Device Farm: Test Your Apps on Real Devices at Scale

DIKSHA P 24CB010 — Thu, 18 Dec 2025 17:11:27 +0000

Building a great mobile or web application is not just about writing good code—it’s about ensuring your app works perfectly across different devices, browsers, and operating systems. This is where AWS Device Farm becomes a powerful testing solution for modern DevOps teams.

What is AWS Device Farm?

AWS Device Farm is a cloud-based testing service provided by Amazon Web Services that allows developers to test mobile and web applications on real physical devices hosted in AWS data centers.

Why Use AWS Device Farm?

In real-world usage, users access apps from many devices with different screen sizes, OS versions, and hardware capabilities. Testing on emulators alone is not enough.

Reducing device management costs

Catching bugs that appear only on real devices

Improving app quality before production

Supporting continuous testing in CI/CD pipelines

Key Features of AWS Device Farm
Real Device Testing

Test your Android, iOS, and web applications on real smartphones and tablets, not simulators. This ensures accurate results for performance, UI, and hardware behavior.

Automated Testing

AWS Device Farm supports popular test frameworks such as:

Appium

Selenium

Espresso

XCTest

You can run large test suites in parallel to save time.

Remote Access

Need to manually test your app? AWS Device Farm provides remote access to devices so you can interact with them in real time through your browser.

Detailed Test Reports

After every test run, Device Farm generates:

Logs

Screenshots

Videos

Performance metrics

These reports make debugging faster and easier.

AWS Device Farm in CI/CD

AWS Device Farm integrates smoothly with CI/CD tools like AWS CodePipeline, Jenkins, GitHub Actions, and GitLab. Teams can automatically trigger tests on every build or pull request.

This enables continuous testing, ensuring quality is maintained throughout the development lifecycle.

Use Cases

Mobile app compatibility testing

Cross-browser web testing

Regression testing

Pre-release validation

DevOps and QA automation workflows

Benefits of AWS Device Farm

No physical device maintenance

Scalable and on-demand testing

Pay only for what you use

Reliable testing on real devices

Things to Consider

Pricing depends on device usage time

Initial setup requires test framework knowledge

Device availability may vary by region

Final Thoughts

AWS Device Farm is an excellent choice for teams that want reliable, scalable, and realistic app testing without managing their own device labs. By integrating real-device testing into CI/CD pipelines, teams can release high-quality applications with confidence.thank you @santhoshnc sir

Datadog: the periodic table DevOps

DIKSHA P 24CB010 — Thu, 18 Dec 2025 16:59:41 +0000

Modern applications are no longer simple. They run across multiple servers, containers, clouds, and microservices. Keeping track of performance, availability, and security can quickly become overwhelming. This is where Datadog becomes an essential DevOps tool.

What is Datadog?

Datadog is a cloud-based monitoring and observability platform that helps teams track the health and performance of their infrastructure and applications in real time. It brings metrics, logs, traces, and security data into a single, unified view.

Why DevOps Teams Use Datadog

Faster issue detection

Continuous monitoring

Improved collaboration between developers and operations

Better reliability in production environments

Key Capabilities
Infrastructure Monitoring

Datadog monitors servers, virtual machines, containers, and cloud services like AWS, Azure, and Google Cloud. It automatically detects hosts and services, making setup easy.

Application Performance Monitoring (APM)

With distributed tracing, Datadog shows how requests move through your application. This makes it easy to identify slow services, errors, and performance bottlenecks—especially in microservices architectures.

Log Management

Datadog collects and analyzes logs from applications and infrastructure. Logs can be directly correlated with metrics and traces, helping teams debug issues faster.

Alerts & Dashboards

Custom dashboards and smart alerts notify teams when something goes wrong. Alerts can be based on thresholds or anomalies, reducing alert fatigue.

Security & DevSecOps

Datadog also supports security monitoring by detecting threats, misconfigurations, and compliance issues in real time.

Datadog in CI/CD Pipelines

Datadog integrates smoothly with CI/CD tools like GitHub Actions, GitLab, Jenkins, and Azure DevOps. Teams can monitor deployments, track performance changes after releases, and quickly roll back when needed.

Benefits of Using Datadog

Single platform for observability

Easy integration with hundreds of tools

Scales well for growing applications

Clean and user-friendly interface

Final Thoughts

Datadog is more than a monitoring tool—it is a complete observability solution for modern DevOps teams. By providing deep visibility across infrastructure, applications, and security, Datadog helps teams build reliable, high-performing systems with confidence. thank you @santhoshnc

sir for motivate to do this blog

MongoDB - Blog

DIKSHA P 24CB010 — Sat, 04 Oct 2025 15:39:20 +0000

db.students.insertMany([
{
"student_id": "S001",
"name": "Santhosh",
"age": 20,
"department": "CSBS",
"year": 2,
"cgpa": 9
},
{
"student_id": "S002",
"name": "Aarav",
"age": 21,
"department": "CSE",
"year": 3,
"cgpa": 8.5
},
{
"student_id": "S003",
"name": "Meera",
"age": 19,
"department": "ECE",
"year": 1,
"cgpa": 7.2
},
{
"student_id": "S004",
"name": "Divya",
"age": 22,
"department": "CSE",
"year": 3,
"cgpa": 9.1
},
{
"student_id": "S005",
"name": "Rohan",
"age": 20,
"department": "MECH",
"year": 2,
"cgpa": 6.8
}
])
Read (Query)
Display all student records
js
db.students.find()
Find all students with CGPA > 8
js
db.students.find({ cgpa: { $gt: 8 } })
Find students belonging to the Computer Science department
js
db.students.find({ department: "CSE" })
Update
Update the CGPA of a specific student (e.g., student_id: "S003")
js
db.students.updateOne(
{ student_id: "S003" },
{ $set: { cgpa: 7.8 } }
)
Increase the year of study for all 3rd year students by 1
js
db.students.updateMany(
{ year: 3 },
{ $inc: { year: 1 } }
)
Delete
Delete one student record by student_id (e.g., "S005")
js
db.students.deleteOne({ student_id: "S005" })
Delete all students having CGPA < 7.5
js
db.students.deleteMany({ cgpa: { $lt: 7.5 } })

Indexing, Hashing & Query Optimization IN DBMS

DIKSHA P 24CB010 — Sat, 04 Oct 2025 10:29:09 +0000

Indexes are the secret sauce behind fast database queries. In this post, we’ll create a Students table, populate it with sample data, and explore three powerful indexing strategies:
B-Tree Index
B+ Tree Index
Hash Index

Step 1: Create the Students Table
sql
CREATE TABLE Students (
roll_no INT PRIMARY KEY,
name VARCHAR(50),
dept VARCHAR(10),
cgpa DECIMAL(3,2)
);
Step 2: Insert Sample Records
sql
INSERT INTO Students VALUES (101, 'Aarav', 'CSBS', 8.5);
INSERT INTO Students VALUES (102, 'Meera', 'ECE', 7.8);
INSERT INTO Students VALUES (103, 'Ravi', 'MECH', 6.9);
INSERT INTO Students VALUES (104, 'Sneha', 'CSBS', 9.1);
INSERT INTO Students VALUES (105, 'Kiran', 'EEE', 7.2);
INSERT INTO Students VALUES (106, 'Divya', 'CSBS', 8.7);
INSERT INTO Students VALUES (107, 'Aditya', 'CIVIL', 6.5);
INSERT INTO Students VALUES (108, 'Neha', 'ECE', 8.0);
INSERT INTO Students VALUES (109, 'Rahul', 'MECH', 7.4);
INSERT INTO Students VALUES (110, 'Priya', 'CSBS', 9.3);
INSERT INTO Students VALUES (111, 'Varun', 'EEE', 7.6);
INSERT INTO Students VALUES (112, 'Isha', 'CIVIL', 8.2);
INSERT INTO Students VALUES (113, 'Manav', 'CSBS', 8.9);
INSERT INTO Students VALUES (114, 'Tanya', 'ECE', 7.0);
INSERT INTO Students VALUES (115, 'Rohit', 'MECH', 6.8);
INSERT INTO Students VALUES (116, 'Anjali', 'CSBS', 9.0);
INSERT INTO Students VALUES (117, 'Siddharth', 'EEE', 7.3);
INSERT INTO Students VALUES (118, 'Pooja', 'CIVIL', 8.1);
INSERT INTO Students VALUES (119, 'Nikhil', 'CSBS', 8.6);
INSERT INTO Students VALUES (120, 'Simran', 'ECE', 7.9);
Step 3: B-Tree Index on roll_no
B-Tree indexes are the default in most databases and great for range and equality queries.

sql
CREATE INDEX idx_rollno_btree ON Students(roll_no);
Query: Fetch Student with roll_no = 110
sql
SELECT * FROM Students WHERE roll_no = 110;

Step 4: B+ Tree Index on cgpa
While Oracle uses B-Tree by default, some systems like PostgreSQL simulate B+ Tree behavior. For educational purposes, we’ll treat this as a logical B+ Tree index.

sql
CREATE INDEX idx_cgpa_bplus ON Students(cgpa);
Students with cgpa > 8.0
sql
SELECT * FROM Students WHERE cgpa > 8.0

thank you @santhoshnc sir

Transactions, Deadlocks & Log Based Recovery

DIKSHA P 24CB010 — Sat, 04 Oct 2025 10:20:01 +0000

database transactions are more than just BEGIN and COMMIT. They’re the backbone of data integrity, especially when things go wrong. In this post, we’ll explore three powerful concepts:

Atomicity & Rollback
Deadlock Simulation
Log-Based Recovery

Atomicity & Rollback: All or Nothing Imagine Alice wants to transfer ₹500 to Bob. We start a transaction, update both accounts, and then rollback before committing.

SQL Example
sql

BEGIN;
UPDATE Accounts SET balance = balance - 500 WHERE name = 'Alice';
UPDATE Accounts SET balance = balance + 500 WHERE name = 'Bob';
ROLLBACK;

sql
SELECT name, balance FROM Accounts WHERE name IN ('Alice', 'Bob');
Result: No changes. That’s Atomicity—either all operations succeed or none do.

Deadlock Simulation: When Transactions Collide Deadlocks happen when two sessions wait on each other indefinitely.

Session 1
sql
BEGIN;
UPDATE Accounts SET balance = balance + 100 WHERE name = 'Alice';
UPDATE Accounts SET balance = balance - 100 WHERE name = 'Bob';
Session 2
sql
BEGIN;
UPDATE Accounts SET balance = balance + 100 WHERE name = 'Bob';
UPDATE Accounts SET balance = balance - 100 WHERE name = 'Alice';

Log-Based Recovery: Most modern databases (MySQL, PostgreSQL, Oracle) use transaction logs to track changes.

Step-by-Step
sql
BEGIn;
UPDATE Accounts SET balance = balance + 1000 WHERE name = 'Alice';
ROLLBACK;
Final Thoughts
Transactions are the heartbeat of reliable databases. Whether you're building fintech apps or inventory systems, understanding how atomicity, deadlocks, and recovery work will make you a better engineer.

Thank you @santhoshnc sir

ACID PROPERTY IN DBMS

DIKSHA P 24CB010 — Sat, 04 Oct 2025 10:03:05 +0000

you're learning database fundamentals, you've probably heard of ACID—Atomicity, Consistency, Isolation, and Durability. These properties ensure reliable transactions in relational databases.

Let’s explore each one with real SQL examples using an Accounts table.

Step 1: Create the Table and Insert Sample Data
sql
CREATE TABLE Accounts (
acc_no INT PRIMARY KEY,
name VARCHAR(50),
balance INT CHECK (balance >= 0) -- Enforces Consistency
);

-- Insert sample rows
INSERT INTO Accounts VALUES (101, 'Aarav', 50000);
INSERT INTO Accounts VALUES (102, 'Meera', 30000);
INSERT INTO Accounts VALUES (103, 'Ravi', 70000);
Exploring ACID Properties

Atomicity: All or Nothing Let’s simulate a money transfer from Aarav to Meera. We’ll start a transaction and rollback midway to ensure no partial updates remain.

sql
BEGIN
UPDATE Accounts SET balance = balance - 10000 WHERE acc_no = 101; -- Aarav
UPDATE Accounts SET balance = balance + 10000 WHERE acc_no = 102; -- Meera

-- Something goes wrong, rollback!
ROLLBACK;
END;

Consistency: Data Integrity Rules Try inserting a record with a negative balance:

sql
INSERT INTO Accounts VALUES (104, 'Kiran', -5000);

Isolation: Transactions Don’t Clash Open Session A and run:

sql
BEGIN
UPDATE Accounts SET balance = balance + 5000 WHERE acc_no = 103;
sql
SELECT balance FROM Accounts WHERE acc_no = 103;
Result: Session B sees the old balance until Session A commits. That’s Isolation—transactions don’t interfere with each other.

4. Durability: Data Persists After Commit
sql
BEGIN
UPDATE Accounts SET balance = balance + 10000 WHERE acc_no = 102;
COMMIT;
END;
Now, restart your database or session and run:

sql
SELECT * FROM Accounts WHERE acc_no = 102;

Final Thoughts
ACID properties are the backbone of reliable database systems. Whether you're building banking software Thank you @santhoshnc sir

TRIGGER AND CURSORS IN DBMS

DIKSHA P 24CB010 — Sat, 04 Oct 2025 09:41:15 +0000

If you're diving into Oracle SQL and want to explore how cursors work, this post is for you! Let's walk through a simple example where we use a cursor to display employee names whose salary exceeds ₹50,000.

What’s a Cursor?
A cursor in SQL is a pointer that allows you to iterate through query results row by row. It’s especially useful when you need to process each record individually.

The Scenario
We have an Employee table with columns like emp_name and salary. Our goal is to display the names of employees earning more than ₹50,000.

The Code
sql
DECLARE
-- Variable to hold employee name
v_emp_name Employee.emp_name%TYPE;

-- Cursor declaration
CURSOR high_salary_cursor IS
SELECT emp_name
FROM Employee
WHERE salary > 50000;

BEGIN
-- Loop through the cursor
FOR emp_record IN high_salary_cursor LOOP
DBMS_OUTPUT.PUT_LINE('Employee Name: ' || emp_record.emp_name);
END LOOP;
END;

Triggers in Oracle SQL are like little watchdogs—they automatically execute when certain events happen in the database. Let’s create a trigger that logs a message whenever a new employee is inserted into the Employee table.

The Trigger Code
sql
CREATE OR REPLACE TRIGGER log_new_employee
AFTER INSERT ON Employee
FOR EACH ROW
BEGIN
DBMS_OUTPUT.PUT_LINE('New employee added: ' || :NEW.emp_name || ', Salary: ' || :NEW.salary);
END;
What’s Happening Here?
AFTER INSERT ON Employee: The trigger fires after a new row is inserted.
After creating the trigger, insert a new employee:

sql
INSERT INTO Employee VALUES (101, 'Priya', 60000);

Combining cursors and triggers gives you powerful control over your data flow. Cursors help you process data row-by-row, while triggers let you react to changes automatically.Thank you @santhoshnc sir for guide me

Normalization in 1NF,2NF,3NF in DBMS

DIKSHA P 24CB010 — Sat, 04 Oct 2025 08:01:11 +0000

Normalization is a key concept in relational database design. It helps eliminate redundancy and improve data integrity. In this post, we’ll explore the first three normal forms—1NF, 2NF, and 3NF—and implement each using SQL CREATE TABLE statements.

First Normal Form (1NF)
Rule:

Each column should contain atomic (indivisible) values.

No repeating groups or arrays.

Example: Unnormalized Table

sql
CREATE TABLE Students (
student_id INT,
name VARCHAR(100),
subjects VARCHAR(255) -- e.g., 'Math, Science, English'
);
Normalized to 1NF

sql
CREATE TABLE StudentSubjects (
student_id INT,
name VARCHAR(100),
subject VARCHAR(50) -- one subject per row
);

Second Normal Form (2NF)
Rule:

Must be in 1NF

All non-key attributes must be fully functionally dependent on the entire primary key.

Problem Example (Partial Dependency)

sql
CREATE TABLE Enrollments (
student_id INT,
course_id INT,
student_name VARCHAR(100) -- depends only on student_id
);
Normalized to 2NF

sql
CREATE TABLE Students (
student_id INT PRIMARY KEY,
student_name VARCHAR(100)
);

CREATE TABLE Courses (
course_id INT PRIMARY KEY,
course_name VARCHAR(100)
);

CREATE TABLE Enrollments (
student_id INT,
course_id INT,
PRIMARY KEY (student_id, course_id)
);

Third Normal Form (3NF)
Rule:

Must be in 2NF

No transitive dependencies (non-key attributes should not depend on other non-key attributes)

Problem Example (Transitive Dependency)

sql
CREATE TABLE Employees (
emp_id INT PRIMARY KEY,
emp_name VARCHAR(100),
dept_name VARCHAR(100),
dept_location VARCHAR(100) -- depends on dept_name
);
Normalized to 3NF

sql
CREATE TABLE Departments (
dept_name VARCHAR(100) PRIMARY KEY,
dept_location VARCHAR(100)
);

CREATE TABLE Employees (
emp_id INT PRIMARY KEY,
emp_name VARCHAR(100),
dept_name VARCHAR(100),
FOREIGN KEY (dept_name) REFERENCES Departments(dept_name)
);
Summary
Normal Form Key Focus
1NF Atomic values, no repeating groups
2NF Full functional dependency
3NF No transitive dependency
Normalization helps keep your data clean, consistent, and scalable. If you’re building relational databases, mastering these forms is essential.

Thank you @santhoshnc sir for guideing me

COLLEGE STUDENT AND COURSE MANAGEMENT SYSTEM.

DIKSHA P 24CB010 — Mon, 25 Aug 2025 10:19:42 +0000

Creating a Simple Student-Course Database in Oracle SQL

In this post,we are going to know about how to create a basic Student-Course Enrollment System using Oracle SQL. This includes creating tables, inserting sample data, applying constraints, and running a few useful queries.

Step 1: Creating the Tables

We’ll start by creating three core tables: Students, Courses, and Enrollments.

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

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

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

Step 2: Inserting Sample Students

Here, we insert 3 sample students from different departments:

INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (1, 'raj Kumar', 'csbs', TO_DATE('2005-03-15', 'YYYY-MM-DD'), 'raj.csbs@example.com');

INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (2, 'harini R', 'mechanical Engineering', TO_DATE('2004-11-22', 'YYYY-MM-DD'), 'harini.mech@example.com');

INSERT INTO Students (StudentID, Name, Dept, DOB, Email)
VALUES (3, 'laksita S', 'civil Engineering', TO_DATE('2005-07-09', 'YYYY-MM-DD'), 'laksita.civil@example.com');

Step 3: Modifying the Table

We now add a PhoneNo column to the Students table:

ALTER TABLE Students
ADD PhoneNo VARCHAR2(10);

Step 4: Adding Constraints

Ensure that the Credits for courses are between 1 and 5:

ALTER TABLE Courses
ADD CHECK (Credits BETWEEN 1 AND 5);

Step 5: Inserting Sample Courses

Let's add a few courses to our database:

INSERT INTO Courses (CourseID, CourseName, Credits)
VALUES (101, 'cyber security', 3);

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

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

COMMIT;

Step 6: Running Sample Queries

Display Student Names in Uppercase and Email Length:
SELECT
UPPER(Name) AS Student_Name,
LENGTH(Email) AS Email_Length
FROM Students;
Display All Courses with Credits:
SELECT CourseID, CourseName, Credits
FROM Courses;
Display All Student Details:
SELECT StudentID, Name, Dept, DOB, Email, PhoneNo
FROM Students;

THANK YOU @santhoshnc sir. For guiding me .