DEV Community: Adhi sankar

Prime Number Program Using Function in Python

Adhi sankar — Wed, 26 Aug 2026 16:08:36 +0000

A prime number is a number greater than 1 that has only two factors: 1 and itself.

Examples of prime numbers are 2, 3, 5, 7, 11, 13, 17, and 19.

In Python, we can use a function to check whether a number is prime.

Python Program

def is_prime(n):
    if n < 2:
        return False

    for i in range(2, n):
        if n % i == 0:
            return False

    return True


number = int(input("Enter a number: "))

if is_prime(number):
    print(number, "is a prime number")
else:
    print(number, "is not a prime number")

How It Works

1. Create a function

def is_prime(n):

The function is_prime() receives a number n.

2. Check numbers less than 2

if n < 2:
    return False

Numbers like 0 and 1 are not prime numbers.

3. Check for factors

for i in range(2, n):

The loop checks numbers from 2 up to n-1.

4. Use the modulo operator

if n % i == 0:
    return False

If n is exactly divisible by any number other than 1 and itself, it is not prime.

5. Return True

return True

If no factor is found, the number is prime.

Example Output

Enter a number: 17
17 is a prime number

Another example:

Enter a number: 20
20 is not a prime number

Conclusion

Using a function makes the prime number program simple, reusable, and easy to understand. The same is_prime() function can also be used when checking many numbers in a program.

How to Check a Palindrome in Python

Adhi sankar — Sun, 23 Aug 2026 08:20:52 +0000

A palindrome is a word, number, or sentence that reads the same forward and backward.

For example:

madam → madam
level → level
121 → 121
racecar → racecar

In this blog, we will learn how to check whether a word is a palindrome using Python.

Python Program

word = input("Enter a word: ")

reverse = word[::-1]

if word == reverse:
    print("It is a palindrome")
else:
    print("It is not a palindrome")

How Does the Program Work?

1. Get input from the user

word = input("Enter a word: ")

This asks the user to enter a word.

For example:

Enter a word: madam

2. Reverse the word

reverse = word[::-1]

[::-1] is used to reverse a string.

For example:

madam → madam
hello → olleh

3. Compare the original and reversed words

if word == reverse:

The program checks whether the original word and reversed word are the same.

If they are the same, it is a palindrome.

4. Print the result

print("It is a palindrome")

If the word is a palindrome, the program prints:

It is a palindrome

Otherwise:

It is not a palindrome

Example

Input

Enter a word: level

Output

It is a palindrome

Another example:

Input

Enter a word: python

Output

It is not a palindrome

Conclusion

Checking a palindrome is a simple and useful Python exercise. It helps beginners understand:

Strings
User input
String slicing
if-else conditions
Comparing values

How to Find Prime Numbers Using Python

Adhi sankar — Sun, 23 Aug 2026 08:18:34 +0000

Prime numbers are an important concept in programming and mathematics. In this blog, we will learn how to check whether a number is prime using a simple Python program.

What is a Prime Number?

A prime number is a number that has only two factors:

1
The number itself

For example:

2, 3, 5, 7, 11, 13, 17, 19

are prime numbers.

But 4 is not prime because it can be divided by 1, 2, and 4.

Python Program

def prime(n):
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

for n in range(10, 21):
    if prime(n):
        print(n)

How Does the Program Work?

1. Create a function

def prime(n):

This creates a function called prime() that takes a number n.

2. Check numbers from 2

for i in range(2, n):

The loop checks numbers starting from 2 up to n - 1.

3. Check divisibility

if n % i == 0:

The % operator gives the remainder.

If the remainder is 0, the number can be divided exactly by i.

So, the number is not prime.

4. Return False

return False

If a divisor is found, the function returns False.

5. Return True

return True

If no divisor is found, the number is prime, so the function returns True.

6. Check numbers from 10 to 20

for n in range(10, 21):

This checks every number from 10 to 20.

7. Print prime numbers

if prime(n):
    print(n)

If the number is prime, it will be printed.

Output

Conclusion

Finding prime numbers is a good beginner programming exercise. It helps us understand:

Functions
for loops
if conditions
The % operator
return statements

Finding Bugs in Software Testing: A Beginner's Guide

Adhi sankar — Wed, 19 Aug 2026 06:53:21 +0000

What Is a Bug in Software Testing?

When we use an application, we expect everything to work correctly. But sometimes, the application behaves differently from what we expect.

This problem is called a bug.

What is a Bug?

A bug is an error or defect in software that causes the application to produce an incorrect or unexpected result.

Simple Example

Imagine a login page:

Username: adhi
Password: 12345

You enter the correct username and password, but the application says "Invalid Password".

This is a bug because the application is not working as expected.

How Do Testers Find Bugs?

Software testers check an application by trying different scenarios.

For example:

Enter valid username and password.
Enter an incorrect password.
Leave the username empty.
Leave the password empty.
Enter special characters.
Try very long input.

If the application behaves incorrectly in any of these cases, the tester can report it as a bug.

Basic Bug Life Cycle

A bug usually goes through these stages:

New → Assigned → Open → Fixed → Retest → Closed

Sometimes, a bug can also be Reopened if the problem still exists after the developer fixes it.

Why Are Bugs Important?

Finding bugs early helps to:

Improve software quality
Provide a better user experience
Reduce development costs
Prevent serious problems after release

Conclusion

Bugs are a normal part of software development. The job of a tester is to find these problems, report them clearly, and make sure they are fixed.

How to Find Even Numbers in Python

Adhi sankar — Tue, 18 Aug 2026 00:40:15 +0000

If you're learning Python, finding even numbers is a simple and useful beginner exercise.

An even number is a number that can be divided by 2 without any remainder.

For example:

2, 4, 6, 8, 10

Using the `%` Operator

In Python, we can use the modulus (%) operator to check whether a number is even.

num = 10

if num % 2 == 0:
    print("Even number")
else:
    print("Odd number")

How does it work?

num % 2 gives the remainder after dividing the number by 2.

Remainder 0 → Even number
Remainder 1 → Odd number

For example:

10 % 2 = 0
7 % 2 = 1

Finding Even Numbers from a List

We can also find even numbers from a list using a for loop.

numbers = [1, 2, 3, 4, 5, 6, 7, 8]

for num in numbers:
    if num % 2 == 0:
        print(num)

Output

Conclusion

Finding even numbers is a simple Python problem, but it helps beginners understand important concepts like:

% operator
if-else
for loops
Lists

These basic concepts are useful for solving many programming problems.

Software Testing for Beginners: A Simple Guide to Getting Started

Adhi sankar — Tue, 18 Aug 2026 00:38:08 +0000

What Is Software Testing? 🧪

Software testing is the process of checking software to make sure it works correctly and does what it is supposed to do.

For example, when we use a login page, we can test:

Correct username and password
Wrong password
Empty username
Empty password
Forgot password option

The goal is to find bugs and problems before the software is used by customers.

Why Is Testing Important?

Testing helps developers and companies:

Find bugs
Improve software quality
Provide a better user experience
Prevent problems after release

Even a small bug can sometimes cause a big problem, so testing is an important part of software development.

Manual Testing

In manual testing, a tester checks the application manually without using automation scripts.

For example, a tester can open a website, enter different inputs, click buttons, and check whether the expected result appears.

Automation Testing

In automation testing, we use tools and programming to test software automatically.

Some popular tools are:

Selenium
Playwright
Cypress

Automation is useful when the same tests need to be performed many times.

Conclusion

Software testing is an important part of creating reliable software.

If you are a beginner, you can start with manual testing, then learn SQL, API testing, and automation testing.

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.

DEV Community: Adhi sankar

Prime Number Program Using Function in Python

Python Program

How It Works

1. Create a function

2. Check numbers less than 2

3. Check for factors

4. Use the modulo operator

5. Return True

Example Output

Conclusion

How to Check a Palindrome in Python

Python Program

How Does the Program Work?

1. Get input from the user

2. Reverse the word

3. Compare the original and reversed words

4. Print the result

Example

Input

Output

Input

Output

Conclusion

How to Find Prime Numbers Using Python

What is a Prime Number?

Python Program

How Does the Program Work?

1. Create a function

2. Check numbers from 2

3. Check divisibility

4. Return False

5. Return True

6. Check numbers from 10 to 20

7. Print prime numbers

Output

Conclusion

Finding Bugs in Software Testing: A Beginner's Guide

What Is a Bug in Software Testing?

What is a Bug?

Simple Example

How Do Testers Find Bugs?

Basic Bug Life Cycle

Why Are Bugs Important?

Conclusion

How to Find Even Numbers in Python

Using the % Operator

How does it work?

Finding Even Numbers from a List

Output

Conclusion

Software Testing for Beginners: A Simple Guide to Getting Started

What Is Software Testing? 🧪

Why Is Testing Important?

Manual Testing

Automation Testing

Conclusion

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

Using the `%` Operator

What is `range()`?

Why Use `range()`?

`input.value`

`trim()`

Why use `return`?