DEV Community: Adhi sankar

PostgreSQL: A Beginner's Guide to Getting Started

Adhi sankar — Mon, 10 Aug 2026 09:55:07 +0000

If you're learning backend development, one database you should definitely know is PostgreSQL.

PostgreSQL is a powerful open-source relational database management system (RDBMS) that uses SQL to store, manage, and retrieve data.

What is PostgreSQL?

PostgreSQL is a relational database where data is stored in tables made up of rows and columns.

For example, an employee table might contain:

id	name	age
1	Adhi	21
2	Ravi	24
3	Kumar	22

Each row represents an employee, while each column represents a particular piece of information.

DBMS vs RDBMS

DBMS stands for Database Management System.

RDBMS stands for Relational Database Management System.

An RDBMS stores data in related tables and allows us to establish relationships between them.

PostgreSQL is an RDBMS.

Creating a Database

We can create a database using:

CREATE DATABASE company;

After creating it, we can connect to the database and create tables.

Creating a Table

CREATE TABLE employee (
    id INT,
    name VARCHAR(50),
    age INT
);

Here:

id stores the employee ID
name stores the employee name
age stores the employee's age

Inserting Data

To insert a row:

INSERT INTO employee
VALUES (1, 'Adhi', 21);

We can insert another employee:

INSERT INTO employee
VALUES (2, 'Ravi', 24);

Reading Data

To retrieve all employees:

SELECT * FROM employee;

To retrieve only the names:

SELECT name FROM employee;

Filtering Data

The WHERE clause is used to filter records.

SELECT * FROM employee
WHERE age = 21;

We can also use conditions such as:

SELECT * FROM employee
WHERE age > 21;

Updating Data

To change existing data:

UPDATE employee
SET name = 'Rahul'
WHERE id = 2;

Always be careful with UPDATE. Using it without a WHERE condition can change every row.

Deleting Data

To delete a particular employee:

DELETE FROM employee
WHERE id = 2;

To delete all rows while keeping the table:

DELETE FROM employee;

To delete the entire table:

DROP TABLE employee;

Altering a Table

We can add a new column using:

ALTER TABLE employee
ADD COLUMN salary INT;

We can remove a column using:

ALTER TABLE employee
DROP COLUMN salary;

We can rename a table:

ALTER TABLE employee
RENAME TO employees;

And rename a column:

ALTER TABLE employee
RENAME COLUMN name TO full_name;

Sorting Data

ORDER BY is used to sort results.

Ascending order:

SELECT * FROM employee
ORDER BY age ASC;

Descending order:

SELECT * FROM employee
ORDER BY age DESC;

Aggregate Functions

PostgreSQL provides useful functions for calculations.

Count

SELECT COUNT(*) FROM employee;

Average

SELECT AVG(age) FROM employee;

Maximum

SELECT MAX(age) FROM employee;

Minimum

SELECT MIN(age) FROM employee;

Sum

SELECT SUM(salary) FROM employee;

Important PostgreSQL Topics to Learn

After learning these basics, you should move on to:

Primary Keys
Foreign Keys
Constraints
Joins
GROUP BY
HAVING
Subqueries
CTEs
Indexes
Transactions
Views
PostgreSQL data types
JSON/JSONB
Query optimization

Conclusion

PostgreSQL is an important skill for backend and full-stack developers.

The best way to learn it isn't by memorizing commands. Create a small database, insert data, query it, update it, delete it, and practice different SQL problems.

Understanding Python `range()` with Real-Life Examples

Adhi sankar — Wed, 05 Aug 2026 11:27:55 +0000

When learning Python, one of the first concepts you'll encounter is the range() function. It is commonly used with loops to repeat tasks a specific number of times.

Instead of using random numbers, let's understand range() through simple real-life examples.

What is `range()`?

The range() function generates a sequence of numbers.

Syntax

range(start, stop, step)

start → The number where the sequence begins.
stop → The sequence ends before this number.
step → The amount by which the numbers increase or decrease.

Example 1: Assigning Roll Numbers

Imagine five students enter a classroom one after another.

First student → Roll Number 1
Second student → Roll Number 2
Third student → Roll Number 3
Fourth student → Roll Number 4
Fifth student → Roll Number 5

Code

for i in range(1, 6):
    print(i)

Output

Explanation

range(1, 6)

starts from 1 and stops before 6, so Python prints:

1 → 2 → 3 → 4 → 5

Example 2: Even Queue Positions

A coach asks students to stand only in even-numbered positions.

The first five even positions are:

2, 4, 6, 8, 10

Code

for a in range(2, 12, 2):
    print(a)

Output

Explanation

range(2, 12, 2)

Starts at 2
Stops before 12
Increases by 2 every time

Sequence:

2 → 4 → 6 → 8 → 10

Example 3: Lift Stops Every Third Floor

A newly constructed building has a lift that stops only at every third floor for safety reasons.

Starting from the ground floor, display the first five stops.

Code

for b in range(0, 15, 3):
    print(b)

Output

Explanation

range(0, 15, 3)

Starts from floor 0
Stops before 15
Moves 3 floors each time

Sequence:

0 → 3 → 6 → 9 → 12

Example 4: Rocket Countdown

A rocket launches with a countdown using only even numbers.

Code

for c in range(10, -1, -2):
    print(c)

Output

Explanation

range(10, -1, -2)

Starts at 10
Counts backward
Decreases by 2
Stops after printing 0

Sequence:

10 → 8 → 6 → 4 → 2 → 0

Understanding the Three Parameters

Parameter	Meaning	Example
Start	Where counting begins	`1`
Stop	Stops before this value	`6`
Step	Increment or decrement	`2` or `-2`

Example:

range(1, 6)

Produces:

1 2 3 4 5

Example:

range(10, -1, -2)

Produces:

10 8 6 4 2 0

Why Use `range()`?

The range() function makes loops simple and efficient.

It helps when you need to:

Assign serial numbers
Print even or odd numbers
Generate countdowns
Skip numbers with custom intervals
Repeat tasks multiple times

Final Thoughts

The range() function is one of the most useful tools in Python programming. Once you understand its three parameters—start, stop, and step—you can solve many looping problems with ease.

Using real-life examples like roll numbers, queue positions, lift stops, and rocket countdowns makes learning range() much more intuitive.

APIs in JavaScript: A Beginner's Guide

Adhi sankar — Tue, 04 Aug 2026 12:09:28 +0000

What is an API?

API stands for Application Programming Interface.

An API allows two applications to communicate with each other.

For example:

A weather app requests weather information.
A shopping website requests product details.
A movie app requests movie information.
A social media app requests user profiles.

Instead of storing all the data inside your application, you simply request it from an API.

How Does an API Work?

The communication process looks like this:

User
   │
   ▼
JavaScript Application
   │
   ▼
API Request
   │
   ▼
Server
   │
   ▼
JSON Response
   │
   ▼
Display Data on Web Page

What is Fetch API?

The Fetch API is a built-in JavaScript feature used to send HTTP requests and receive responses from a server.

Basic syntax:

fetch(url)
    .then(response => response.json())
    .then(data => {
        console.log(data);
    })
    .catch(error => {
        console.log(error);
    });

Understanding the Code

Step 1: Send a Request

fetch("https://fakestoreapi.com/products")

This sends a GET request to the API.

Step 2: Convert the Response into JSON

.then(response => response.json())

The server sends data in JSON format.

response.json() converts it into a JavaScript object.

Step 3: Use the Data

.then(data => {
    console.log(data);
})

Now you can display the data on your webpage.

Step 4: Handle Errors

.catch(error => {
    console.log(error);
})

If something goes wrong, the error is displayed in the console.

Complete Example

HTML

<button onclick="loadProducts()">
    Load Products
</button>

<div id="products"></div>

JavaScript

function loadProducts() {

    fetch("https://fakestoreapi.com/products")

    .then(response => response.json())

    .then(data => {

        let output = "";

        data.forEach(product => {

            output += `
                <div>
                    <h3>${product.title}</h3>
                    <img src="${product.image}" width="120">
                    <p>$${product.price}</p>
                </div>
            `;

        });

        document.getElementById("products").innerHTML = output;

    })

    .catch(error => {

        console.log(error);

    });

}

When you click the button, JavaScript fetches product data from the API and displays each product's title, image, and price.

Common HTTP Methods

Method	Purpose
GET	Retrieve data
POST	Create new data
PUT	Update existing data
DELETE	Remove data

The Fetch API supports all these methods.

Example of a POST request:

fetch("https://example.com/users", {
    method: "POST",
    headers: {
        "Content-Type": "application/json"
    },
    body: JSON.stringify({
        name: "John",
        age: 22
    })
});

Checking the Response Status

fetch("https://fakestoreapi.com/products")

.then(response => {

    if (!response.ok) {
        throw new Error("Request Failed");
    }

    return response.json();

})

.then(data => console.log(data))

.catch(error => console.log(error));

Checking response.ok helps ensure the request was successful before processing the data.

Advantages of Fetch API

Built into modern browsers
Easy to learn and use
Supports Promises
Works with JSON data
Supports asynchronous programming
Cleaner than older AJAX methods

Best Practices

Always use .catch() to handle errors.
Check response.ok before reading the response.
Keep API keys secure.
Avoid making unnecessary API requests.
Use meaningful variable names.
Display user-friendly error messages.

Real-World Uses of APIs in JavaScript

Weather applications
E-commerce websites
Movie search apps
News websites
Currency converters
Chat applications
Travel booking systems

Conclusion

The Fetch API makes it easy for JavaScript applications to communicate with servers and retrieve data. By understanding how to send requests, process JSON responses, and handle errors, you can build interactive and dynamic web applications.

If you're just starting with JavaScript, practice using free public APIs like Fake Store API or JSONPlaceholder. It's one of the best ways to improve your frontend development skills.

Python Modules Explained: Write Cleaner and Reusable Code

Adhi sankar — Tue, 04 Aug 2026 12:03:01 +0000

When writing Python programs, you may notice that some code gets repeated again and again. Instead of copying the same code into every file, Python provides modules to help organize and reuse your code.

In this blog, you'll learn what a Python module is, why it's useful, and how to create and use your own modules.

What is a Python Module?

A module is simply a Python file (.py) that contains Python code such as:

Functions
Variables
Classes

You can import a module into another Python file and use its contents without rewriting the code.

For example:

import math

print(math.sqrt(25))

Output:

5.0

Here, math is a built-in Python module.

Why Use Modules?

Modules make programming easier because they:

Reuse code instead of rewriting it.
Keep programs organized.
Make debugging easier.
Improve readability.
Allow developers to share code.

Built-in Modules

Python comes with many built-in modules.

math

import math

print(math.pi)
print(math.factorial(5))

Output:

3.141592653589793
120

random

import random

print(random.randint(1, 10))

This generates a random number between 1 and 10.

datetime

import datetime

today = datetime.datetime.now()

print(today)

This displays the current date and time.

Creating Your Own Module

Suppose you create a file named calculator.py.

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

Now create another file named main.py.

import calculator

print(calculator.add(10, 5))
print(calculator.subtract(10, 5))

Output:

15
5

Your own module works just like Python's built-in modules.

Different Ways to Import Modules

1. Import the entire module

import math

print(math.sqrt(16))

2. Import specific functions

from math import sqrt

print(sqrt(16))

3. Import with an alias

import math as m

print(m.pi)

Aliases make code shorter and easier to read.

The dir() Function

The dir() function displays everything inside a module.

import math

print(dir(math))

This helps you discover available functions and constants.

Module Search Path

When Python imports a module, it searches in the following order:

Current project folder
Installed Python packages
Python's standard library

If Python cannot find the module, it raises a ModuleNotFoundError.

Best Practices

Give modules meaningful names.
Keep each module focused on one purpose.
Avoid duplicate code.
Group related functions together.
Use comments and documentation where needed.

Advantages of Modules

Better code organization
Easy maintenance
Code reusability
Faster development
Improved readability
Easier collaboration with teams

Conclusion

Python modules are one of the most powerful features of the language. They help you organize your code into smaller, reusable pieces, making programs cleaner and easier to maintain.

Build a Simple To-Do List Using JavaScript (Step-by-Step)

Adhi sankar — Sat, 01 Aug 2026 11:02:09 +0000

A To-Do List is one of the best beginner projects for learning JavaScript. It teaches you how to work with the DOM, handle events, create HTML elements dynamically, and remove elements from a webpage.

In this article, we'll build a simple To-Do List where users can:

Add a new task
Prevent empty tasks
Delete a task
Clear the input field after adding a task

Let's understand the JavaScript code line by line.

Selecting HTML Elements

const input = document.getElementById("input");
const button = document.getElementById("btn");
const ul = document.getElementById("value");

What's happening?

First, we select the HTML elements that we want to work with.

input stores the text box where the user types a task.
button stores the Add button.
ul stores the unordered list that will display all tasks.

Instead of searching for these elements every time, we store them in variables for easy access.

Listening for the Button Click

button.addEventListener("click", function touch() {

The addEventListener() method waits for an event.

Here, the event is "click".

This means:

Whenever the user clicks the Add button, execute the function.

The function name touch is optional. Since the function isn't called anywhere else, you could also write:

button.addEventListener("click", function () {

Both versions work the same.

Checking for Empty Input

if (input.value.trim() === "") {
    alert("please enter the value");
    return;
}

Before adding a task, we check whether the input field is empty.

`input.value`

Gets the text entered by the user.

Example:

Learn JavaScript

`trim()`

Removes spaces from the beginning and end of the string.

For example:

"   Hello   "

becomes

"Hello"

If the user enters only spaces, trim() converts them into an empty string.

Why use `return`?

If the input is empty:

An alert is displayed.
return immediately stops the function.
No task is added.

Without return, JavaScript would continue executing the remaining code and create an empty list item.

Creating a New Task

const li = document.createElement("li");

The createElement() method creates a new HTML element.

Here, it creates a new list item:

<li></li>

At this point, the element exists only in memory.

It won't appear on the webpage until we add it to the DOM.

Adding the Task Text

li.innerText = input.value;

This places the user's input inside the <li>.

If the user enters:

Buy Milk

The element becomes:

<li>Buy Milk</li>

Creating the Delete Button

const deletebtn = document.createElement("button");
deletebtn.innerText = "delete";

First, a new button is created.

Then its text is set to delete.

The result is:

<button>delete</button>

Adding the Delete Functionality

deletebtn.addEventListener("click", function () {
    ul.removeChild(li);
});

Each task gets its own Delete button.

When the Delete button is clicked:

JavaScript finds the corresponding <li>
Removes it from the <ul>

As a result, the task disappears from the page.

Displaying the Task

ul.appendChild(li);

This adds the new <li> to the unordered list.

Before:

<ul></ul>

After:

<ul>
    <li>Buy Milk</li>
</ul>

Now the task becomes visible.

Adding the Delete Button to the Task

li.appendChild(deletebtn);

This places the Delete button inside the list item.

Final structure:

<li>
    Buy Milk
    <button>delete</button>
</li>

Every task now has its own Delete button.

Clearing the Input Field

input.value = "";

After adding a task, the input field is cleared automatically.

This allows the user to type the next task without manually deleting the previous text.

How the Program Works

User enters a task
        │
        ▼
Clicks Add button
        │
        ▼
Is the input empty?
        │
   Yes ─────► Show alert
        │           │
        │           ▼
        │        return
        │
       No
        ▼
Create a new <li>
        ▼
Add the task text
        ▼
Create a Delete button
        ▼
Attach Delete functionality
        ▼
Display the task
        ▼
Clear the input field

What You'll Learn

By building this simple project, you'll practice:

DOM Manipulation
Event Listeners
Functions
Conditional Statements (if)
trim()
return
createElement()
appendChild()
removeChild()
innerText

These concepts are the building blocks of interactive web applications.

Final Thoughts

A To-Do List may look like a small project, but it teaches many essential JavaScript concepts used in real-world applications. Once you're comfortable with this version, try improving it by adding features such as editing tasks, marking tasks as completed, searching tasks, and saving tasks with localStorage.

Auto Enable and Disable a Submit Button Using JavaScript

Adhi sankar — Fri, 31 Jul 2026 11:48:11 +0000

HTML

<input type="checkbox" id="check"> I agree
<button id="btn" disabled>Submit</button>

Explanation

The checkbox allows the user to agree to the terms.
The button has the disabled attribute, so it is disabled when the page first loads.

JavaScript - Method 1 (Recommended)

const checkbox = document.getElementById("check");
const button = document.getElementById("btn");

checkbox.addEventListener("change", function () {
    button.disabled = !checkbox.checked;
});

Step-by-Step Explanation

Step 1: Select the HTML Elements

const checkbox = document.getElementById("check");
const button = document.getElementById("btn");

document.getElementById() selects HTML elements using their id.

After these two lines:

checkbox refers to the checkbox.
button refers to the Submit button.

Step 2: Listen for Changes

checkbox.addEventListener("change", function () {

What is `addEventListener()`?

addEventListener() tells JavaScript to listen for a specific event on an element.

Syntax

element.addEventListener("event", function);

In our example

Element: checkbox
Event: "change"
Function: Runs whenever the checkbox changes.

Why Use the `"change"` Event?

The "change" event is triggered whenever the checkbox changes its state.

For example:

Action	Checkbox State	`change` Event
User checks the box	Checked	✅ Yes
User unchecks the box	Unchecked	✅ Yes

Every time the checkbox changes, JavaScript executes the function.

Step 3: Enable or Disable the Button

button.disabled = !checkbox.checked;

This single line does all the work.

Let's understand it from right to left.

`checkbox.checked`

The checked property returns a Boolean value.

Checkbox	`checkbox.checked`
Checked	`true`
Unchecked	`false`

The `!` (Logical NOT) Operator

The ! operator reverses a Boolean value.

Original Value	After `!`
`true`	`false`
`false`	`true`

Examples:

!true

Output:

false

!false

Output:

true

`button.disabled`

The disabled property determines whether a button is enabled.

Value	Result
`true`	Button is disabled
`false`	Button is enabled

Putting Everything Together

When the checkbox is checked:

checkbox.checked

returns

true

Then

!true

becomes

false

So JavaScript executes:

button.disabled = false;

The button becomes enabled.

When the checkbox is unchecked:

checkbox.checked

returns

false

Then

!false

becomes

true

So JavaScript executes:

button.disabled = true;

The button becomes disabled.

Flow Diagram

Checkbox Checked?
        │
   ┌────┴────┐
   │         │
  Yes       No
   │         │
checked   checked
 = true    = false
   │         │
!true     !false
   │         │
false      true
   │         │
Button     Button
Enabled   Disabled

JavaScript - Method 2 (Using `if...else`)

const checkbox = document.getElementById("check");
const button = document.getElementById("btn");

checkbox.addEventListener("change", fun);

function fun() {
    if (checkbox.checked == true) {
        button.disabled = false;
    } else {
        button.disabled = true;
    }
}

How Method 2 Works

Whenever the checkbox changes, the fun() function runs.

Inside the function:

if (checkbox.checked == true)

If the checkbox is checked:

button.disabled = false;

The button is enabled.

Otherwise:

button.disabled = true;

The button is disabled.

Method 1 vs Method 2

Method 1	Method 2
One line of code	Multiple lines of code
Uses the Logical NOT (`!`) operator	Uses `if...else`
Short and clean	Easier for beginners to understand
Preferred in modern JavaScript	Good for learning programming logic

Which Method Should You Use?

For beginners, the if...else version is easier to understand because the logic is written step by step.

Once you're comfortable with Boolean values and the Logical NOT (!) operator, the one-line version is the better choice because it's concise, readable, and commonly used in modern JavaScript.

Final Thoughts

Both methods achieve the same result:

Listen for changes on the checkbox.
Check whether the checkbox is selected.
Enable the button when checked.
Disable the button when unchecked.

As you continue learning JavaScript, you'll often find multiple ways to solve the same problem. Understanding both approaches helps you write cleaner code and recognize common patterns used in real-world applications.

Functions in Python: A Beginner's Guide with Examples

Adhi sankar — Fri, 31 Jul 2026 11:44:24 +0000

What is a Function?

A function is a reusable block of code that performs a specific task. Instead of writing the same code multiple times, you can write it once inside a function and call it whenever needed.

Example

def greet():
    print("Hello, Welcome to Python!")

greet()

Output

Hello, Welcome to Python!

In this example:

def is the keyword used to define a function.
greet is the function name.
Parentheses () hold parameters if needed.
The indented block contains the function body.
greet() calls the function.

Why Use Functions?

Functions provide several advantages:

Reduce code duplication.
Improve code readability.
Make programs easier to maintain.
Allow code reuse.
Simplify debugging and testing.

Syntax of a Function

def function_name(parameters):
    # Function body
    return value

Function Without Parameters

A function can work without taking any input.

def say_hello():
    print("Hello World!")

say_hello()

Output

Hello World!

Function With Parameters

Parameters allow you to pass information into a function.

def greet(name):
    print("Hello", name)

greet("Adhi")

Output

Hello Adhi

Function With Multiple Parameters

def add(a, b):
    print(a + b)

add(10, 20)

Output

Returning Values

The return statement sends a value back to the caller.

def square(number):
    return number * number

result = square(5)
print(result)

Output

Difference Between `print()` and `return`

Using `print()`

def add(a, b):
    print(a + b)

add(5, 3)

Output

The value is displayed but cannot be reused.

Using `return`

def add(a, b):
    return a + b

result = add(5, 3)
print(result * 2)

Output

The returned value can be stored and used later.

Default Parameters

You can assign default values to parameters.

def greet(name="Guest"):
    print("Hello", name)

greet()
greet("Adhi")

Output

Hello Guest
Hello Adhi

Keyword Arguments

You can pass arguments using parameter names.

def student(name, age):
    print(name, age)

student(age=21, name="Adhi")

Output

Adhi 21

Arbitrary Arguments (`*args`)

Use *args when you don't know how many arguments will be passed.

def numbers(*values):
    print(values)

numbers(10, 20, 30, 40)

Output

(10, 20, 30, 40)

Arbitrary Keyword Arguments (`**kwargs`)

Use **kwargs to accept multiple keyword arguments.

def student(**details):
    print(details)

student(name="Adhi", age=21, city="Chennai")

Output

{'name': 'Adhi', 'age': 21, 'city': 'Chennai'}

Local Variables

Variables declared inside a function exist only within that function.

def demo():
    message = "Python"
    print(message)

demo()

Global Variables

Variables declared outside a function can be accessed inside it.

language = "Python"

def display():
    print(language)

display()

Output

Python

Lambda Functions

A lambda function is a small anonymous function written in a single line.

square = lambda x: x * x

print(square(6))

Output

Recursive Functions

A recursive function calls itself.

def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))

Output

Built-in Functions

Python provides many built-in functions.

Examples include:

print(len("Python"))

print(max(5, 10, 15))

print(min(5, 10, 15))

print(sum([1, 2, 3, 4]))

Output

Best Practices

Use meaningful function names.
Keep functions short and focused.
Avoid repeating code.
Use comments when necessary.
Return values instead of printing when possible.

Common Mistakes

Forgetting Parentheses

greet

Correct:

greet()

Missing Return Statement

def add(a, b):
    a + b

Correct:

def add(a, b):
    return a + b

Incorrect Indentation

def hello():
print("Hello")

Correct:

def hello():
    print("Hello")

Real-World Example

def calculate_total(price, quantity):
    return price * quantity

product_price = 250
quantity = 4

total = calculate_total(product_price, quantity)

print("Total Amount:", total)

Output

Total Amount: 1000

Summary

Functions are one of Python's most powerful features. They make programs modular, reusable, and easier to maintain. Whether you're writing a small script or a large application, using functions effectively will improve the quality of your code.

Key Takeaways

Functions are reusable blocks of code.
Use def to define a function.
Parameters allow functions to accept input.
return sends values back to the caller.
Python supports default arguments, keyword arguments, *args, and **kwargs.
Lambda functions are useful for short operations.
Recursive functions solve problems by calling themselves.
Good functions are simple, reusable, and easy to understand.

DOM Element Selectors in JavaScript

Adhi sankar — Thu, 30 Jul 2026 15:54:14 +0000

Introduction

When building interactive websites, JavaScript needs a way to access HTML elements. This is where DOM Element Selectors come in.

The DOM (Document Object Model) represents your HTML page as a tree of objects. JavaScript uses selectors to find these objects and modify their content, style, or behavior.

What is the DOM?

The Document Object Model (DOM) is a programming interface that represents an HTML document as objects.

JavaScript can use the DOM to:

Change text
Change styles
Add or remove elements
Handle user actions
Update web pages without reloading

Example HTML:

<h1 id="title">Welcome</h1>

JavaScript can access this element and change it.

1. getElementById()

This selector finds an element using its id.

Syntax

document.getElementById("idName");

Example

<h1 id="title">Hello World</h1>

<script>
let heading = document.getElementById("title");

heading.innerText = "Welcome to JavaScript";
</script>

Output

Before:

Hello World

After:

Welcome to JavaScript

When to use

Use this method when an element has a unique ID.

2. getElementsByClassName()

This selector finds all elements with the same class name.

Syntax

document.getElementsByClassName("className");

Example

<p class="text">Apple</p>
<p class="text">Banana</p>
<p class="text">Orange</p>

<script>
let items = document.getElementsByClassName("text");

items[0].style.color = "red";
</script>

Important

Returns an HTMLCollection
Multiple elements can have the same class
Access elements using the index

Example:

items[1]
items[2]

3. getElementsByTagName()

This selector finds elements using their HTML tag.

Syntax

document.getElementsByTagName("tagName");

Example

<h2>Heading One</h2>
<h2>Heading Two</h2>

<script>
let headings = document.getElementsByTagName("h2");

headings[1].style.color = "blue";
</script>

Important

Returns an HTMLCollection
Selects every matching tag

4. querySelector()

This selector returns the first matching element.

It can select using:

ID
Class
Tag
CSS Selector

Select by ID

document.querySelector("#title");

Select by Class

document.querySelector(".text");

Select by Tag

document.querySelector("p");

Example

<p class="text">First Paragraph</p>
<p class="text">Second Paragraph</p>

<script>
let para = document.querySelector(".text");

para.style.color = "green";
</script>

Only the first paragraph changes.

5. querySelectorAll()

This selector returns all matching elements.

Syntax

document.querySelectorAll("selector");

Example

<p class="text">Apple</p>
<p class="text">Banana</p>
<p class="text">Orange</p>

<script>
let fruits = document.querySelectorAll(".text");

fruits.forEach(function(item) {
    item.style.color = "purple";
});
</script>

Output

All paragraphs become purple.

Important

Returns a NodeList, which supports methods like forEach().

Difference Between querySelector() and querySelectorAll()

querySelector()	querySelectorAll()
Returns the first matching element	Returns all matching elements
Returns a single element	Returns a NodeList
No index needed	Access elements using an index or `forEach()`

Difference Between HTMLCollection and NodeList

HTMLCollection	NodeList
Returned by `getElementsByClassName()`	Returned by `querySelectorAll()`
Live collection	Static collection
Does not directly support `forEach()`	Supports `forEach()`

Which Selector Should You Use?

Situation	Best Selector
Select by ID	`getElementById()`
Select multiple classes	`getElementsByClassName()`
Select by tag	`getElementsByTagName()`
Select the first matching element	`querySelector()`
Select all matching elements	`querySelectorAll()`

Summary

DOM element selectors help JavaScript find HTML elements and make web pages interactive.

The most commonly used selectors are:

getElementById() – Selects one element by its ID.
getElementsByClassName() – Selects all elements with the same class.
getElementsByTagName() – Selects elements by their HTML tag.
querySelector() – Selects the first matching CSS selector.
querySelectorAll() – Selects all matching CSS selectors.

Python Installation and Versions

Adhi sankar — Wed, 29 Jul 2026 16:47:05 +0000

Python is one of the most popular programming languages in the world. It is easy to learn, beginner-friendly, and widely used in web development, data science, artificial intelligence, automation, and software development. Before writing Python programs, you need to install Python on your computer and understand the different Python versions.

What is Python?

Python is a high-level, interpreted programming language created by Guido van Rossum and first released in 1991. It is known for its simple syntax, readability, and powerful features, making it a great choice for beginners and professionals.

Python Versions

There are two main versions of Python:

Python 2

Released in 2000.
Easy to learn and use.
Official support ended on January 1, 2020.
No longer recommended for new projects.

Python 3

Released in 2008.
Faster, more secure, and more efficient.
Includes many new features and improvements.
Fully supported and regularly updated.
Recommended for all new projects.

Python 2 vs Python 3

Feature	Python 2	Python 3
Support	No longer supported	Fully supported
Print Syntax	`print "Hello"`	`print("Hello")`
Performance	Older version	Improved performance
Libraries	Older libraries	Updated libraries
Recommended	❌ No	✅ Yes

How to Install Python

Follow these simple steps to install Python on your computer:

Open your web browser.
Visit the official Python website: https://www.python.org
Click Downloads.
Download the latest version for your operating system.
Run the installer.
Check the box "Add Python to PATH".
Click Install Now.
Wait until the installation is complete.

Verify the Installation

Open Command Prompt (Windows) or Terminal (Linux/macOS) and type:

python --version

python3 --version

If Python is installed successfully, you will see an output similar to:

Python 3.13.2

Your First Python Program

Create a file named hello.py and write the following code:

print("Hello, World!")

Save the file and run it using:

python hello.py

Output:

Hello, World!

Advantages of Python

Easy to learn and use.
Simple and readable syntax.
Free and open source.
Cross-platform support (Windows, Linux, and macOS).
Large collection of libraries and frameworks.
Used in web development, data science, artificial intelligence, machine learning, automation, and software development.

Conclusion

Python is one of the best programming languages for beginners because of its simplicity and versatility. Python 3 is the latest and recommended version, offering better performance, improved security, and regular updates. After installing Python, you can start writing programs and explore exciting fields such as web development, automation, data science, and artificial intelligence.

Python 2 vs Python 3

Adhi sankar — Mon, 27 Jul 2026 15:54:56 +0000

Introduction

Python is one of the most popular programming languages in the world. It is simple to learn, easy to read, and widely used in web development, data science, artificial intelligence, automation, and software development. Python has two major versions: Python 2 and Python 3. Although both versions are similar, Python 3 includes many improvements and is the version recommended for all new projects.

What is Python 2?

Python 2 was released in 2000. It became very popular because of its simplicity and large collection of libraries. Many old applications were developed using Python 2. However, official support for Python 2 ended in January 2020, so it is no longer updated or maintained.

Features of Python 2

Uses print as a statement.
Uses raw_input() to receive user input.
Integer division returns a whole number.
Limited Unicode support.
No longer receives security updates.

Example

print "Hello, World!"
name = raw_input("Enter your name: ")
print "Welcome", name

What is Python 3?

Python 3 was released in 2008 to improve the language and fix many limitations found in Python 2. Today, Python 3 is the standard version used by developers around the world.

Features of Python 3

Uses print() as a function.
Uses input() for user input.
Supports Unicode by default.
Integer division returns a decimal value when needed.
Better performance and security.
Supports the latest libraries and frameworks.

Example

print("Hello, World!")
name = input("Enter your name: ")
print("Welcome", name)

Python 2 vs Python 3

Feature	Python 2	Python 3
Release Year	2000	2008
Support	Ended in 2020	Actively Supported
Print	`print "Hello"`	`print("Hello")`
Input	`raw_input()`	`input()`
Division	`5/2 = 2`	`5/2 = 2.5`
Unicode	Limited	Full Support
Performance	Older	Improved
Recommended	No	Yes

Advantages of Python 3

Easy to learn and use.
Better security and performance.
Supports modern libraries and frameworks.
Improved error messages.
Used for AI, machine learning, web development, and automation.

Conclusion

Python 2 played an important role in the growth of the Python programming language, but it is no longer supported. Python 3 offers better features, improved performance, and long-term support. If you are learning Python today or starting a new project, Python 3 is the best and recommended choice.

Python – An Easy Programming Language

Adhi sankar — Fri, 24 Jul 2026 15:37:29 +0000

Introduction

Python is one of the most popular programming languages in the world. It is easy to learn and easy to use. Beginners choose Python because its syntax is simple and clear. Python is used to build websites, games, software, and many other applications.

What is Python?

Python is a high-level programming language. It was created by Guido van Rossum in 1991. Python helps programmers write programs with fewer lines of code.

Features of Python

Python is easy to learn.
Python has simple syntax.
Python is free and open source.
Python works on Windows, Linux, and macOS.
Python has many built-in libraries.

Uses of Python

Python is used for:

Web development
Data science
Artificial Intelligence (AI)
Machine Learning
Automation
Game development

Advantages of Python

Easy to read and write
Beginner-friendly
Large community support
Less coding compared to other languages
Many job opportunities

Disadvantages of Python

Python is slower than C and C++.
It uses more memory.
It is not the best choice for mobile app development.

Example Program

print("Hello, World!")

Output:

Hello, World!

Conclusion

Python is a simple and powerful programming language. It is a great choice for beginners because it is easy to learn and understand. If you learn Python, you can build many types of applications and start a career in software development.

Understanding the `forEach()` Method in JavaScript

Adhi sankar — Mon, 20 Jul 2026 12:56:14 +0000

Introduction

The forEach() method is one of the most commonly used array methods in JavaScript. It allows you to iterate through each element of an array and perform a specific action. Unlike traditional for loops, forEach() makes the code cleaner, shorter, and easier to read.

It is mainly used when you want to perform an operation on every element of an array without creating a new array.

What is the `forEach()` Method?

The forEach() method executes a callback function once for each element in an array.

In simple words:

forEach() loops through every element of an array and executes a function for each item.

Syntax

array.forEach(function(element, index, array) {
    // Code to execute
});

Parameters

element – The current element being processed.
index (optional) – The index of the current element.
array (optional) – The array being traversed.

Example 1: Print Array Elements

const fruits = ["Apple", "Banana", "Orange"];

fruits.forEach(function(fruit) {
    console.log(fruit);
});

Output

Apple
Banana
Orange

Explanation

forEach() visits each element one by one.
The callback function receives the current fruit.
console.log() prints each fruit.

Example 2: Using Index

const colors = ["Red", "Green", "Blue"];

colors.forEach(function(color, index) {
    console.log(index + " : " + color);
});

Output

0 : Red
1 : Green
2 : Blue

Example 3: Using Arrow Function

const numbers = [10, 20, 30];

numbers.forEach(number => {
    console.log(number);
});

Output

10
20
30

Arrow functions make the code shorter and easier to read.

Real-Life Example

Imagine a teacher has a list of students.

Rahul
Priya
Arun
Sneha

The teacher calls each student's name one by one.

Similarly, forEach() goes through every element in an array and performs the same action for each item.

Where is `forEach()` Used?

The forEach() method is commonly used for:

Displaying data
Printing array values
Updating HTML elements
Performing calculations
Processing API response data

Difference Between `forEach()` and `map()`

`forEach()`	`map()`
Executes a function for each element	Creates and returns a new array
Does not return a new array	Returns a new array
Used for performing actions	Used for transforming data

Example

const nums = [1, 2, 3];

nums.forEach(num => console.log(num * 2));

Output:

2
4
6

const doubled = nums.map(num => num * 2);

console.log(doubled);

Output:

[2, 4, 6]

Advantages

Easy to understand and use.
Makes code cleaner than a traditional for loop.
Automatically iterates through all elements.
Reduces the chances of loop-related errors.
Works well with callback functions.

Limitations

Cannot use break or continue to stop the loop.
Does not return a new array.
Not suitable when you need to transform array data (use map() instead).

Conclusion

The forEach() method is a simple and powerful way to iterate through arrays in JavaScript. It executes a callback function for every element in the array, making the code more readable and maintainable. It is best used when you want to perform an action on each array element without creating a new array.

DEV Community: Adhi sankar

PostgreSQL: A Beginner's Guide to Getting Started

What is PostgreSQL?

DBMS vs RDBMS

Creating a Database

Creating a Table

Inserting Data

Reading Data

Filtering Data

Updating Data

Deleting Data

Altering a Table

Sorting Data

Aggregate Functions

Count

Average

Maximum

Minimum

Sum

Important PostgreSQL Topics to Learn

Conclusion

Understanding Python `range()` with Real-Life Examples

What is range()?

Syntax

Example 1: Assigning Roll Numbers

Code

Output

Explanation

Example 2: Even Queue Positions

Code

Output

Explanation

Example 3: Lift Stops Every Third Floor

Code

Output

Explanation

Example 4: Rocket Countdown

Code

Output

Explanation

Understanding the Three Parameters

Why Use range()?

Final Thoughts

APIs in JavaScript: A Beginner's Guide

What is an API?

How Does an API Work?

What is Fetch API?

Understanding the Code

Step 1: Send a Request

Step 2: Convert the Response into JSON

Step 3: Use the Data

Step 4: Handle Errors

Complete Example

HTML

JavaScript

Common HTTP Methods

Checking the Response Status

Advantages of Fetch API

Best Practices

Real-World Uses of APIs in JavaScript

Conclusion

Python Modules Explained: Write Cleaner and Reusable Code

What is a Python Module?

Why Use Modules?

Built-in Modules

math

random

datetime

Creating Your Own Module

Different Ways to Import Modules

1. Import the entire module

2. Import specific functions

3. Import with an alias

The dir() Function

Module Search Path

Best Practices

Advantages of Modules

Conclusion

Build a Simple To-Do List Using JavaScript (Step-by-Step)

Selecting HTML Elements

What is `range()`?

Why Use `range()`?

`input.value`

`trim()`

Why use `return`?

What is `addEventListener()`?

Why Use the `"change"` Event?

`checkbox.checked`

The `!` (Logical NOT) Operator

`button.disabled`

JavaScript - Method 2 (Using `if...else`)

Difference Between `print()` and `return`

Using `print()`

Using `return`

Arbitrary Arguments (`*args`)

Arbitrary Keyword Arguments (`**kwargs`)