Forem: PONVEL M

Understanding SDLC (Software Development Life Cycle)

PONVEL M — Sat, 18 Apr 2026 04:11:54 +0000

Introduction

Software Development Life Cycle (SDLC) is a structured process used by developers to design, develop, test, and deploy software efficiently. It helps in delivering high-quality software within a planned time and budget.

In simple terms, SDLC is a step-by-step process followed to build a software application from start to end.

🔄 Phases of SDLC

SDLC consists of several important phases:

Planning

In this phase, the team identifies the project goals and requirements.
They analyze what the client needs and create a project plan.

Example: Deciding to build a construction management app.

Requirement Analysis

All requirements are collected and documented clearly.

Example:

User login
Dashboard
Report generation

Design

The system design is created, including:

UI/UX design
Database design
Architecture

This phase acts as a blueprint for development.

Development (Coding)

Developers start writing code based on the design.

Technologies used:

HTML, CSS, JavaScript
React, Java, Python, etc.

Testing

The application is tested to find bugs and errors.

Types of testing:

Unit Testing
Integration Testing
System Testing

Deployment

The software is released to users.

Example:
Uploading the website or app to a server.

Maintenance

After deployment, the software is maintained and updated.

Fix bugs, improve features, and ensure smooth performance.

Why SDLC is Important?

Improves software quality
Reduces development cost
Ensures proper planning
Helps in delivering on time

Popular SDLC Models

Some commonly used SDLC models:

Waterfall Model
Agile Model
Spiral Model
V-Model

Agile is widely used in modern development.

Conclusion

SDLC plays a crucial role in software development. It provides a clear structure and ensures that the final product meets user requirements effectively. By following SDLC, developers can build reliable and high-quality software systems.

Understanding Collections, ArrayList, Wrapper Classes & Memory Storage in Java

PONVEL M — Sat, 18 Apr 2026 04:11:12 +0000

Introduction

Java provides powerful tools to store and manage data efficiently. Among them, Collections, ArrayList, and Wrapper Classes play a very important role in real-world applications.

In this blog, we will understand:

What is Collection in Java
What is ArrayList
What are Wrapper Classes
How Integer and Wrapper objects are stored in Java memory

What is Collection in Java?

The Collection Framework in Java is a set of classes and interfaces used to store and manipulate groups of objects.

It provides:

Dynamic data storage
Built-in methods (add, remove, search)
Better performance and flexibility

Some common collection types:

List (ArrayList, LinkedList)
Set (HashSet)
Map (HashMap)

What is ArrayList?

ArrayList is a class in Java that implements the List interface.

Key Features:

Dynamic size (can grow and shrink)
Maintains insertion order
Allows duplicate elements

Example:

import java.util.*;

ArrayList<Integer> list = new ArrayList<>();
list.add(10);
list.add(20);
list.add(30);

Unlike arrays, ArrayList does not have a fixed size.

What is a Wrapper Class?

Java provides wrapper classes to convert primitive data types into objects.

Example:

int → Integer
char → Character
double → Double

Example:

int a = 10;
Integer obj = a; // Autoboxing

Why Wrapper Classes?

Collections can store only objects
So primitive types must be converted into objects

Autoboxing and Unboxing

Autoboxing → primitive to object
Unboxing → object to primitive

Integer obj = 10;  // Autoboxing
int num = obj;     // Unboxing

How Data is Stored in Java Memory?

Java mainly uses two types of memory:

1. Stack Memory

Stores primitive variables
Stores reference variables
Fast access

Example:

int a = 10;

a is stored in stack

🔹 2. Heap Memory

Stores objects and instances
Managed by JVM

Example:

Integer obj = new Integer(10);

Object is stored in heap, reference is in stack

Integer & Wrapper Storage in Memory

Case 1: Primitive int

int a = 10;

Value 10 stored directly in stack memory

Case 2: Wrapper Integer

Integer obj = 10;

What happens:

Object created in heap memory
Reference stored in stack memory

Case 3: ArrayList Storage

ArrayList<Integer> list = new ArrayList<>();
list.add(10);

Internally:

ArrayList object → stored in heap
Integer objects → stored in heap
Reference → stored in stack

Key Difference

Type	Stored In
int (primitive)	Stack
Integer (object)	Heap
ArrayList	Heap

Why This is Important?

Understanding memory helps in:

Writing efficient code
Avoiding memory issues
Improving performance

Gmail Validation in Python and Java (Without Using Predefined Methods)

PONVEL M — Sat, 18 Apr 2026 04:10:55 +0000

Introduction

Validating user input is an important concept in programming, especially for login and registration systems. One common task is checking whether an email (Gmail) is valid.

In this blog, we will learn how to validate a Gmail address using:

Python
Java

And the important part: without using advanced predefined methods like regex

Problem Statement

We need to check:

Only valid characters are used
Email ends with @gmail.com

Python Implementation

```python id="8y2b2a"
def verify_Gmail(Gmail):
i = 0
while i < len(Gmail):
current = Gmail[i]
i += 1

    if current >= "a" and current <= "z":
        continue
    elif current >= "A" and current <= "Z":
        continue
    elif current >= "0" and current <= "9":
        continue
    elif current == "@" or current == "." or current == "_":
        continue
    else:
        return False

if Gmail[-10:] == "@gmail.com":
    return True
else:
    return False

if verify_Gmail(input("Enter Your Gmail :")):
print("valid")
else:
print("invalid")




---

##  Java Implementation



```java id="0m5x2r"
import java.util.*;

public class GmailValidation {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter Your Gmail: ");
        String Gmail = sc.nextLine();

        if (verifyGmail(Gmail)) {
            System.out.println("valid");
        } else {
            System.out.println("invalid");
        }

        sc.close();
    }

    public static boolean verifyGmail(String Gmail) {

        // Check each character
        for (int i = 0; i < Gmail.length(); i++) {
            char current = Gmail.charAt(i);

            if (current >= 'a' && current <= 'z') {
                continue;
            } else if (current >= 'A' && current <= 'Z') {
                continue;
            } else if (current >= '0' && current <= '9') {
                continue;
            } else if (current == '@' || current == '.' || current == '_') {
                continue;
            } else {
                return false;
            }
        }

        // Check ending "@gmail.com"
        if (Gmail.length() >= 10) {
            String lastPart = Gmail.substring(Gmail.length() - 10);
            if (lastPart.equals("@gmail.com")) {
                return true;
            }
        }

        return false;
    }
}

Logic Explanation

Step 1: Loop through each character

We check every character using:

Python → while loop
Java → for loop

Step 2: Validate allowed characters

Allowed:

Alphabets (a–z, A–Z)
Numbers (0–9)
Special characters: @, ., _

If any other character appears → invalid

Step 3: Check Gmail domain

We ensure the email ends with:

```text id="bh84jm"
@gmail.com




---

##  Valid Examples

* `ponvel123@gmail.com`
* `user_name@gmail.com`

---

##  Invalid Examples

* `ponvel@gmail` 
* `ponvel#@gmail.com` 
* `user@gmail.org` 

---

##  Limitations

* Does not check multiple `@` symbols
* Does not fully validate email format
* Basic validation only

Pincode Validation in Python (Without Using String Methods)

PONVEL M — Sat, 18 Apr 2026 04:10:39 +0000

Introduction

In India, a pincode (Postal Index Number) is a 6-digit number used to identify a specific geographic location for postal services. Validating a pincode is a common task in programming, especially in forms and data processing applications.

In this blog, we will learn how to validate a pincode using Python, without using any string methods. This approach helps us understand how numbers can be processed using basic logic and loops.

Objective

The goal of this program is to:

Accept a pincode as input from the user
Count the number of digits in the pincode
Check whether it is a valid 6-digit number
Print "YES" if valid, otherwise print "NO"

Logic Behind the Program

Instead of converting the number into a string, we use a mathematical approach:

Store the input number in a variable
Use a temporary variable to avoid modifying the original value
Use a while loop to remove digits one by one
Count how many times the loop runs (this gives the number of digits)
Finally, check:

If the digit count is exactly 6
If the number lies between 100000 and 999999

Python Implementation

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

count = 0
temp = pincode

while temp > 0:
    temp = temp // 10
    count += 1

if count == 6 and pincode >= 100000 and pincode <= 999999:
    print("YES")
else:
    print("NO")

Sample Output

Example 1:

Enter a pincode: 600001
YES

Example 2:

Enter a pincode: 1234
NO

Limitations

While this approach is useful for learning, it has some limitations:

It does not support pincodes with leading zeros
It only works with numeric input (integers)
It cannot handle formatted input like spaces or special characters

Conclusion

In this blog, we explored how to validate a pincode using basic Python concepts like loops and arithmetic operations, without relying on string methods.

This method strengthens our understanding of:

Number manipulation
Loop execution
Logical validation

However, in real-world applications, developers often prefer using strings for easier and more flexible validation.

Understanding SDLC Models: Waterfall, V-Model, and Agile

PONVEL M — Fri, 17 Apr 2026 07:07:54 +0000

Introduction

In software development, following a structured process is very important to build high-quality applications. This process is called the Software Development Life Cycle (SDLC). There are different models in SDLC that guide how a project should be developed.

In this blog, we will explore three important SDLC models:

Waterfall Model
V-Model
Agile Model

🌊 Waterfall Model

🔹 What is Waterfall Model?

The Waterfall Model is a linear and sequential approach where each phase is completed before moving to the next phase.

🔹 Phases of Waterfall Model:

Requirement Gathering
Design
Development
Testing
Deployment
Maintenance

🔹 Advantages:

Easy to understand and manage
Clear structure and documentation
Suitable for small projects

🔹 Disadvantages:

Not flexible for changes
Testing happens at the end
Difficult to fix errors later

🎯 Example:

This model is used in projects where requirements are fixed, such as government or banking systems.

🔺 V-Model (Verification and Validation)

🔹 What is V-Model?

The V-Model is an extension of the Waterfall Model where testing is performed parallel to development.

🔹 Structure:

Left side → Development phases
Right side → Testing phases

🔹 Mapping:

Requirement → Acceptance Testing
Design → System Testing
Architecture → Integration Testing
Coding → Unit Testing

🔹 Advantages:

Early detection of bugs
Better quality assurance
Clear process

🔹 Disadvantages:

Rigid structure
Not suitable for changing requirements

🎯 Example:

Used in critical systems like healthcare and banking where accuracy is very important.

🔄 Agile Model

🔹 What is Agile Model?

The Agile Model is a flexible and iterative approach where development is done in small cycles called sprints.

🔹 How Agile Works:

Planning
Development
Testing
Feedback
Repeat (Sprint cycle)

🔹 Advantages:

Highly flexible
Fast delivery
Continuous customer feedback

🔹 Disadvantages:

Less documentation
Requires experienced team
Scope may change frequently

🎯 Example:

Widely used in modern applications like web apps and mobile apps.

🔥 Comparison of SDLC Models

Feature	Waterfall	V-Model	Agile
Type	Linear	Structured	Iterative
Flexibility	Low	Low	High
Testing	Late	Early	Continuous
Changes	Difficult	Difficult	Easy
Usage	Fixed projects	Critical systems	Modern apps

🎯 Conclusion

Each SDLC model has its own advantages and disadvantages. The Waterfall Model is simple and structured, the V-Model improves quality with early testing, and Agile provides flexibility and faster delivery.

In today’s software industry, Agile is the most widely used model due to its adaptability and continuous feedback process.

✍️ My Learning Experience

While learning about SDLC models, I understood that software development is not just about coding. Planning, testing, and user feedback are equally important. Among all models, Agile impressed me the most because of its flexibility and real-time improvements.

✨ Thank you for reading!

Printing Characters and Their ASCII Values (Java, Python, JavaScript)

PONVEL M — Wed, 08 Apr 2026 17:44:57 +0000

Introduction

In programming, every character has a numeric value called an ASCII value.

ASCII stands for American Standard Code for Information Interchange

It is used to represent characters like letters, numbers, and symbols in computers.

What is ASCII Value?

Each character is mapped to a number.

Examples:

'A' → 65
'a' → 97
'0' → 48
'@' → 64

Problem Statement

Given a string:

ponvelm2@gmail.com

Print each character along with its ASCII value.

Logic Explanation

We need to:

Traverse the string (loop)
Take each character
Convert it to ASCII value
Print the result

Java Solution

public class Main {
    public static void main(String[] args) {
        String str = "ponvelm2@gmail.com";

        for (int i = 0; i < str.length(); i++) {
            char ch = str.charAt(i);
            int ascii = (int) ch;

            System.out.println(ch + " -> " + ascii);
        }
    }
}

Python Solution

str = "ponvelm2@gmail.com"

for ch in str:
    print(ch, "->", ord(ch))

JavaScript Solution

let str = "ponvelm2@gmail.com";

for (let i = 0; i < str.length; i++) {
  let ch = str[i];
  console.log(ch + " -> " + ch.charCodeAt(0));
}

Sample Output

p -> 112
o -> 111
n -> 110
v -> 118
e -> 101
l -> 108
m -> 109
2 -> 50
@ -> 64
g -> 103
m -> 109
a -> 97
i -> 105
l -> 108
. -> 46
c -> 99
o -> 111
m -> 109

Real-World Use Cases

This concept is useful in:

Data encoding
Encryption basics
Input validation
String manipulation problems
Competitive programming

Common Mistakes

Forgetting to loop through the string
Not converting character properly
Using wrong method (ord, charCodeAt, etc.)

Interview Tips

This is a basic but important question.
Interviewers may extend it to:

Count vowels and consonants
Remove special characters
Reverse a string
Find duplicate characters

Conclusion

Understanding ASCII values helps in building strong fundamentals in programming.

By practicing simple problems like this, you can improve your logic and problem-solving skills.

Understanding Constructors in Programming (Java, Python, JavaScript)

PONVEL M — Wed, 08 Apr 2026 17:44:35 +0000

What is a Constructor?

A constructor is a special method that is automatically called when an object is created.

In simple words:
A constructor helps to initialize values when we create an object.

Why are Constructors Important?

Constructors help us to:

Initialize object data easily
Reduce repetitive code
Make programs clean and readable
Automatically assign values during object creation

Real-Time Example: Food Ordering App

Think about a food ordering app like Swiggy or Zomato.

When a user places an order, we need to store:

Item name
Price

Instead of setting values manually every time, a constructor does it automatically when the order is created.

Constructor in Java

Default Constructor

class Order {
    String item;

    Order() {
        item = "Burger";
    }
}

public class Main {
    public static void main(String[] args) {
        Order o1 = new Order();
        System.out.println(o1.item);
    }
}

Output:

Burger

Parameterized Constructor

class Order {
    String item;
    int price;

    Order(String i, int p) {
        item = i;
        price = p;
    }
}

public class Main {
    public static void main(String[] args) {
        Order o1 = new Order("Pizza", 299);
        System.out.println(o1.item + " " + o1.price);
    }
}

Output:

Pizza 299

Key Points (Java)

Constructor name must be same as class name
No return type
Automatically called when object is created

Constructor in Python

In Python, constructors are defined using __init__ method.

class Order:
    def __init__(self, item, price):
        self.item = item
        self.price = price

o1 = Order("Pizza", 299)
print(o1.item, o1.price)

Output:

Pizza 299

Key Points (Python)

Constructor is always __init__
self refers to the current object
Automatically runs when object is created

Constructor in JavaScript

In JavaScript, constructors are defined inside a class using constructor().

class Order {
  constructor(item, price) {
    this.item = item;
    this.price = price;
  }
}

const o1 = new Order("Pizza", 299);
console.log(o1.item, o1.price);

Output:

Pizza 299

Key Points (JavaScript)

Use constructor() method
Use this keyword to assign values
Object is created using new

Types of Constructors

Default Constructor

No parameters
Assigns default values

Parameterized Constructor

Takes input values
Used for dynamic data

Common Mistakes

Forgetting to use new keyword (JavaScript)
Writing wrong constructor name (Java)
Not using this or self
Missing parameters

When Should You Use Constructors?

When creating objects with initial values
When working with real-world applications
When you want clean and reusable code

Real-World Usage

Constructors are used in:

Food ordering apps
E-commerce websites
Banking systems
Student management systems

Conclusion

Constructors are one of the most important concepts in programming.

They help you:

Initialize objects easily
Write cleaner code
Build real-world applications efficiently

File Handling in Java (Complete Guide for Beginners)

PONVEL M — Wed, 08 Apr 2026 17:44:12 +0000

File handling in Java is used to create, read, write, update, and delete files.
It is very important for building real-world applications like logging systems, data storage, reports, etc.

What is File Handling?

File handling means working with files stored on your computer.
Java provides built-in classes in the java.io package for this.

Important Classes in Java File Handling

Class	Purpose
File	Create & manage files
FileWriter	Write data to file
FileReader	Read data from file
BufferedWriter	Efficient writing
BufferedReader	Efficient reading
PrintWriter	Formatted writing
Scanner	Read file easily

1. Creating a File

import java.io.File;
import java.io.IOException;

class Main {
    public static void main(String[] args) {
        try {
            File file = new File("test.txt");

            if (file.createNewFile()) {
                System.out.println("File created: " + file.getName());
            } else {
                System.out.println("File already exists");
            }

        } catch (IOException e) {
            System.out.println("Error occurred");
        }
    }
}

2. Writing to a File

Using FileWriter

import java.io.FileWriter;
import java.io.IOException;

class Main {
    public static void main(String[] args) {
        try {
            FileWriter writer = new FileWriter("test.txt");
            writer.write("Hello, this is Java File Handling!");
            writer.close();

            System.out.println("Data written successfully");

        } catch (IOException e) {
            System.out.println("Error writing file");
        }
    }
}

Using BufferedWriter (Faster)

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

class Main {
    public static void main(String[] args) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter("test.txt"));

        bw.write("Buffered writing example");
        bw.newLine();
        bw.write("Second line");

        bw.close();
    }
}

Using PrintWriter (Formatted Output)

import java.io.PrintWriter;

class Main {
    public static void main(String[] args) throws Exception {
        PrintWriter pw = new PrintWriter("test.txt");

        pw.println("Name: Ponvel");
        pw.println("Score: 95");

        pw.close();
    }
}

3. Reading from a File

Using FileReader

import java.io.FileReader;

class Main {
    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("test.txt");
        int i;

        while ((i = fr.read()) != -1) {
            System.out.print((char)i);
        }

        fr.close();
    }
}

Using BufferedReader (Efficient)

import java.io.BufferedReader;
import java.io.FileReader;

class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new FileReader("test.txt"));
        String line;

        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

        br.close();
    }
}

Using Scanner (Simple Way)

import java.io.File;
import java.util.Scanner;

class Main {
    public static void main(String[] args) throws Exception {
        File file = new File("test.txt");
        Scanner sc = new Scanner(file);

        while (sc.hasNextLine()) {
            System.out.println(sc.nextLine());
        }

        sc.close();
    }
}

4. Deleting a File

import java.io.File;

class Main {
    public static void main(String[] args) {
        File file = new File("test.txt");

        if (file.delete()) {
            System.out.println("File deleted successfully");
        } else {
            System.out.println("Failed to delete file");
        }
    }
}

5. File Methods (Must Know)

Method	Description
createNewFile()	Creates a new file
exists()	Checks file exists
delete()	Deletes file
getName()	Returns file name
getAbsolutePath()	Returns full path
length()	Returns file size
canRead()	Check read permission
canWrite()	Check write permission

Example

File file = new File("test.txt");

System.out.println(file.getName());
System.out.println(file.getAbsolutePath());
System.out.println(file.length());
System.out.println(file.canRead());

Exception Handling in File Handling

File operations may throw errors (IOException)

try {
    // file code
} catch (IOException e) {
    System.out.println("Error: " + e.getMessage());
}

Advantages of File Handling

✔ Store data permanently
✔ Useful for logs & reports
✔ Helps in real applications

Disadvantages

Slower than memory
Requires exception handling

Conclusion

File handling is a must-know concept in Java for real-world development.

Create files
Read & write data
Manage file operations

10 Simple Recursion Problems (Java, JavaScript, Python)

PONVEL M — Sat, 04 Apr 2026 04:41:41 +0000

Recursion becomes easy only with practice.
Here are 10 beginner-friendly problems to master recursion.

1. Print Numbers from 1 to N

Python

def printN(n):
    if n == 0:
        return
    printN(n-1)
    print(n)

printN(5)

Java

static void printN(int n){
    if(n == 0) return;
    printN(n-1);
    System.out.println(n);
}

JavaScript

function printN(n){
    if(n === 0) return;
    printN(n-1);
    console.log(n);
}

2. Print Numbers from N to 1

def reverse(n):
    if n == 0:
        return
    print(n)
    reverse(n-1)

static void reverse(int n){
    if(n == 0) return;
    System.out.println(n);
    reverse(n-1);
}

function reverse(n){
    if(n === 0) return;
    console.log(n);
    reverse(n-1);
}

4. Factorial

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

static int fact(int n){
    if(n == 1) return 1;
    return n * fact(n-1);
}

function fact(n){
    if(n === 1) return 1;
    return n * fact(n-1);
}

4. Sum of N Numbers

def sumN(n):
    if n == 0:
        return 0
    return n + sumN(n-1)

static int sumN(int n){
    if(n == 0) return 0;
    return n + sumN(n-1);
}

function sumN(n){
    if(n === 0) return 0;
    return n + sumN(n-1);
}

5. Fibonacci Series

def fib(n):
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)

static int fib(int n){
    if(n <= 1) return n;
    return fib(n-1) + fib(n-2);
}

function fib(n){
    if(n <= 1) return n;
    return fib(n-1) + fib(n-2);
}

6. Reverse a String

def reverseStr(s):
    if s == "":
        return s
    return reverseStr(s[1:]) + s[0]

static String reverseStr(String s){
    if(s.equals("")) return s;
    return reverseStr(s.substring(1)) + s.charAt(0);
}

function reverseStr(s){
    if(s === "") return s;
    return reverseStr(s.slice(1)) + s[0];
}

7. Count Digits

def countDigits(n):
    if n == 0:
        return 0
    return 1 + countDigits(n//10)

static int countDigits(int n){
    if(n == 0) return 0;
    return 1 + countDigits(n/10);
}

function countDigits(n){
    if(n === 0) return 0;
    return 1 + countDigits(Math.floor(n/10));
}

8. Sum of Digits

def sumDigits(n):
    if n == 0:
        return 0
    return n%10 + sumDigits(n//10)

static int sumDigits(int n){
    if(n == 0) return 0;
    return (n%10) + sumDigits(n/10);
}

function sumDigits(n){
    if(n === 0) return 0;
    return (n%10) + sumDigits(Math.floor(n/10));
}

9. Check Palindrome (String)

def isPalindrome(s):
    if len(s) <= 1:
        return True
    return s[0] == s[-1] and isPalindrome(s[1:-1])

static boolean isPalindrome(String s){
    if(s.length() <= 1) return true;
    return s.charAt(0) == s.charAt(s.length()-1)
        && isPalindrome(s.substring(1, s.length()-1));
}

function isPalindrome(s){
    if(s.length <= 1) return true;
    return s[0] === s[s.length-1] &&
           isPalindrome(s.slice(1, -1));
}

10. Power of a Number (xⁿ)

def power(x, n):
    if n == 0:
        return 1
    return x * power(x, n-1)

static int power(int x, int n){
    if(n == 0) return 1;
    return x * power(x, n-1);
}

function power(x, n){
    if(n === 0) return 1;
    return x * power(x, n-1);
}

Difference Between Compile-Time Exception and Runtime Exception (Java)

PONVEL M — Sat, 04 Apr 2026 04:41:25 +0000

Exception handling is an important concept in Java that helps us handle errors smoothly without crashing the program.

In this blog, we will clearly understand:

What is Compile-Time Exception
What is Runtime Exception
Key Differences with examples

What is an Exception?

An exception is an error that occurs during the execution of a program.

It interrupts the normal flow of the program.

1. Compile-Time Exception (Checked Exception)

Definition

Compile-time exceptions are errors that are checked by the compiler before the program runs.

If not handled, the program will not compile.

Examples

IOException
SQLException
FileNotFoundException

Example Code (Java)

import java.io.*;

class Main {
    public static void main(String[] args) throws IOException {
        FileReader file = new FileReader("test.txt"); // may throw exception
        BufferedReader br = new BufferedReader(file);
        System.out.println(br.readLine());
    }
}

If we don’t use throws or try-catch, compilation will fail.

Key Points

✔ Checked at compile time
✔ Must be handled using try-catch or throws
✔ Safer, because errors are caught early

2. Runtime Exception (Unchecked Exception)

Definition

Runtime exceptions occur during program execution.

Compiler does NOT check these errors.

Examples

ArithmeticException
NullPointerException
ArrayIndexOutOfBoundsException

Example Code (Java)

class Main {
    public static void main(String[] args) {
        int a = 10 / 0; // runtime error
        System.out.println(a);
    }
}

This code compiles successfully, but crashes at runtime.

Key Points

✔ Occurs at runtime
✔ Not checked by compiler
✔ Optional to handle

Difference Table

Feature	Compile-Time Exception	Runtime Exception
Checked by	Compiler	JVM at runtime
Handling	Mandatory	Optional
Occurs	Before execution	During execution
Examples	IOException, SQLException	NullPointerException, ArithmeticException
Program Status	Won’t compile	Compiles but crashes

Real-Life Example

Compile-Time Exception
Like missing documents before an exam → You cannot enter

Runtime Exception
Like bike breakdown during travel → Problem happens suddenly

Advantages of Exception Handling

✔ Prevents program crash
✔ Maintains normal flow
✔ Helps debugging
✔ Improves code quality

Important Note

All compile-time exceptions are checked exceptions
All runtime exceptions are unchecked exceptions

Conclusion

Understanding the difference between compile-time and runtime exceptions is very important for writing robust Java programs.

Compile-time exceptions = handled early
Runtime exceptions = handled during execution

Recursion Programs: Sum of Digits, Reverse Number & Digit Printing (Python, Java, JavaScript)

PONVEL M — Sat, 04 Apr 2026 04:41:10 +0000

Recursion is one of the most important concepts in programming. It means a function calls itself to solve smaller parts of a problem.

In this blog, we will understand recursion with three simple and important problems:

Sum of digits of a number
Reverse a number
Print digits of a number

We will implement all these in Python, Java, and JavaScript.

1. Sum of Digits Using Recursion

Problem

Find the sum of digits of a number.

Example:
Input: 1234
Output: 10

Logic

Take last digit → n % 10
Remove last digit → n / 10
Repeat until number becomes 0

Python Code

def sum_digits(n):
    if n == 0:
        return 0
    return n % 10 + sum_digits(n // 10)

print(sum_digits(1234))

Java Code

class Main {
    static int sumDigits(int n){
        if(n == 0) return 0;
        return n % 10 + sumDigits(n / 10);
    }

    public static void main(String[] args){
        System.out.println(sumDigits(1234));
    }
}

JavaScript Code

function sumDigits(n){
    if(n === 0) return 0;
    return n % 10 + sumDigits(Math.floor(n / 10));
}

console.log(sumDigits(1234));

2. Reverse a Number Using Recursion

Problem

Reverse a number using recursion.

Example:
Input: 1234
Output: 4321

Logic

Take last digit
Build reversed number step by step

Python Code

def reverse(n, rev=0):
    if n == 0:
        return rev
    return reverse(n // 10, rev * 10 + n % 10)

print(reverse(1234))

Java Code

class Main {
    static int reverse(int n, int rev){
        if(n == 0) return rev;
        return reverse(n / 10, rev * 10 + n % 10);
    }

    public static void main(String[] args){
        System.out.println(reverse(1234, 0));
    }
}

JavaScript Code

function reverse(n, rev = 0){
    if(n === 0) return rev;
    return reverse(Math.floor(n / 10), rev * 10 + n % 10);
}

console.log(reverse(1234));

3. Print Digits of a Number

Problem

Print each digit of a number.

Example:
Input: 1234

Output:
1
2
3
4

Logic

First go to the last digit using recursion
Print while returning back

Python Code

def print_digits(n):
    if n == 0:
        return
    print_digits(n // 10)
    print(n % 10)

print_digits(1234)

Java Code

class Main {
    static void printDigits(int n){
        if(n == 0) return;
        printDigits(n / 10);
        System.out.println(n % 10);
    }

    public static void main(String[] args){
        printDigits(1234);
    }
}

JavaScript Code

function printDigits(n){
    if(n === 0) return;
    printDigits(Math.floor(n / 10));
    console.log(n % 10);
}

printDigits(1234);

Conclusion

Recursion is a powerful concept that helps us solve problems in a clean and simple way.

✔ Breaks problems into smaller parts
✔ Makes code more readable
✔ Useful for mathematical and logical problems

Final Thought

If you understand these three problems, you can easily solve many recursion-based questions in interviews.

Practice more to master recursion!

Thank you for reading!

Sum of Digits, Reverse Number & Digit Printing

PONVEL M — Sat, 04 Apr 2026 04:40:55 +0000

Using Recursion and Normal Methods (Python, Java, JavaScript)

In programming, we can solve problems in multiple ways. The two common approaches are:

Normal Method (Loops) – using for / while
Recursion – function calling itself

In this blog, we will solve 3 important problems using both approaches:

Sum of digits
Reverse a number
Print digits of a number

1. Sum of Digits

Example

Input: 1234
Output: 10

Normal Method (Loop)

Python

def sum_digits(n):
    total = 0
    while n > 0:
        total += n % 10
        n = n // 10
    return total

print(sum_digits(1234))

Java

class Main {
    public static void main(String[] args){
        int n = 1234, sum = 0;
        while(n > 0){
            sum += n % 10;
            n = n / 10;
        }
        System.out.println(sum);
    }
}

JavaScript

function sumDigits(n){
    let sum = 0;
    while(n > 0){
        sum += n % 10;
        n = Math.floor(n / 10);
    }
    return sum;
}

console.log(sumDigits(1234));

Recursion Method

Python

def sum_digits(n):
    if n == 0:
        return 0
    return n % 10 + sum_digits(n // 10)

print(sum_digits(1234))

Java

class Main {
    static int sumDigits(int n){
        if(n == 0) return 0;
        return n % 10 + sumDigits(n / 10);
    }

    public static void main(String[] args){
        System.out.println(sumDigits(1234));
    }
}

JavaScript

function sumDigits(n){
    if(n === 0) return 0;
    return n % 10 + sumDigits(Math.floor(n / 10));
}

console.log(sumDigits(1234));

🔁 2. Reverse a Number

👉 Example

Input: 1234
Output: 4321

🔁 Normal Method (Loop)

Python

def reverse(n):
    rev = 0
    while n > 0:
        rev = rev * 10 + n % 10
        n = n // 10
    return rev

print(reverse(1234))

Java

class Main {
    public static void main(String[] args){
        int n = 1234, rev = 0;
        while(n > 0){
            rev = rev * 10 + n % 10;
            n = n / 10;
        }
        System.out.println(rev);
    }
}

JavaScript

function reverse(n){
    let rev = 0;
    while(n > 0){
        rev = rev * 10 + n % 10;
        n = Math.floor(n / 10);
    }
    return rev;
}

console.log(reverse(1234));

🔄 Recursion Method

Python

def reverse(n, rev=0):
    if n == 0:
        return rev
    return reverse(n // 10, rev * 10 + n % 10)

print(reverse(1234))

Java

class Main {
    static int reverse(int n, int rev){
        if(n == 0) return rev;
        return reverse(n / 10, rev * 10 + n % 10);
    }

    public static void main(String[] args){
        System.out.println(reverse(1234, 0));
    }
}

JavaScript

function reverse(n, rev = 0){
    if(n === 0) return rev;
    return reverse(Math.floor(n / 10), rev * 10 + n % 10);
}

console.log(reverse(1234));

🔢 3. Print Digits of a Number

👉 Example

Input: 1234

Output:
1
2
3
4

🔁 Normal Method (Loop)

Python

def print_digits(n):
    digits = []
    while n > 0:
        digits.append(n % 10)
        n = n // 10
    for d in reversed(digits):
        print(d)

print_digits(1234)

Java

class Main {
    public static void main(String[] args){
        int n = 1234;
        int[] arr = new int[10];
        int i = 0;

        while(n > 0){
            arr[i++] = n % 10;
            n = n / 10;
        }

        for(int j = i - 1; j >= 0; j--){
            System.out.println(arr[j]);
        }
    }
}

JavaScript

function printDigits(n){
    let arr = [];
    while(n > 0){
        arr.push(n % 10);
        n = Math.floor(n / 10);
    }
    arr.reverse().forEach(d => console.log(d));
}

printDigits(1234);

🔄 Recursion Method

Python

def print_digits(n):
    if n == 0:
        return
    print_digits(n // 10)
    print(n % 10)

print_digits(1234)

Java

class Main {
    static void printDigits(int n){
        if(n == 0) return;
        printDigits(n / 10);
        System.out.println(n % 10);
    }

    public static void main(String[] args){
        printDigits(1234);
    }
}

JavaScript

function printDigits(n){
    if(n === 0) return;
    printDigits(Math.floor(n / 10));
    console.log(n % 10);
}

printDigits(1234);