DEV Community: Kathirvel S

From Java Methods to Method Overloading: A Complete Beginner's Guide to Compile-Time Polymorphism

Kathirvel S — Mon, 01 Jun 2026 16:28:01 +0000

Introduction

When most beginners start learning Java, they spend a lot of time understanding variables, data types, classes, and objects. While these concepts are important, there is another concept that gives life to an object: methods.

Imagine you have a mobile phone.

The phone contains data:

Brand
Model
Storage
Battery Percentage

But simply having data is not enough.

A phone can also perform actions:

Make a call
Send a message
Open an application
Take a picture

In Object-Oriented Programming (OOP), data is represented using variables, while actions are represented using methods.

Without methods, objects would simply hold information. They would not be able to perform any meaningful work.

According to Oracle's Java Documentation, a method is a collection of statements that perform a specific operation. In simple terms, a method is a reusable block of code that performs a particular task.

In this article, we will take a complete journey through:

Objects and non-static variables
Accessing methods through objects
Understanding what methods are
Learning every keyword used in method creation
Return types and the return keyword
Parameters and arguments
Common compile-time errors
Method Overloading
Compile-Time Polymorphism

By the end of this article, you will understand not only how methods work but also why Method Overloading is called Compile-Time Polymorphism.

Let's begin from the very beginning.

Objects Access Non-Static Variables

Before understanding methods, we must understand how objects interact with variables.

Consider the following class:

class Student {

    String name = "Rahul";

}

Here:

String name = "Rahul";

is called an instance variable or non-static variable.

Official Definition

According to Oracle Java Documentation, instance variables belong to an object instance. Every object created from a class gets its own copy of instance variables.

Beginner-Friendly Explanation

Think of a class as a blueprint and an object as the real thing created from that blueprint.

Example:

Class → Student
Object → Rahul, Priya, Arjun

Every student object can have its own name.

To access an instance variable, we need an object.

public class Main {

    public static void main(String[] args) {

        Student s = new Student();

        System.out.println(s.name);

    }

}

Output:

Rahul

Notice:

s.name

This follows the pattern:

object.variable

The object s is being used to access the variable name.

Common Beginner Error

System.out.println(name);

Error:

cannot find symbol

Why?

Because name belongs to the object, not directly to the main method.

Fix:

System.out.println(s.name);

Key takeaway:

Non-static variables are accessed using object.variable.

Objects Can Also Access Methods

Objects do not only access variables.

They can also access methods.

Let's create a simple method.

class Student {

    void study() {

        System.out.println("Student is studying");

    }

}

Create an object:

Student s = new Student();

Call the method:

s.study();

Output:

Student is studying

This follows the pattern:

object.method();

Real-World Analogy

Imagine a TV remote.

When you press a button, an action happens.

Similarly:

s.study();

asks the object to perform the behavior called study().

Methods are often called the behavior of an object.

What Happens If the Method Does Not Exist?

Suppose we write:

Student s = new Student();

s.play();

But inside Student:

class Student {

    void study() {

    }

}

There is no play() method.

Error:

cannot find symbol
symbol: method play()
location: variable s of type Student

Why Does This Error Occur?

Java checks everything before running the program.

The compiler asks:

Does the class exist?
Does the object exist?
Does the method exist?

Since play() cannot be found, compilation fails.

Important Rule:

A method must be declared before it can be called.

What Exactly Is a Method?

Oracle Documentation defines a method as:

A collection of statements grouped together to perform an operation.

Beginner-Friendly Definition

A method is a reusable block of code that performs a specific task.

Examples:

Calculating salary
Printing information
Finding the largest number
Sending an email

Without methods:

System.out.println("Hello");
System.out.println("Hello");
System.out.println("Hello");

With methods:

greet();
greet();
greet();

Methods help achieve:

Reusability
Readability
Maintainability
Modularity

Creating Your First Method

Example:

public void printActivity() {

    System.out.println("Learning Java");

}

This method prints a message.

But what does each keyword mean?

Let's break it down.

Understanding Every Keyword in a Method

public

public

Official Meaning

An access modifier that makes a member accessible from anywhere.

Beginner-Friendly Meaning

Anyone can use this method.

Think of it as an open door.

Example:

public void printActivity()

means:

"This method can be accessed by other classes."

void

void

Official Meaning

The method returns no value.

Beginner-Friendly Meaning

The method performs work but gives nothing back.

Example:

void greet() {

    System.out.println("Hello");

}

It prints something but does not return any value.

printActivity

printActivity

This is the method name.

Java uses the method name to identify which method to execute.

Good method names should describe the action being performed.

Examples:

calculateSalary()
sendEmail()
printActivity()

Bad examples:

abc()
xyz()
doit()

Parentheses ()

()

Used to hold parameters.

Currently:

()

means no parameters.

Curly Braces {}

{
}

The method body.

The actual statements execute inside these braces.

Return Types in Java

Every method must specify what type of value it returns.

Example:

public int getAge() {

    return 25;

}

Here:

int

means the method returns an integer.

Why Does Java Need a Return Type?

Before compilation, Java must know:

"What kind of value will this method send back?"

That's why return types are mandatory.

Error: Missing Return Type

Wrong:

public getAge() {

    return 25;

}

Error:

invalid method declaration; return type required

Why?

Java does not know what type of value will be returned.

Fix:

public int getAge() {

    return 25;

}

Understanding the return Keyword

The keyword:

return

sends a value back to the caller.

Example:

public int getAge() {

    return 25;

}

Usage:

int age = getAge();

System.out.println(age);

Output:

Flow:

Method Call
    ↓
Method Executes
    ↓
return 25
    ↓
Caller Receives 25

Why Do We Use void?

Consider:

void greet() {

    System.out.println("Hello");

}

The method simply performs an action.

Nothing needs to be returned.

Therefore:

void

is used.

Rule:

Do work only → void

Return value → int, String, double, boolean, etc.

Parameters and Arguments

This is one of the most commonly confused topics.

Parameter

void greet(String name)

name is a parameter.

Argument

greet("Rahul");

"Rahul" is an argument.

Simple rule:

Method Definition → Parameters

Method Call → Arguments

Think of parameters as placeholders and arguments as actual values.

No-Argument Method

Method:

void greet() {

    System.out.println("Hello");

}

Call:

greet();

Output:

Hello

Error: Passing an Argument to a No-Argument Method

Method:

void greet() {

}

Call:

greet("Rahul");

Error:

method greet cannot be applied to given types

Fix:

void greet(String name)

One-Parameter Method

Method:

void greet(String name) {

    System.out.println("Hello " + name);

}

Call:

greet("Rahul");

Output:

Hello Rahul

Error: Missing Required Argument

Method:

void greet(String name)

Call:

greet();

Error:

method greet cannot be applied to given types

Why?

The method expects one argument but receives none.

Fix:

greet("Rahul");

Two-Parameter Method

Method:

void add(int a, int b) {

    System.out.println(a + b);

}

Call:

add(10, 20);

Output:

Error: Passing One Argument Instead of Two

Call:

add(10);

Error:

method add cannot be applied to given types

Fix:

add(10, 20);

String Parameters

Method:

void display(String name) {

    System.out.println(name);

}

Correct:

display("Java");

Output:

Java

Error: Passing Wrong Data Type

Method:

display(String name);

Call:

display(100);

Error:

incompatible types

Reason:

Method expects:

String

but receives:

int

Fix:

display("100");

Why Method Overloading Exists

Imagine a printing system.

Without overloading:

printInt()
printString()
printDouble()
printTwoNumbers()

Too many method names.

Difficult to remember.

Java provides a cleaner solution.

Method Overloading

Official Definition

Method Overloading is the ability to define multiple methods with the same name but different parameter lists.

Example:

class Printer {

    void print() {
        System.out.println("No Data");
    }

    void print(int num) {
        System.out.println(num);
    }

    void print(String text) {
        System.out.println(text);
    }

    void print(int a, int b) {
        System.out.println(a + b);
    }

}

Calls:

print();

print(10);

print("Java");

print(10, 20);

Output:

No Data
10
Java
30

Notice:

Same method name.

Different parameter lists.

That is Method Overloading.

Rules of Method Overloading

Valid:

print()
print(int)
print(String)
print(int, int)

Invalid:

int print()

String print()

Changing only the return type is not overloading.

The parameter list must be different.

What Is Compile-Time Polymorphism?

The word polymorphism comes from:

Poly = Many

Morph = Forms

Meaning:

One Name
Many Forms

Example:

print()
print(int)
print(String)
print(int, int)

All methods share the same name.

But each has a different form.

Why Is Method Overloading Called Compile-Time Polymorphism?

Consider:

print(10);

During compilation, Java checks:

void print(int num)

For:

print("Java");

Java checks:

void print(String text)

The decision happens before the program runs.

That means the compiler determines which method should execute.

Therefore:

Method Overloading
        ↓
Method Selected During Compilation
        ↓
Compile-Time Polymorphism

It is also called:

Static Polymorphism

because the method resolution happens during compile time rather than runtime.

Final Summary

In this article, we started with the fundamentals of objects and non-static variables. We learned how objects access data using the dot operator and how methods represent the behavior of an object.

We explored what methods are, why they exist, and how they help us write reusable and maintainable code. We broke down every component of a method, including public, void, method names, parentheses, and method bodies.

We then moved into return types and the return keyword, understanding how methods can send values back to the caller. After that, we learned the difference between parameters and arguments and examined common compile-time errors that beginners frequently encounter.

Finally, we reached Method Overloading. Instead of creating many methods with different names, Java allows us to use the same method name for multiple operations by changing the parameter list.

This feature is called Method Overloading, and because Java determines the correct method during compilation, it is known as Compile-Time Polymorphism.

The most important takeaway from this entire journey is:

Method Overloading allows one method name to have multiple forms, and Java selects the correct form during compilation. This ability is what makes Method Overloading an example of Compile-Time Polymorphism.

Understanding methods thoroughly is one of the strongest foundations you can build as a Java developer. Almost every Java application—from simple console programs to enterprise-level systems—relies heavily on methods. Mastering them today will make advanced topics such as inheritance, runtime polymorphism, interfaces, and design patterns much easier to understand in the future.

Happy Coding!

References

Oracle Java Tutorials – Methods
https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html
Oracle Java Tutorials – Objects
https://docs.oracle.com/javase/tutorial/java/javaOO/objects.html
Java Language Specification – Methods
https://docs.oracle.com/javase/specs/
Oracle Java Tutorials – Passing Information to a Method or Constructor
https://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html

How to Find a Prime Number in Python — A Thinking Journey

Kathirvel S — Mon, 01 Jun 2026 03:20:38 +0000

Introduction

Understanding how to find prime numbers is one of the best ways to develop logical thinking in programming. It looks simple on the surface, but it teaches you how to break a problem into smaller steps, build a solution gradually, and then improve it into a clean and reusable structure.

In this blog, we will not jump directly into code. Instead, we will start from basic thinking, slowly convert that thinking into logic, and finally refine it into a proper Python program using functions and loops. The goal is not just to find prime numbers, but to understand how programming logic is actually built in real development.

1. Understanding the Problem First

Before writing anything in Python, we need to understand what a prime number actually means.

A prime number is a number that:

is greater than 1
has exactly two divisors: 1 and itself

So the real question becomes:

How do we check whether a number has any divisors other than 1 and itself?

That is the core problem we are trying to solve.

2. Thinking Like a Human Before Coding

Let’s take a number, for example 13.

To check if 13 is prime, we naturally try dividing it by smaller numbers:

2 → does not divide 13
3 → does not divide 13
4 → does not divide 13
5 → does not divide 13
and so on

If none of these numbers divide 13 completely, then 13 is prime.

So the logic is simple:

Try dividing the number by possible candidates and see if any divide it perfectly.

3. Turning Thinking into a Basic Algorithm

From the above idea, we can form a basic structure:

We need:

a number to test
a variable that moves through possible divisors
a way to detect whether a divisor exists

We start checking from 2 because every number is divisible by 1 anyway.

We also do not need to check beyond half of the number, because a number cannot have a divisor greater than half (except itself).

So the idea becomes:

Start divisor from 2
Go up to number // 2
If any number divides it evenly, it is not prime

4. First Working Logic (Direct Implementation)

Now we translate the idea into Python.

We introduce:

number: the value we are testing
divisor: the number we try dividing with
divisor_count: how many divisors we find

If divisor_count stays zero, the number is prime.

number = 13
divisor = 2
divisor_count = 0

while divisor <= number // 2:
    if number % divisor == 0:
        print("divisor found:", divisor)
        divisor_count += 1
    divisor += 1

if divisor_count == 0:
    print("Prime")
else:
    print("Not Prime")

Flow Chart:

Start
  ↓
Initialize number, divisor = 2, divisor_count = 0
  ↓
Check divisor <= number//2
  ↓
Is number divisible by divisor?
      ↓ Yes → increment divisor_count
      ↓ No  → continue
  ↓
Increase divisor
  ↓
Repeat loop
  ↓
If divisor_count == 0 → Prime
Else → Not Prime
  ↓
End

5. Understanding What Happens Here

This logic works like a manual test:

We are checking every possible divisor one by one.

If even one divisor divides the number completely, we mark it as non-prime.

Otherwise, it is prime.

So effectively:

No divisors found → Prime
At least one divisor found → Not Prime

6. The Problem With This Approach

Although this works, it has a major issue.

If we want to check multiple numbers, we would need to repeat the same logic again and again.

This leads to:

repeated code
harder maintenance
low reusability

So we need a better structure.

7. Introducing Functions in Python

A function is a reusable block of code that performs a specific task.

Instead of rewriting logic every time, we can define it once and reuse it whenever needed.

From the official Python documentation:

A function is a group of statements that performs a specific task.

Reference:
https://docs.python.org/3/tutorial/controlflow.html#defining-functions

8. Simple Example to Understand Functions

Before applying it to primes, let’s understand a simple function idea.

def buy_nonveg():
    return "chicken"

bag = buy_nonveg()
print(bag)

Flow Chart:

Call function buy_nonveg()
  ↓
Execute function body
  ↓
return "chicken"
  ↓
Store result in bag
  ↓
Print bag
  ↓
End

9. Understanding the return Keyword

The return statement is used to send a result back from a function.

From Python documentation:

The return statement exits a function and optionally passes back an expression.

Reference:
https://docs.python.org/3/reference/simple_stmts.html#the-return-statement

In simple terms:

A function processes something
return sends the result back
after return, the function stops executing

You can think of it as:

Input → Processing → Output

return is the output step.

10. Converting Prime Logic into a Function

Now we take our earlier logic and wrap it inside a function so it becomes reusable.

def find_prime(no):
    div = 2
    divisors_count = 0

    while div <= no // 2:
        if no % div == 0:
            divisors_count += 1
        div += 1

    if divisors_count == 0:
        return True
    else:
        return False

Flow Chart:

Start function find_prime(no)
  ↓
Initialize div = 2, divisors_count = 0
  ↓
Check div <= no//2
  ↓
Is no divisible by div?
      ↓ Yes → increment divisors_count
      ↓ No  → continue
  ↓
Increase div
  ↓
Repeat loop
  ↓
If divisors_count == 0
      ↓ Yes → return True
      ↓ No  → return False
  ↓
End function

11. Understanding This Function

This function does the following:

takes a number as input
checks all possible divisors
counts how many divisors exist
returns True if no divisors are found
returns False otherwise

So now instead of writing full logic every time, we simply call this function.

12. Using the Function (But Still Not Efficient)

Now we try to use this function to check multiple numbers.

no = 2

result = find_prime(no)
if result == True:
    print(no)

no += 1
result = find_prime(no)
if result == True:
    print(no)

no += 1
result = find_prime(no)
if result == True:
    print(no)

Flow Chart:

Start
  ↓
Set no = 2
  ↓
Call find_prime(no)
  ↓
If result == True → print no
  ↓
Increase no
  ↓
Repeat manually
  ↓
End

13. The Problem Again

Even though logic is now reusable, usage is still repetitive.

We are still manually:

increasing numbers
calling function again and again

This is not scalable.

So we need another improvement.

14. Using a Loop to Remove Repetition

Instead of repeating the same steps, we can automate the process using a loop.

def find_prime(no):
    div = 2
    divisors_count = 0

    while div <= no // 2:
        if no % div == 0:
            divisors_count += 1
        div += 1

    return divisors_count == 0


no = 2

while no <= 10:
    if find_prime(no):
        print(no)
    no += 1

Flow Chart:

Start
  ↓
Set no = 2
  ↓
Check no <= 10
  ↓
Call find_prime(no)
  ↓
If True → print no
  ↓
Increment no
  ↓
Repeat loop
  ↓
End when no > 10

15. What Changed Here

Now the structure is much cleaner:

Loop handles number progression
Function handles prime checking
Output is handled separately

This separation is important in programming design.

16. Final Improved Version (Cleaner Logic)

We can further improve the function by removing unnecessary counting.

We only need to know whether a divisor exists or not.

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

    div = 2
    while div <= n // 2:
        if n % div == 0:
            return False
        div += 1

    return True

Flow Chart:

Start function is_prime(n)
  ↓
If n < 2 → return False
  ↓
Set div = 2
  ↓
Check div <= n//2
  ↓
If n % div == 0 → return False
  ↓
Increment div
  ↓
Repeat loop
  ↓
If no divisor found → return True
  ↓
End function

And usage becomes:

for num in range(2, 11):
    if is_prime(num):
        print(num)

Flow Chart:

Start
  ↓
Loop num from 2 to 10
  ↓
Call is_prime(num)
  ↓
If True → print num
  ↓
Repeat loop
  ↓
End

17. Final Understanding

At a high level, prime checking is simply:

Try dividing the number
If anything divides it evenly → not prime
If nothing divides it → prime

Everything else in code is just structuring this idea properly.

18. Key Learning Path

What we built step by step:

Manual reasoning
Basic loop logic
First implementation
Identifying repetition problem
Introducing functions
Understanding return
Refactoring into reusable design
Removing redundancy with loops
Final clean implementation

Conclusion

What looks like a simple “prime number program” is actually a complete demonstration of how programming logic evolves in real software development.

We started with raw human thinking, converted it into a working algorithm, noticed its limitations, introduced functions for reusability, and finally optimized it into a clean and scalable solution.

This is exactly how real developers think: not by writing perfect code at once, but by building, observing problems, and improving step by step.

If you understand this flow, you are not just learning prime numbers — you are learning how to think like a programmer.

Static vs Non-Static in Java: Understanding Class and Object Through a Shop Story

Kathirvel S — Sun, 31 May 2026 14:04:36 +0000

Imagine You're Standing Outside a Shop...

Have you ever noticed something interesting when you walk past a shop?

Even before entering, you can see the shop's name board.

"Fresh Mart"

You don't need to enter the shop to know its name. It's visible to everyone from outside.

But what about the products?

Can you see all the products from outside?

No.

To access products, you must enter the shop.

Now let's connect this simple real-world example to Java.

Meet Our Java Shop

Imagine this Java class:

public class Shop {

    static int age = 20;
    static String name = "Fresh Mart";

    String prod_name;
}

Think of it this way:

Shop Story	Java Concept
Shop building	Class
Shop name board	Static variable
Product inside shop	Non-static variable
Entering the shop	Creating an object

What Is a Class?

According to the Java documentation:

A class is a blueprint or template from which objects are created.

In simple words:

A class describes what something should look like.

For example:

public class Shop {
    static String name;
    String prod_name;
}

This does not create an actual shop.

It only describes:

A shop has a name.
A shop can contain products.

Think of it like an architect's building plan.

A plan is not the actual building.

Similarly:

A class is not an object.

It is only the blueprint.

Think of a class as:

Recipe
Template
Blueprint
Design
Instruction Sheet

Why Do We Need Classes?

Imagine a city with 10,000 shops.

Would you write separate code for every shop?

shop1
shop2
shop3
shop4
...

That would be a nightmare.

Instead, we create one blueprint:

class Shop

And then create many shop objects from it.

Benefits:

✅ Reusability

✅ Better organization

✅ Less code duplication

✅ Easier maintenance

What Is an Object?

If a class is the blueprint...

An object is the real thing created from that blueprint.

Example:

Blueprint:

House Design

Actual house:

House #1
House #2
House #3

Similarly:

Class:

Shop

Objects:

Shop s1 = new Shop();

Shop s2 = new Shop();

Now we have two real shop objects.

Each object gets its own storage.

Why Do We Need Objects?

Imagine there are 10,000 shops.

Would we create 10,000 classes?

Shop1
Shop2
Shop3
Shop4
...

❌ Impossible to maintain.

Instead:

class Shop

One class.

Many objects.

Shop s1 = new Shop();

Shop s2 = new Shop();

Shop s3 = new Shop();

Advantages:

✅ Reusable

✅ Organized

✅ Saves code

✅ Models real-world entities

The Most Important Line in Java

Look carefully:

Shop s1 = new Shop();

Most beginners see one line.

Java sees several steps.

Let's break it apart.

Step 1: `Shop`

Shop

This is the class type.

It tells Java:

"The variable I'm about to create will store a Shop object."

Similar to:

int age;
String name;

Here:

Shop s1;

means:

s1 can store a Shop reference.

Step 2: `s1`

Shop s1;

s1 is a reference variable.

Think of it as:

Address Holder
Pointer
Reference
Remote Control

Initially:

s1
 |
 v
null

No object exists yet.

Step 3: `new`

new

This is where the magic happens.

new tells Java:

"Allocate memory and create a brand new object."

Without new:

Shop s1;

No shop is created.

With new:

new Shop();

Java creates a fresh object in memory.

Step 4: `Shop()`

Shop()

This calls the constructor.

Think of it as:

Opening a new shop
Initializing the shop
Preparing the shop

Java creates memory and prepares all variables.

What Happens Internally?

When Java sees:

Shop s1 = new Shop();

Java roughly performs:

Create memory

Memory

+----------------+
| prod_name=null |
+----------------+

Then:

Store address in s1

s1
 |
 |-------> Object
           +----------------+
           | prod_name=null |
           +----------------+

Creating Another Object

Shop s2 = new Shop();

Now Java allocates another memory block.

s1
 |
 v
+----------------+
| prod_name=null |
+----------------+

s2
 |
 v
+----------------+
| prod_name=null |
+----------------+

Notice:

These are two separate objects.

Separate memory.

Separate data.

What Happens After Assignments?

s1.prod_name = "Rice";

s2.prod_name = "Milk";

Memory becomes:

s1
 |
 v
+----------------+
| prod_name=Rice |
+----------------+

s2
 |
 v
+----------------+
| prod_name=Milk |
+----------------+

Each object stores its own value.

Where Does Static Memory Live?

Consider:

public class Shop {

    static String name = "Fresh Mart";

    String prod_name;
}

Many beginners think:

Every object stores name.

Wrong.

Static variables are stored once per class.

Visual Memory Layout

CLASS AREA (Method Area)

Shop Class
+-----------------------+
| name = Fresh Mart     |
+-----------------------+



HEAP MEMORY

Object s1
+-----------------------+
| prod_name = Rice      |
+-----------------------+

Object s2
+-----------------------+
| prod_name = Milk      |
+-----------------------+

Only one copy of:

static String name

exists.

No matter how many objects you create.

Why Static Saves Memory

Imagine:

Shop s1
Shop s2
Shop s3
...
Shop s1000

If name were non-static:

Fresh Mart
Fresh Mart
Fresh Mart
Fresh Mart
...
1000 times

Huge waste.

Instead:

static String name

One copy.

All objects share it.

             Fresh Mart
                 ^
                 |
      -------------------------
      |           |           |
     s1          s2          s3

Static vs Non-Static Memory Diagram

CLASS AREA

+--------------------------------+
| Shop.name = Fresh Mart         |
| Shop.age  = 20                 |
+--------------------------------+



HEAP

s1
 |
 v
+--------------------------------+
| prod_name = Rice               |
+--------------------------------+


s2
 |
 v
+--------------------------------+
| prod_name = Milk               |
+--------------------------------+

What Is Static?

Remember the shop name board?

Everyone can see it without entering the shop.

That's exactly how static members work.

Example:

static String name = "Fresh Mart";

You can access it directly through the class:

System.out.println(Shop.name);

No object required.

Because static belongs to the class itself.

Why Static Exists

Imagine there are 1,000 shop objects.

Should every object store the same shop name?

That wastes memory.

Instead:

static String name = "Fresh Mart";

Only one copy exists.

All objects share it.

Benefits:

✅ Memory efficient

✅ Faster access

✅ Shared information

What Is Non-Static?

Products inside the shop are different.

One shelf contains:

Rice

Another shelf contains:

Milk

Each shop object stores its own products.

Example:

String prod_name;

This is non-static.

Every object gets its own copy.

Access:

product.prod_name

Not:

Shop.prod_name

Because the product belongs to a specific shop object.

Static vs Non-Static

Static	Non-Static
Belongs to class	Belongs to object
One copy exists	Separate copy per object
Access using class name	Access using object
Memory efficient	Stores object-specific data
Created when class loads	Created when object is created

Code to the Story

public class Shop {

    // Visible from outside
    static int age = 20;
    static String name = "Fresh Mart";

    // Inside the shop
    String prod_name;

    public static void main(String[] args) {

        Shop product = new Shop();
        product.prod_name = "First Product";

        Shop product2 = new Shop();
        product2.prod_name = "Second Product";

        System.out.println("=== Looking from outside ===");

        System.out.println("Shop Age: " + Shop.age);
        System.out.println("Shop Name: " + Shop.name);



        System.out.println("=== Entering Shop ===");

        System.out.println(product.prod_name);
        System.out.println(product2.prod_name);
    }
}

Output:

=== Looking from outside ===
Shop Age: 20
Shop Name: Fresh Mart

=== Entering Shop ===
First Product
Second Product

See the difference?

Outside:

Shop.age
Shop.name

Inside:

product.prod_name
product2.prod_name

How to Print Static Variables

Static variables belong to the class.

System.out.println(Shop.age);
System.out.println(Shop.name);

Output:

20
Fresh Mart

How to Print Non-Static Variables

Create an object first.

Shop product = new Shop();

product.prod_name = "Laptop";

System.out.println(product.prod_name);

Output:

Laptop

When Should You Use Static?

Use static when data is shared by all objects.

Examples:

Company Name
Tax Rate
Application Version
Counter
Constants
Utility Methods

Example:

static String company = "ABC Ltd";

Every employee object uses the same company name.

When Should You Use Non-Static?

Use non-static when every object needs its own value.

Examples:

Student Name
Employee Salary
Car Number
Product Name
Account Balance

Example:

String studentName;

Every student has a different name.

Where Are These Memories Stored in JVM?

Think of the JVM as having three important areas.

Stack Memory

Stores:

s1
s2
product
product2

Reference variables live here.

STACK

s1 ------+
s2 ------+

Heap Memory

Stores actual objects.

HEAP

Object 1
Object 2
Object 3

Whenever you write:

new Shop();

Memory is allocated in the Heap.

Method Area (Class Area)

Stores:

Class metadata
Static variables
Static methods

Example:

static String name;
static int age;

These are stored once in the Method Area.

METHOD AREA

Shop.name
Shop.age

Complete JVM Memory Picture

METHOD AREA
+-------------------------+
| Shop.name = Fresh Mart  |
| Shop.age  = 20          |
+-------------------------+


STACK
+-------------------------+
| s1 -> Object1           |
| s2 -> Object2           |
+-------------------------+


HEAP
+-------------------------+
| Object1                 |
| prod_name = Rice        |
+-------------------------+

+-------------------------+
| Object2                 |
| prod_name = Milk        |
+-------------------------+

Now you can actually visualize what happens when Java executes:

Shop s1 = new Shop();

Quick Challenge For You

Before reading the answer, guess the output:

public class Shop {

    static String name = "Fresh Mart";

    String product;

    public static void main(String[] args) {

        Shop s1 = new Shop();
        Shop s2 = new Shop();

        s1.product = "Rice";
        s2.product = "Milk";

        System.out.println(name);

        System.out.println(s1.product);

        System.out.println(s2.product);
    }
}

Think...

Ready?

Output:

Fresh Mart
Rice
Milk

Why?

Because:

name is shared by the class.
product belongs to each object separately.

Final Takeaway

Whenever you're confused between static and non-static, remember the shop story.

Shop Name Board = Static

Everyone can access it without entering.

Products Inside the Shop = Non-Static

You must enter a specific shop object to access them.

And remember:

Class = Blueprint
Object = Real thing created from the blueprint
Static = Shared by everyone
Non-Static = Unique to each object

Whenever you see:

Shop s1 = new Shop();

Read it like this:

Shop      -> Type of object

s1        -> Reference variable

new       -> Allocate new memory

Shop()    -> Create and initialize object

Visualize:

s1
 |
 v
+------------------+
| Shop Object      |
+------------------+

Once you understand this memory picture, static vs non-static stops being something to memorize and becomes something you can actually see happening inside the JVM.

References

Official Java Documentation:

Java Classes and Objects: https://docs.oracle.com/javase/tutorial/java/javaOO/classes.html
Understanding Class Members (Static and Instance): https://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html
The Java Language Specification: https://docs.oracle.com/javase/specs/

Why Data Types Exist in Python: and Building Logic Through Finding Perfect number

Kathirvel S — Sun, 31 May 2026 11:02:07 +0000

Introduction

When we start learning Python, one of the first concepts we hear about is data types. Many beginners ask:

"Why do data types even exist?"

To understand this, let's begin with a simple story.

A Story Behind Data Types

Computers don't understand letters, numbers, images, or sounds directly. Everything inside a computer is stored as binary digits (0s and 1s).

Consider the letter 'A'.

The ASCII value of A is 65.

A = 65

Inside the computer, 65 is stored in binary form:

Now imagine another situation where:

a = 100001

The binary representation of the number 65 and the number 100001 may look similar to the computer at the storage level.

So how does the computer know whether it should treat the value as:

A character ('A')
A number (65)
A string ("65")

This is where data types become important.

Data types tell the computer:

"How should this piece of data be interpreted and processed?"

Without data types, the computer would struggle to distinguish between characters, numbers, text, and other kinds of information.

For example:

char = 'A'
num = 65
text = "65"

Even though they may be related, Python treats them differently because each has a different data type.

Common Data Types in Python

According to the official Python documentation:

"The following sections describe the standard types that are built into the interpreter." (Python documentation)

Python provides several built-in data types that help the interpreter understand how data should be stored and manipulated.

Official Documentation:

Python Built-in Types Documentation

Integer (int)

Used for whole numbers.

age = 20

Float (float)

Used for decimal numbers.

price = 99.99

String (str)

Used for text.

name = "Python"

Boolean (bool)

Used for True or False values.

is_active = True

Problem 1: Sum of Odd and Even Numbers

Before writing code, let's think like a programmer.

Suppose I ask:

What happens when we add an odd number and an even number?

Let's try manually.

3 + 4 = 7

7 is Odd.

Another example:

5 + 8 = 13

13 is Odd.

Again:

9 + 2 = 11

11 is Odd.

After observing multiple examples, we can identify a pattern:

Odd + Even = Odd

Now let's create the logic ourselves.

Building the Logic

Step 1:

Take two numbers.

3 and 4

Step 2:

Add them.

3 + 4 = 7

Step 3:

Check whether the result is divisible by 2.

If a number leaves remainder 1 after division by 2:

Number is Odd

Otherwise:

Number is Even

Flowchart

Start
  |
Take Two Numbers
  |
Add Numbers
  |
Check sum % 2
  |
  +---- remainder != 0 ----> ODD
  |
  +---- remainder == 0 ----> EVEN
  |
 End

Python Code

no1 = 3
no2 = 4

sum = no1 + no2

if sum % 2 != 0:
    print("ODD")
else:
    print("EVEN")

Code Explanation

no1 = 3
no2 = 4

Stores two numbers.

sum = no1 + no2

Adds both numbers and stores the result.

sum % 2

Checks the remainder after dividing by 2.

If the remainder is not zero:

if sum % 2 != 0:

The number is Odd.

Otherwise:

else:

The number is Even.

Output

ODD

Problem 2: Perfect Number

Let's build the logic slowly before coding.

What is a Perfect Number?

A perfect number is a number whose factors (excluding itself) add up exactly to the number.

Let's take:

Find all factors except 6 itself.

1
2
3

Now add them.

1 + 2 + 3 = 6

The sum becomes equal to the original number.

So:

6 is a Perfect Number

Let's try another number.

Factors:

1
2
4

Sum:

1 + 2 + 4 = 7

7 is not equal to 8.

So:

8 is NOT a Perfect Number

Building the Logic

Step 1:

Take a number.

Step 2:

Check all numbers from 1 up to the number before it.

1 2 3 4 5

Step 3:

Find which numbers divide 6 completely.

1 ✓
2 ✓
3 ✓
4 ✗
5 ✗

Step 4:

Add all valid factors.

1 + 2 + 3 = 6

Step 5:

Compare the total with the original number.

6 == 6

Perfect Number.

Flowchart

Start
  |
Take Number
  |
Find Factors
  |
Add Factors
  |
Compare Sum and Number
  |
  +---- Equal ------> Perfect Number
  |
  +---- Not Equal --> Not Perfect Number
  |
 End

Python Program

no = 6
total = 0
div = 1

while div < no:
    if no % div == 0:
        total = total + div
    div += 1

if no == total:
    print('Perfect Number')
else:
    print('Not Perfect Number')

Code Explanation

no = 6

Stores the number we want to check.

total = 0

Used to store the sum of factors.

div = 1

Starting divisor.

while div < no:

Runs from 1 up to 5.

if no % div == 0:

Checks whether the divisor is a factor.

For example:

6 % 2 = 0

So 2 is a factor.

total = total + div

Adds the factor to the total.

div += 1

Moves to the next divisor.

After the loop completes:

if no == total:

Compares the factor sum with the original number.

If both are equal:

Perfect Number

Otherwise:

Not Perfect Number

Output

Perfect Number

Conclusion

Data types are one of the most important concepts in Python because they help the computer understand what kind of data it is working with. Without data types, the computer would not know whether a value should be treated as a character, number, text, or logical value.

However, learning Python is not only about understanding data types and syntax. It is also about learning how to think logically.

In this article, we started by understanding why data types exist and how computers interpret information internally. We then explored some fundamental Python data types and saw how they help the interpreter process different kinds of data correctly.

After building that foundation, we worked through two logical problems:

Determining whether the sum of two numbers is Odd or Even.
Checking whether a number is a Perfect Number.

Instead of jumping directly into code, we first analyzed the problem, observed patterns, built the logic step by step, designed simple flowcharts, and then translated that logic into Python code. This is the same approach followed by experienced programmers when solving real-world problems.

A good programmer does not start with code.

A good programmer starts with:

Understanding the problem.
Breaking it into smaller steps.
Building a logical solution.
Creating a flow of execution.
Converting that logic into code.

The more logical problems you solve, the stronger your problem-solving skills become. Python provides the tools, but logic is what transforms those tools into solutions.

Keep practicing, keep questioning, and most importantly, keep building logic before writing code.

The Ultimate Python Logic Journey: Chocolates -> Divisors -> Primes

Kathirvel S — Fri, 29 May 2026 14:24:42 +0000

Imagine this...

You walk into a shop and buy 30 chocolates. 🍫

Your friend looks at the chocolates and asks:

“Can we divide these chocolates equally among people without breaking any chocolate?”

Interesting question, right?

So now we start thinking...

Can 1 person take all 30 chocolates?
Can 2 people share equally?
What about 3?
4?
5?
6?

Suddenly... mathematics enters the story.

And that is where the beautiful idea of Divisors begins.

Step 1: Understanding Divisors Using Chocolates

We have:

30 chocolates

Now let’s check who can divide them equally.

If a number divides 30 completely with no remainder, then it is called a divisor (or factor) of 30.

These are the divisors of 30:

1 2 3 5 6 10 15 30

Because:

30 ÷ 1 = 30
30 ÷ 2 = 15
30 ÷ 3 = 10
30 ÷ 5 = 6

No remainder anywhere.

The Secret Weapon: `%` Modulus Operator

In Python:

30 % 2

means:

“What remainder is left when 30 is divided by 2?”

If the answer is:

then division happened perfectly.

That means:

2 is a divisor of 30

Step 2: Checking Divisors Manually

At first, beginners usually think like this:

if 30%1 == 0:
    print(1)

if 30%2 == 0:
    print(2)

if 30%3 == 0:
    print(3)

if 30%4 == 0:
    print(4)

if 30%5 == 0:
    print(5)

if 30%6 == 0:
    print(6)

if 30%7 == 0:
    print(7)

if 30%8 == 0:
    print(8)

Let’s Understand This Deeply

Take this line:

if 30%2 == 0:
    print(2)

Here’s what happens internally:

Step-by-step Thinking

Divide 30 by 2
Check the remainder
If remainder is 0
Then print 2

Because 30 divides perfectly by 2.

Flowchart

        Start
           |
           v
     Check 30 % 2
           |
     Is remainder 0?
        /       \
      Yes       No
      /           \
Print 2        Ignore
      \
       v
       End

But Wait... This Feels Repetitive

Imagine checking till 1000 manually.

Impossible!

So programmers start asking smarter questions:

“Can the computer repeat the work for us?”

And that leads us to loops.

Step 3: Reducing Repetition

Instead of writing many if statements:

div = 1

if 30%div == 0:
    print(div)

div+=1

if 30%div == 0:
    print(div)

div+=1

if 30%div == 0:
    print(div)

div+=1

Now we introduced a variable:

div

which means:

“Current divisor we are checking.”

What is Happening Here?

Initially:

div = 1

Then:

30 % div

checks whether current divisor divides 30 perfectly.

After checking:

div += 1

moves to the next divisor.

This is already smarter than writing everything manually.

But still repetitive.

Step 4: The Power of While Loop

Now comes the real programming mindset.

no = 30
div = 1

while div <= no:
    if no % div == 0:
        print(div)

    div += 1

Let’s Build the Logic Slowly

We are saying:

“Start divisor from 1 and keep checking till 30.”

Detailed Breakdown

Line 1

no = 30

The number whose divisors we want.

Line 2

div = 1

We begin checking from divisor 1.

Line 3

while div <= no:

Meaning:

“Keep running until divisor becomes greater than 30.”

Inside the Loop

if no % div == 0:

Check whether divisor divides the number perfectly.

If True

print(div)

Print the divisor.

Move Forward

div += 1

Go to next divisor.

Flowchart

           Start
              |
              v
          no = 30
          div = 1
              |
              v
       Is div <= no ?
          /       \
        Yes        No
         |          |
         v          v
   Check no % div   End
         |
   Is remainder 0?
      /       \
    Yes        No
     |          |
Print div       |
      \         /
       v       v
       div += 1
           |
           v
      Repeat Loop

Output

Beautiful.

The computer found all divisors automatically.

Step 5: Can We Make It Faster?

Suppose:

no = 10000

Do we really need to check till 10000?

Actually no.

Because:

A number cannot have divisors greater than half of itself (except the number itself).

So we optimize.

Optimized Version

no = 10000
div = 2

while div <= no//2:
    if no % div == 0:
        print(div)

    div += 1

Why Start From 2?

Because:

1 is always a divisor
number itself is always a divisor

We are searching for divisors in between.

Why `no//2`?

Because no number larger than half can divide the number evenly.

For example:

Can 20 divide 30?

No.

So checking after 15 is useless.

This saves time.

This is called:

Optimization

A very important programming skill.

Flowchart

      Start
         |
         v
    no = 10000
    div = 2
         |
         v
 Is div <= no//2 ?
      /         \
    Yes          No
     |            |
     v            v
Check no % div    End
     |
Is remainder 0?
   /      \
 Yes      No
  |        |
Print div  |
    \      /
     v    v
    div += 1
        |
        v
    Repeat

Step 6: Counting Divisors Instead of Printing

Now a new idea comes.

Instead of printing divisors...

What if we count them?

Code

no = 30
div = 2
count = 0

while div <= no//2:
    if no % div == 0:
        count += 1

    div += 1

print("Count of Divisors", count)

Deep Understanding

Variable `count`

This stores:

“How many divisors we found.”

Initially:

count = 0

Whenever divisor is found:

count += 1

means:

count = count + 1

Let’s Trace It

For 30:

Divisors between 2 and 15 are:

2 3 5 6 10 15

Total:

So output becomes:

Count of Divisors 6

Flowchart

        Start
           |
           v
      count = 0
           |
           v
   Check divisors
           |
    Divisor found?
        /      \
      Yes       No
       |
 count += 1
       |
       v
 Continue Loop
       |
       v
 Print count

Step 7: The Birth of Prime Numbers

Now comes the magical idea.

A prime number is:

A number that has NO divisors except 1 and itself.

Examples:

2 3 5 7 11 13 17

Let’s Test 31

no = 31
div = 2
count = 0

while div <= no//2:
    if no % div == 0:
        count += 1

    div += 1

if count == 0:
    print(no, 'is a prime number')

The Core Idea

We search for divisors between:

2 to no//2

If we find none...

Then the number is prime.

Why Does This Work?

For 31:

31 % 2 → not 0
31 % 3 → not 0
31 % 4 → not 0

...

No divisor found.

So:

count == 0

Which means:

31 is a prime number

Flowchart

          Start
             |
             v
        count = 0
             |
             v
      Check divisors
             |
      Any divisor found?
          /        \
        Yes         No
        |            |
   count += 1        |
         \           /
          v         v
       Loop Ends
             |
             v
      Is count == 0 ?
          /       \
        Yes        No
         |          |
 Print Prime      Not Prime

Special Fact

The One and Only Even Prime Number is 2

Why?

Because every other even number is divisible by 2.

But 2 itself has only:

1 and 2

as divisors.

So it is prime.

Final Big Idea

Everything started with chocolates.

Then we learned:

Chocolate Sharing
        ↓
Divisors
        ↓
Finding Divisors
        ↓
Counting Divisors
        ↓
Prime Numbers

This is how programming should be learned.

Not by memorizing code.

But by:

Asking questions
Building logic slowly
Thinking like a problem solver

Final Thought

Whenever you see a prime number problem now...

Don’t think:

“Oh no, math!”

Instead think:

“Can this number share chocolates equally with anyone?”

And suddenly...

Prime numbers become simple.

Java Data Types: The Deep Dive Nobody Actually Gives You

Kathirvel S — Fri, 29 May 2026 11:00:20 +0000

You've probably seen a tutorial that goes: "int stores numbers, String stores text, boolean is true or false — moving on!" And then you're left writing code, wondering why Java has 8 integer-ish things, why your float math is slightly wrong, or the difference between a field and a local variable actually is.

This isn't that tutorial.

We're going deep — memory sizes, JVM storage, when to pick what, and the stuff even experienced devs sometimes get fuzzy on. Buckle up.

What Even Is a "Data Type"?

Before we split into primitive vs non-primitive, let's just get this straight.

Java is a statically-typed language. That means every single variable you declare has to have a type, and the compiler knows that type at compile time — before your program ever runs. Compare that to something like Python, where you just write x = 42 and Python figures out the type at runtime.

So in Java, when you write:

int age = 25;

You're not just storing a number. You're telling the compiler: "this slot of memory holds a 32-bit signed integer, nothing else, ever." That contract is locked in.

This is why data types matter so much in Java — they define:

How much memory to allocate
What values are valid
What operations you can perform
How the JVM handles the variable in memory

Alright, now let's get into the actual categories.

Primitive vs Non-Primitive — What's the Real Difference?

Here's the actual distinction, not the watered-down version.

Primitive types are built directly into the Java language specification. They aren't objects. They don't have methods. They're not created with new. They just hold a raw value — directly. When you write int x = 5, that 5 is stored as a plain binary value in memory. No wrapper, no metadata, nothing else.

Non-primitive types (also called reference types) are objects. When you create one, the JVM allocates space on the heap, and your variable holds a reference (think: a memory address) pointing to that object. The variable itself doesn't contain the data — it contains a pointer to where the data lives.

Let's make this concrete:

int a = 10;         // 'a' IS the value 10 — stored directly
String s = "hello"; // 's' is a reference — points to an object on the heap

Here's the key difference that matters in practice:

int a = 10;
int b = a;  // b gets a COPY of 10
b = 99;
System.out.println(a); // still 10 — a is unaffected

String str1 = new String("hello");
String str2 = str1;  // str2 holds the same REFERENCE as str1
// both point to the same object

With primitives, you copy the value. With references, you copy the address. That distinction trips up a lot of people when they start passing objects into methods.

One more thing: primitives can never be null. A non-primitive can. That's actually a significant design point — if you declare int x; inside a method without assigning it, the compiler won't even let you use it. But String s; can hold null (when it's a field — more on that later).

The 8 Primitive Types — Actually Explained

According to the Oracle Java documentation, Java has exactly 8 primitive data types. Let's go through all of them properly.

`byte` — 8 bits, -128 to 127

byte temperature = 36;
byte smallCounter = -50;

byte is an 8-bit signed two's complement integer. That gives you a range of -128 to 127.

When to actually use it: Primarily in large arrays where memory genuinely matters — like reading raw file data, network streams, or image pixel processing. If you have an array of 10 million small numbers that fit in -128 to 127, using byte[] instead of int[] saves you 30MB right there.

Don't reach for byte in everyday code just to "save memory" on individual variables. The JVM often internally promotes bytes to int for arithmetic anyway, so the benefit only shows at scale.

`short` — 16 bits, -32,768 to 32,767

short year = 2024;
short population = 32000;

short is 16 bits. Same story as byte — you'd use it in large arrays where the data genuinely fits within the range and memory is a concern. In modern development, you'll rarely see short in the wild. But it exists and it's valid.

`int` — 32 bits, the workhorse

int score = 150000;
int negativeValue = -2147483648; // Integer.MIN_VALUE
int maxValue = 2147483647;       // Integer.MAX_VALUE

This is your default integer type. 32 bits, stores values from roughly -2.1 billion to +2.1 billion. Whenever you write a whole number literal like 42, Java treats it as an int by default.

From Java 8 onward, you can also treat int as an unsigned 32-bit integer using methods like Integer.compareUnsigned() — but that's an edge case for lower-level work.

Use int unless you have a specific reason not to.

`long` — 64 bits, when `int` isn't enough

long worldPopulation = 8_000_000_000L;   // notice the L suffix
long nanoseconds = System.nanoTime();

When your number outgrows int's ~2 billion limit, you step up to long. It's 64 bits, which gets you up to about 9.2 quintillion. Timestamps in milliseconds (like System.currentTimeMillis()), large ID values, or file sizes in bytes are common use cases.

The L suffix is required when assigning a long literal that exceeds int's range. By convention, use uppercase L — lowercase l looks too much like the number 1.

`float` — 32-bit decimal, single precision

float price = 9.99f;    // f suffix required
float pi = 3.14f;

float is a 32-bit IEEE 754 floating-point number. Notice the f suffix — without it, Java assumes double.

Here's the critical thing everyone should know: never use float or double for money. Floating-point arithmetic isn't exact. This is a fundamental truth of how computers represent decimals in binary:

float a = 0.1f;
float b = 0.2f;
System.out.println(a + b); // 0.3 right? Nope — prints 0.3000000119

For currency, use java.math.BigDecimal. For scientific computations where a small rounding error is acceptable, float or double is fine.

Use float over double when you're working with large arrays of floating-point numbers and memory is tight.

`double` — 64-bit decimal, double precision

double gravity = 9.81;
double pi = 3.141592653589793;

This is your default decimal type. Any decimal literal you write (like 3.14) is a double by default. It's more precise than float but still not exact — the same "don't use for money" rule applies.

Use double as your go-to for decimals. Use float only when you need to save memory in large arrays.

`char` — 16-bit Unicode character

char grade = 'A';
char symbol = '\u00A9'; // © copyright symbol
char newline = '\n';

char is 16 bits and holds a single Unicode character (UTF-16). The minimum value is '\u0000' (0) and the maximum is '\uffff' (65,535). This is why Java can handle characters from virtually any human language — the 16-bit Unicode space is large enough for the basic multilingual plane.

One thing that surprises people: char can also participate in arithmetic, since it's technically an unsigned integer under the hood:

char c = 'A';
System.out.println(c + 1); // prints 66 (int arithmetic!)

`boolean` — true or false, nothing else

boolean isLoggedIn = true;
boolean hasPermission = false;

Two values. That's it. boolean represents one bit of logical information.

Interesting technical note: the Java specification says boolean's "size isn't something that's precisely defined." In practice, the JVM typically represents a boolean field using a full byte (8 bits) for alignment purposes — but this is a JVM implementation detail, not a spec guarantee. In boolean arrays (boolean[]), each element typically takes 1 byte. So don't assume boolean magically saves memory compared to byte.

Default Values — A Gotcha You Need to Know

When you declare a field (a variable attached to a class) without initializing it, the JVM assigns a sensible default. Here's the full table from the official Oracle docs:

Type	Default Value
`byte`	0
`short`	0
`int`	0
`long`	0L
`float`	0.0f
`double`	0.0d
`char`	`'\u0000'`
`boolean`	`false`
Any object	`null`

But here's the catch: this only applies to fields (class-level variables). Local variables — variables declared inside a method — get NO default value. Try to use one before assigning it and you'll get a compile error:

public void example() {
    int x;
    System.out.println(x); // Compile error: variable x might not have been initialized
}

The compiler protects you here. Don't rely on defaults even for fields — it's considered bad practice. Initialize explicitly.

Non-Primitive Types — Where Objects Live

Non-primitive types are everything else: classes, arrays, interfaces, enums. They're all reference types. Let's hit the most important ones.

String

String name = "Ada Lovelace";
String empty = null; // valid — reference types can be null

String gets special treatment in Java. It's not technically primitive, but you can create one without new by using a string literal. When you do that, Java places the string in a special area called the string pool (inside the heap) and reuses it if the same literal is used again:

String a = "hello";
String b = "hello";
System.out.println(a == b);       // true — same object from the pool
System.out.println(a.equals(b));  // true — same content

String c = new String("hello");
System.out.println(a == c);       // false — different object!
System.out.println(a.equals(c));  // true — content is same

This is why you should always use .equals() to compare strings, never ==. The == operator compares references (are they the same object?), not content (do they contain the same text?).

Also: String is immutable. Once created, its value cannot change. When you do str = str + " world", you're not modifying the original string — you're creating a brand new one. For heavy string manipulation in loops, use StringBuilder instead.

Arrays

int[] scores = new int[5];
String[] names = {"Alice", "Bob", "Charlie"};
int[][] matrix = new int[3][3]; // 2D array

Arrays are objects in Java. Even int[] is a reference type — it lives on the heap. Arrays have a fixed size once created (you can't resize them). If you need a growable list, use ArrayList.

Classes and Objects

// Custom class — a non-primitive type you define
public class Person {
    String name;
    int age;
}

Person p = new Person(); // p is a reference to a Person object on the heap

When you create an object with new, the JVM allocates memory on the heap and returns a reference. Your variable holds that reference.

Interfaces

Interfaces are reference types used to define contracts. A variable of an interface type holds a reference to an object that implements that interface:

List<String> items = new ArrayList<>(); // List is an interface

Where Does Everything Actually Live in Memory?

This is the part most tutorials skip. Let's fix that.

The JVM has two main memory areas you need to understand:

Stack memory is where method execution happens. Every time you call a method, a new "stack frame" is pushed onto the stack. That frame holds the method's local variables and its return address. When the method returns, the frame is popped — the memory is instantly freed. Stack memory is fast, automatically managed, and thread-specific.

Heap memory is shared across the entire application. This is where objects live — anything created with new. The garbage collector manages heap memory, cleaning up objects that are no longer referenced.

Now here's how this maps to data types:

public void myMethod() {
    int x = 42;          // x lives on the stack — directly
    String s = "hello";  // s (the reference) lives on the stack,
                         // the String object lives on the heap
}

The reference variable s is on the stack. The actual String object it points to is on the heap. When myMethod() finishes, s disappears from the stack. If nothing else references that String, it becomes eligible for garbage collection.

Static Fields vs Instance Fields — The Memory That Sticks Around

Here's where things get interesting, and this connects directly to the static vs non-static question you had.

Instance Fields (Non-Static)

public class Car {
    String color;  // instance field
    int speed;     // instance field
}

Car car1 = new Car();
Car car2 = new Car();
car1.color = "red";
car2.color = "blue"; // completely independent

Instance fields are declared without static. Each object gets its own copy. car1.color and car2.color are completely separate values in memory — both on the heap, inside their respective Car objects.

Static Fields (Class Variables)

public class Counter {
    static int count = 0;  // static field — belongs to the CLASS

    public Counter() {
        count++; // every new Counter instance shares this
    }
}

Counter c1 = new Counter();
Counter c2 = new Counter();
System.out.println(Counter.count); // 2 — shared across all instances

Static fields belong to the class itself, not to any individual object. There is exactly one copy, regardless of how many instances you create. The JVM stores static fields in a special area associated with the class's metadata — historically called the PermGen, now called Metaspace (since Java 8).

As the Oracle docs state clearly: "there is exactly one copy of a class variable, regardless of how many times the class has been instantiated."

Local Variables

public void calculate() {
    int result = 0;          // local variable — lives on the stack
    String message = "done"; // local variable — reference on stack, object on heap
}

Local variables live inside methods. They're created on the stack when the method starts and destroyed when it ends. The compiler never assigns default values to local variables — you must initialize them yourself before use.

Summary: Where Does Each Variable Type Live?

Variable Kind	Where It Lives	Lifecycle
Local primitive	Stack	Method execution
Local reference	Stack (reference) + Heap (object)	Method execution
Instance primitive	Heap (inside the object)	Object's lifetime
Instance reference	Heap (reference + object)	Object's lifetime
Static primitive	Metaspace/class area	Class is loaded → app ends
Static reference	Metaspace (reference) + Heap (object)	Same

When to Use What — A Practical Decision Guide

Let's make this actionable.

Use int for any whole number unless you have a reason to do otherwise. It's the default, the most optimized, and the most readable.

Use long when your number can exceed ~2.1 billion — timestamps, large IDs, file sizes.

Use double for decimals. It's the default. Don't overthink it.

Use byte or short only in large arrays (thousands to millions of elements) where memory actually matters.

Use float over double only when you're in a massive array context and need to halve the memory footprint.

Never use float or double for money. Use BigDecimal. Seriously.

Use boolean for flags and conditions. Resist the temptation to use int with 0/1 — that's C thinking, not Java thinking.

Use char when you genuinely need to work with individual characters. For text, use String.

Use String with .equals(), never == for comparison.

Use static for:

Constants (static final int MAX_SIZE = 100)
Utility/helper methods that don't need object state
Counters or shared state across all instances (carefully)

Avoid static for:

Anything that should be different per object
Mutable shared state (thread-safety nightmare)

The Memory Size Cheat Sheet

Here's everything in one place:

Type	Size	Range / Notes
`byte`	8 bits (1 byte)	-128 to 127
`short`	16 bits (2 bytes)	-32,768 to 32,767
`int`	32 bits (4 bytes)	~-2.1B to ~2.1B
`long`	64 bits (8 bytes)	~-9.2 quintillion to ~9.2 quintillion
`float`	32 bits (4 bytes)	~±3.4×10³⁸, ~7 significant decimal digits
`double`	64 bits (8 bytes)	~±1.7×10³⁰⁸, ~15-16 significant decimal digits
`char`	16 bits (2 bytes)	`'\u0000'` to `'\uffff'` (0 to 65,535)
`boolean`	~1 byte (JVM-dependent)	`true` or `false`

Wrapping Up

Data types in Java aren't just syntax trivia. They're decisions that affect how much memory your program uses, how fast it runs, and how correctly it behaves. The difference between a float and a BigDecimal in a banking app isn't academic — it's the difference between correct output and off-by-a-penny errors.

If you take away just a few things from this, let it be these:

Primitive types store values directly; reference types store addresses pointing to heap objects
Use int and double as your defaults; only go smaller for memory-sensitive bulk data
Never use floating-point for exact decimal arithmetic
Static fields are shared across all instances — one copy per class, not per object
Local variables need to be explicitly initialized; fields get defaults (but relying on defaults is bad practice)
Always compare String content with .equals(), not ==

The Java type system feels rigid at first, but that rigidity is what lets the compiler catch entire classes of bugs before your code ever runs. Lean into it.

References

Understanding Loops, Conditions, and Real-World Logic Through a Train Journey

Kathirvel S — Thu, 28 May 2026 13:33:21 +0000

Train Story Logic with Python

Programming becomes easier when we connect code with real-life stories.
Instead of memorizing syntax, imagine a situation happening in the real world.

In this blog, we are going to learn Python loops and conditions using a train station story.

We will build the logic slowly.

Not directly with code.

First, we will think like humans.

Then we will teach that thinking to Python.

Finally, we will combine everything into a complete working program.

The Story Begins

Imagine there are 300 railway stations.

Two trains are traveling on the same railway route.

Train 1 stops at every station divisible by 3
Train 2 stops at every station divisible by 8

Now imagine a railway officer asking:

“At which station will both trains stop together?”

This is where logic begins.

Step 1 — Think Before Coding

Before touching Python, let us think carefully.

If Train 1 stops at stations divisible by 3:

And Train 2 stops at stations divisible by 8:

Now look carefully.

Which station appears in both lists?

👉 24

That means:

24 is divisible by 3
24 is divisible by 8

So both trains stop there together.

Now another question appears:

How do we teach Python to discover this automatically?

That is where loops and conditions help us.

Step 2 — Understanding the Search Process

Imagine a railway officer checking every station one by one.

The officer starts from station 1.

Then checks:

station 2
station 3
station 4
...

Until station 300.

At every station, the officer asks:

Is this station divisible by 3 AND divisible by 8?

If YES:

Both trains meet here.

This is exactly what our first Python program does.

First Program — Finding the First Meeting Station

station_no=1

while station_no<=300:

    if station_no%3==0 and station_no%8==0:
        print(station_no)
        break

    station_no+=1

Line 1

station_no=1

We start checking from station 1.

Line 3

while station_no<=300:

This loop means:

“Keep checking stations until station 300.”

Python now behaves like a railway officer checking every station.

Line 5

if station_no%3==0 and station_no%8==0:

This is the heart of the logic.

Let us decode it slowly.

What does `%` mean?

% is called the modulus operator.

It gives the remainder.

Example:

24 % 3 = 0

Why?

Because 24 divides perfectly by 3.

Similarly:

24 % 8 = 0

So when remainder becomes 0, it means:

The number is divisible.

Understanding AND Condition

station_no%3==0 and station_no%8==0

This means BOTH conditions must be true.

divisible by 3 ✅
divisible by 8 ✅

Only then Python prints the station.

Line 6

print(station_no)

Python prints the station where both trains meet.

Output:

Line 7

break

This stops the loop immediately.

Because we only wanted the first meeting station.

Without break, Python would continue checking all 300 stations.

Line 9

station_no+=1

Move to the next station.

Same as:

station_no = station_no + 1

Step 3 — Now Let Us Watch Both Trains

Now we want something more interesting.

Instead of finding only the meeting station, let us watch:

where Train 1 stops
where Train 2 stops
where both stop together

This creates a beautiful railway simulation.

Second Program — Tracking Both Trains

station_no=1

while station_no<=30:

    if station_no%3==0:
        print("train 1 stopped at :",station_no)

    if station_no%8==0:
        print("train 2 stopped at :",station_no)

    if station_no%3==0 and station_no%8==0:
        print("train 1 and train 2 stopped at",station_no)

    station_no+=1

Understanding the Logic Deeply

Now Python checks every station from 1 to 30.

At each station:

Check Train 1
Check Train 2
Check whether both trains meet

Example Walkthrough

Station 3

3 % 3 == 0

TRUE ✅

Output:

train 1 stopped at : 3

Station 8

8 % 8 == 0

TRUE

Output:

train 2 stopped at : 8

Station 24

Now something special happens.

24 % 3 == 0
24 % 8 == 0

Both TRUE

Output:

train 1 stopped at : 24
train 2 stopped at : 24
train 1 and train 2 stopped at 24

This is the meeting station.

Step 4 — Railway Analytics System

Now let us make the program smarter.

Suppose railway management asks:

How many times did the trains meet?
Which was the first meeting station?
Which was the last meeting station?

Now we move from basic coding to data tracking.

This is where variables become powerful.

Third Program — Counting Train Meetings

station_no=1
count=0
first=0
last=0

while station_no<=300:

    if station_no%3==0 and station_no%8==0:

        print("train meets station at :",station_no)

        if count==0:
            first=station_no

        count=count+1
        last=station_no

    station_no=station_no+1

print("total station meet",count)
print("first meet:",first)
print("last meet:",last)

Breaking the Logic Slowly

Variable 1 — Count

count=0

This counts how many times trains meet.

Every time trains meet:

count=count+1

Count increases.

Variable 2 — First Meeting Station

first=0

Initially unknown.

Now observe this logic:

if count==0:
    first=station_no

This means:

“If this is the first meeting, store the station number.”

Only the first meeting gets stored.

Variable 3 — Last Meeting Station

last=0

Every time trains meet:

last=station_no

The value keeps updating.

So finally it stores the latest meeting station.

What Happens Internally?

Meeting stations between 1 and 300 are:

Total = 12 meetings.

So output becomes:

total station meet 12
first meet: 24
last meet: 288

Hidden Mathematics Behind the Story

There is actually a mathematical secret here.

The trains meet at numbers divisible by BOTH 3 and 8.

That means:

LCM of 3 and 8

LCM = 24

So trains meet every 24 stations.

This means:

This is how programming and mathematics work together beautifully.

Final Thoughts

Most beginners try to memorize Python syntax.

But great programmers think differently.

They first ask:

“What is the real-world logic?”

Once logic becomes clear, code becomes easy.

Programming is not about typing fast.

Programming is about teaching the computer how to think step by step.

And that is exactly what we did with our train story.

Complete Final Code 🚆

# Finding first meeting station

station_no=1

while station_no<=300:

    if station_no%3==0 and station_no%8==0:
        print(station_no)
        break

    station_no+=1


# Watching both train stops

station_no=1

while station_no<=30:

    if station_no%3==0:
        print("train 1 stopped at :",station_no)

    if station_no%8==0:
        print("train 2 stopped at :",station_no)

    if station_no%3==0 and station_no%8==0:
        print("train 1 and train 2 stopped at",station_no)

    station_no+=1


# Counting all meetings

station_no=1
count=0
first=0
last=0

while station_no<=300:

    if station_no%3==0 and station_no%8==0:

        print("train meets station at :",station_no)

        if count==0:
            first=station_no

        count=count+1
        last=station_no

    station_no=station_no+1

print("total station meet",count)
print("first meet:",first)
print("last meet:",last)

Object-Oriented Programming (OOPs) in Java

Kathirvel S — Wed, 27 May 2026 14:12:25 +0000

Java is one of the most popular programming languages in the world, and one major reason behind its popularity is Object-Oriented Programming, commonly called OOPs.

OOPs is not just a programming style. It is a way of thinking and designing software so that programs become easier to build, understand, maintain, and reuse.

In this blog, we will understand:

Why OOPs was introduced
Problems faced before OOPs
What OOPs actually means
Core concepts of OOPs in Java
Real-world examples
Advantages of OOPs
Why modern software development depends on OOPs

Why Was OOPs Needed?

Before OOPs became popular, most programs were written using procedural programming.

In procedural programming:

Code is divided into functions
Data is shared globally
Programs grow as a collection of procedures

This approach works fine for small programs, but as applications become large, several problems appear.

Problems in Procedural Programming

1. Code Becomes Difficult to Manage

Imagine building a banking application with thousands of lines of code.

If everything is written as functions and global variables:

One change may affect many parts
Debugging becomes difficult
Understanding the system takes more time

2. Data Is Not Secure

In procedural programming, data is often globally accessible.

That means any function can modify important data accidentally.

Example:

balance = balance - 5000;

Any part of the program can directly change the balance.

This creates security and reliability problems.

3. Reusability Is Poor

Suppose you create a function for one project.

Using it in another project may require major modifications because code is tightly connected.

4. Real-World Modeling Is Difficult

Procedural programming focuses on functions.

But the real world contains objects like:

Cars
Students
Employees
Bank accounts

Representing these entities naturally becomes difficult.

5. Large Applications Become Complex

Modern applications contain:

Millions of lines of code
Multiple developers
Different modules

Managing such systems without proper structure becomes nearly impossible.

What Problem Does OOPs Solve?

OOPs solves these issues by organizing software around objects instead of just functions.

It provides:

Better structure
Data security
Code reusability
Easy maintenance
Real-world modeling
Scalability

OOPs allows developers to build software like assembling components of a machine.

Each object handles its own responsibilities.

What Is OOPs?

Object-Oriented Programming is a programming paradigm based on the concept of:

Objects
Classes

An object contains:

Data (variables)
Behavior (methods)

Simple Definition

OOPs is a way of designing programs using objects that contain both data and functions together.

Understanding with a Real-World Example

Think about a Car.

A car has:

Properties (Data)

Color
Brand
Speed

Behaviors (Functions)

Start()
Stop()
Accelerate()

In Java, we can represent this as an object.

class Car {

    String color;
    String brand;
    int speed;

    void start() {
        System.out.println("Car started");
    }

    void stop() {
        System.out.println("Car stopped");
    }
}

Here:

Car is a class
color, brand, speed are data members
start() and stop() are methods

What Is a Class in Java?

A class is a blueprint or template used to create objects.

It defines:

Variables
Methods
Structure

Example

class Student {

    String name;
    int age;

    void study() {
        System.out.println(name + " is studying");
    }
}

This class describes what a student object should contain.

What Is an Object?

An object is a real instance created from a class.

Example

Student s1 = new Student();

s1.name = "Rahul";
s1.age = 20;

s1.study();

Here:

s1 is an object
It contains real values

Output:

Rahul is studying

Core Concepts of OOPs in Java

The foundation of OOPs is built on four major principles:

Encapsulation
Inheritance
Polymorphism
Abstraction

These are called the four pillars of OOPs.

1. Encapsulation

Encapsulation means:

Wrapping data and methods together into a single unit.

It also means restricting direct access to data.

This is achieved using:

Classes
Access modifiers
Getters and setters

Why Encapsulation Is Important

Without encapsulation:

Anyone can change data directly
Data becomes unsafe

With encapsulation:

Data is controlled
Validation becomes possible
Security improves

Example of Encapsulation

class BankAccount {

    private double balance;

    public void deposit(double amount) {
        balance += amount;
    }

    public double getBalance() {
        return balance;
    }
}

Here:

balance is private
Direct access is restricted
Data can only be changed through methods

This protects important information.

2. Inheritance

Inheritance allows one class to acquire properties and methods of another class.

It promotes:

Code reuse
Better organization

Real-World Example

A Dog is an Animal.

So the dog can inherit common animal properties.

Example

class Animal {

    void eat() {
        System.out.println("Eating...");
    }
}

class Dog extends Animal {

    void bark() {
        System.out.println("Barking...");
    }
}

Usage:

Dog d = new Dog();

d.eat();
d.bark();

Output:

Eating...
Barking...

The Dog class reused functionality from Animal.

3. Polymorphism

Polymorphism means:

One thing behaving in multiple forms.

In Java, polymorphism mainly occurs in two ways:

Method Overloading
Method Overriding

Method Overloading

Same method name with different parameters.

class MathOperation {

    int add(int a, int b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }
}

The add() method behaves differently based on parameters.

Method Overriding

A child class changes the behavior of a parent method.

class Animal {

    void sound() {
        System.out.println("Animal makes sound");
    }
}

class Dog extends Animal {

    void sound() {
        System.out.println("Dog barks");
    }
}

Output:

Dog barks

4. Abstraction

Abstraction means:

Showing only essential details and hiding implementation complexity.

Example:

When driving a car:

You use steering, brakes, accelerator
You do not need to know engine internals

Why Abstraction Matters

It reduces complexity.

Users focus on:

What an object does
Not how it works internally

Abstraction Using Abstract Class

abstract class Vehicle {

    abstract void start();
}

class Car extends Vehicle {

    void start() {
        System.out.println("Car starts with key");
    }
}

Relationship Between Class and Object

Class	Object
Blueprint	Real instance
Logical entity	Physical entity
Defines structure	Holds actual data

Example:

Class = Car design
Object = Actual car

Features of OOPs in Java

1. Modularity

Programs are divided into smaller parts.

Each class handles specific tasks.

2. Reusability

Existing classes can be reused through inheritance.

This reduces duplicate code.

3. Scalability

Large applications become easier to expand.

4. Maintainability

Errors can be fixed more easily because code is organized.

5. Security

Encapsulation protects sensitive data.

Real-Life Examples of OOPs

OOPs exists everywhere in software development.

Banking System

Objects:

Customer
Account
Transaction

E-Commerce Website

Objects:

Product
Cart
Order
User

Why Java Is Called an Object-Oriented Language

Java follows OOP principles strongly.

In Java:

Everything is organized into classes
Objects are heavily used
OOP concepts are built into the language

Java was designed to encourage structured software development.

Advantages of OOPs in Java

Advantage	Explanation
Reusability	Code can be reused
Security	Data hiding protects information
Flexibility	Polymorphism improves adaptability
Easy Maintenance	Organized code is easier to manage
Scalability	Large systems become manageable
Real-World Modeling	Programs represent real entities naturally

OOPs vs Procedural Programming

Procedural Programming	OOPs
Focuses on functions	Focuses on objects
Data is less secure	Data hiding improves security
Difficult to manage large systems	Better structure for large systems
Less reusable	Highly reusable
Complex maintenance	Easier maintenance

Conclusion

Object-Oriented Programming changed the way software is developed.

Instead of writing large collections of functions, OOPs organizes programs into meaningful objects that represent real-world entities.

OOPs helps solve major software development problems such as:

Code complexity
Poor maintainability
Lack of security
Low reusability

The four pillars of OOPs:

Encapsulation
Inheritance
Polymorphism
Abstraction

make Java powerful for building scalable and maintainable applications.

Today, most enterprise applications, mobile apps, banking systems, games, and web platforms rely heavily on OOP principles because they make software easier to understand, build, and grow.

Introduction to Java – The Language That Changed Programming

Kathirvel S — Wed, 27 May 2026 05:07:51 +0000

Programming languages did not appear suddenly. Every new language was created to solve the problems of older languages. As technology grew, developers needed languages that were easier, safer, faster, and more portable.

In the early days, programmers used low-level languages like Assembly Language. These languages were very hard to write and understand. Then came languages like C, which made programming easier and faster. But C also had some limitations such as memory management issues, security problems, and platform dependency.

To solve some of these issues, C++ was introduced. It added Object-Oriented Programming concepts, which helped developers organize code better. However, C++ became complex because of features like pointers, multiple inheritance, and manual memory management.

At that time, software companies wanted a language that was:

Simple to learn
Secure
Platform independent
Reliable
Easy to maintain

This is where Java entered the world.

Why Was Java Created?

Java was created by James Gosling and his team at Sun Microsystems in 1995.

Initially, Java was designed for electronic devices like televisions, set-top boxes, and home appliances. The goal was to create a language that could run on different devices without changing the code.

Later, with the rapid growth of the internet, Java became extremely popular for web applications and enterprise software.

The main problems Java tried to solve were:

Platform dependency in C and C++
Complex memory management
Security vulnerabilities
Difficult code maintenance
Lack of portability

Java introduced the concept:

“Write Once, Run Anywhere.”

This means a Java program can run on any operating system if Java is installed.

What is Java?

Official Definition of Java

Java is a high-level, object-oriented, platform-independent programming language used to develop desktop, web, mobile, and enterprise applications.

Simple and Understandable Definition

Java is a programming language that helps developers create applications that can run on different devices and operating systems without changing the code.

In simple words:

Java is a language that allows us to write code once and run it anywhere.

How Java Runs

Java has a special execution process that makes it platform independent.

Step 1: Writing Java Code

The programmer writes code in a file with .java extension.

Example:

class Hello {
    public static void main(String[] args) {
        System.out.println("Hello Java");
    }
}

Step 2: Compilation by JDK

The Java compiler inside the JDK converts the source code into Bytecode.

Source Code → Bytecode

The generated file has a .class extension.

What is JDK?

JDK stands for Java Development Kit.

It contains:

Compiler (javac)
Development tools
JRE

JDK is mainly used by developers to create Java programs.

Bytecode

Bytecode is an intermediate code generated by the Java compiler.

It is not machine code.

It is a special code understood by the Java Virtual Machine (JVM).

Because of bytecode, Java becomes platform independent.

Role of JRE

JRE stands for Java Runtime Environment.

It provides the environment needed to run Java programs.

JRE contains:

JVM
Libraries
Supporting files

Without JRE, Java programs cannot run.

What is JVM?

JVM stands for Java Virtual Machine.

It is responsible for executing Java bytecode.

The JVM converts bytecode into machine code that the computer understands.

JVM is the main reason Java is platform independent.

Interpreter in Java

Initially, the JVM uses an Interpreter.

The interpreter reads bytecode line by line and converts it into machine code.

This process is simple but slower because every line is translated during execution.

JIT Compiler

To improve performance, Java uses a JIT (Just-In-Time) Compiler.

The JIT compiler identifies frequently used code and converts it into native machine code.

This makes Java programs run much faster.

Java Execution Flow

The complete flow looks like this:

Java Source Code (.java)
        ↓
Compiler (JDK)
        ↓
Bytecode (.class)
        ↓
JVM inside JRE
        ↓
Interpreter + JIT Compiler
        ↓
Machine Code
        ↓
Program Output

Where is Java Used?

Java is used in many areas because of its stability and portability.

1. Web Applications

Java is widely used for backend development.

Examples:

Banking systems
E-commerce websites
Enterprise applications

Technologies:

Spring Boot
Hibernate
JSP
Servlets

2. Android App Development

Android applications were mainly built using Java for many years.

Examples:

Mobile apps
Games
Utility applications

3. Enterprise Applications

Large companies use Java for secure and scalable systems.

Examples:

Banking software
Insurance systems
ERP software

4. Desktop Applications

Java can create desktop software using:

JavaFX
Swing

Examples:

Media players
Management systems

5. Cloud and Big Data

Java is used in:

Hadoop
Apache Kafka
Cloud platforms

6. Embedded Systems

Java is also used in:

Smart cards
IoT devices
Electronic systems

Features of Java

1. Platform Independent

Java programs can run on any operating system.

2. Object-Oriented

Java follows Object-Oriented Programming concepts like:

Class
Object
Inheritance
Polymorphism

3. Simple

Java removed complex features like pointers and manual memory management.

4. Secure

Java provides:

Bytecode verification
Secure runtime environment
No direct memory access

5. Robust

Java handles errors properly and has automatic garbage collection.

6. Multithreading

Java supports running multiple tasks at the same time.

7. High Performance

With the help of the JIT compiler, Java performance improved significantly.

8. Distributed

Java supports network-based applications easily.

Advantages of Java

Easy to Learn

Java syntax is simple and readable.

Platform Independent

Code can run on multiple systems.

Secure

Widely used in banking and enterprise applications.

Huge Community Support

Millions of developers use Java worldwide.

Rich Libraries and Frameworks

Java has powerful frameworks like:

Spring
Hibernate
Maven

Automatic Memory Management

Garbage Collection automatically removes unused memory.

Disadvantages of Java

Slower Than Native Languages

Java can be slower compared to C and C++ because it runs through JVM.

More Memory Usage

Java applications consume more memory.

Verbose Code

Java often requires writing more lines of code.

GUI Development is Less Popular

Modern UI development is less preferred in Java compared to newer technologies.

Conclusion

Java became popular because it solved many problems found in older programming languages. It introduced platform independence, security, simplicity, and better memory management.

Today, Java is one of the most trusted programming languages in the world. From web applications to enterprise systems and Android apps, Java continues to play a major role in software development.

Even after many years, Java remains relevant because of its stability, large ecosystem, and continuous improvements.

If you want to learn a language that is powerful, reliable, and widely used in the industry, Java is still one of the best choices.

Learn Python Logic Through the Frog Escape Story

Kathirvel S — Tue, 26 May 2026 13:23:39 +0000

When we start learning programming, many people jump directly into writing code. But good programmers first try to understand the logic behind the problem.

In this blog, we will solve two interesting problems:

Sum of n numbers
A frog escaping from a 50-feet well

Instead of writing code immediately, we will first think like humans and build the logic step by step.

1. Sum of N Numbers Using While Loop

Suppose we want to find the sum from 1 to n.

Example:

1 + 2 + 3 + 4 + 5 = 15

Step 1: Understand the Logic

Before coding, think carefully.

We need to:

Start from number 1
Keep adding numbers one by one
Stop when we reach n

We will use:

one variable for counting numbers
one variable for storing the total sum

Step 2: Dry Run

Suppose n = 5

Current Number	Total Sum
1	1
2	3
3	6
4	10
5	15

Now the logic becomes easy.

Python Code Using While Loop

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

i = 1
total = 0

while i <= n:
    total = total + i
    i = i + 1

print("Sum is:", total)

Explanation of the Code

`i = 1`

We start counting from 1.

`total = 0`

This variable stores the final sum.

Initially, sum is zero.

`while i <= n`

The loop runs until i becomes greater than n.

`total = total + i`

This line adds the current number into the total.

Example:

total = 0 + 1
total = 1 + 2
total = 3 + 3

and so on.

`i = i + 1`

This increases the value of i by 1 every time.

Without this line, the loop would run forever.

Output

Enter a number: 5
Sum is: 15

2. Frog Story – Escaping From the Well

Now let’s solve a famous logic problem.

The Story

A frog falls into a well that is:

50 feet deep

Every day:

Frog climbs up 2 feet
At night, it slips down 1.25 feet

Question:

In how many days will the frog escape?

Step 1: Think About the Logic

First understand what happens in one complete day.

During the day:

+2 feet

At night:

-1.25 feet

So actual progress in one full day is:

2 - 1.25 = 0.75 feet

This means the frog slowly moves upward.

Code

feet = 50
up = 2
down = 1.25
day = 0

while feet > 0:
    feet = feet - up + down
    day = day + 1

print(day)

Proper Explanation of This Code

At first glance, this code may look confusing because:

feet starts from 50

Here, feet does not represent how much the frog climbed.

Instead, it represents:

how much distance is still left

Initially:

feet = 50

means:

50 feet are remaining to escape

Understanding the Main Logic

Inside the loop:

feet = feet - up + down

This means:

subtract the upward climb
add the downward slip

So every day:

remaining distance decreases by 0.75 feet

because:

2 - 1.25 = 0.75

Day-by-Day Understanding

Day 1

Remaining distance:

50 - 2 + 1.25 = 49.25

Day 2

49.25 - 2 + 1.25 = 48.5

The remaining distance keeps decreasing slowly.

`day = day + 1`

This line counts the number of days.

Each loop means:

one full day completed

`while feet > 0`

The loop runs until the remaining distance becomes zero or negative.

That means:

frog has escaped

Final Output

Important Note About This Logic

This code is mathematically correct according to the loop logic.

But in real-life logic:

the frog escapes immediately when it reaches the top
it should not slip back on the final day

So the more realistic answer is:

65 days

But the given code treats every day as:

climb first and slip every single time

That is why the output becomes slightly different.

Conclusion

Programming is not only about syntax and coding.
Real programming starts with thinking.

Whether it is finding the sum of numbers or helping a frog escape a well, logic always comes first.

So next time you solve a problem:

Think first, code later.

That is the mindset of a good programmer.

Conditional Statements and Control Flow in Python

Kathirvel S — Mon, 25 May 2026 05:20:15 +0000

When we first start learning programming, most beginners immediately jump into writing code. But before writing even a single line, there is something more important:

Thinking.

Programming is not only about typing code.
Programming is about teaching the computer how to think step by step.

A computer is very fast, but it is not intelligent by itself.
It only follows instructions that we give.

So before learning Python syntax, ask yourself:

How does a program make decisions?
How does a program repeat tasks?
How does a computer choose between two options?

This is where Conditional Statements and Control Flow come into the picture.

What is Control Flow?

Control flow means:

The order in which a program executes instructions.

Think of it like traffic on a road.

A program does not run everything at once.
It moves step by step.

Sometimes:

it goes forward,
sometimes it takes a different path,
sometimes it repeats the same path again and again.

Python controls this flow using:

if
elif
else
loops like while

These statements help Python make decisions like a human.

Imagine This Real-Life Situation

Suppose three students scored marks:

Arun → 15
Bala → 20
Charles → 45

Now someone asks:

“Who scored the highest marks?”

Before answering, your brain automatically compares all three values.

You think like this:

Is Arun greater than Bala and Charles?
No.
Is Bala greater than Arun and Charles?
No.
Then Charles must be the highest.

This exact thinking process is what we teach Python.

Conditional Statements in Python

Python uses:

if
elif
else

to make decisions.

Finding the Largest Number

Now let’s convert our thinking into code.

a = 15
b = 20
c = 45

if a > b and a > c:
    print(a)

elif b > a and b > c:
    print(b)

else:
    print(c)

Understanding the Code Slowly

Step 1 — Creating Variables

a = 15
b = 20
c = 45

Variables are containers that store values.

Here:

a stores 15
b stores 20
c stores 45

Step 2 — The if Statement

if a > b and a > c:

Python checks:

Is a greater than b?
AND
Is a greater than c?

The keyword and means:

Both conditions must be True.

Now Python checks:

15 > 20   → False
15 > 45   → False

Since the condition is False, Python skips this block.

Step 3 — elif Statement

elif b > a and b > c:

elif means:

“Check another condition.”

Now Python checks:

20 > 15   → True
20 > 45   → False

Again False.

So Python skips this too.

Step 4 — else Statement

else:
    print(c)

else means:

“If nothing above is true, run this.”

So Python prints:

Output

Why This Program Matters

This small program teaches powerful programming concepts:

Decision making
Comparison operators
Logical thinking
Problem solving

This is the foundation of real programming.

Another Example — Comparing Two Numbers

Before coding, think first.

Suppose:

a = 10
b = 5

Question:

Which number is greater?

Your brain instantly says:

10 is greater.

Now let’s teach Python the same thinking.

a = 10
b = 5

if a > b:
    print(a)

else:
    print(b)

Understanding the Logic

Python checks:

10 > 5

This is True.

So Python executes:

print(a)

Output:

Since the condition is True, the else block is ignored.

Truthy and Falsy Values

Now let’s explore something interesting.

Before coding, think carefully:

If I write:

if a:

What is Python checking?

Most beginners get confused here.

The Important Idea

In Python:

Some values behave like True
Some values behave like False

This is called:

Truthy and Falsy Values

Example

a = -0.1

if a:
    print("a")

else:
    print("b")

What Happens Here?

Python checks:

if -0.1

Since -0.1 is not zero, Python treats it as True.

So output becomes:

Important Rule

In Python:

These are considered False:

0
0.0
False
None
''
[]
{}

Everything else is usually True.

Why This Concept Is Powerful

This helps programmers write cleaner and smarter code.

You will see this concept everywhere in real-world Python applications.

Now Let’s Think About Repetition

Imagine printing numbers manually:

print(1)
print(1)
print(1)
print(1)
print(1)

This is boring and repetitive.

A programmer always asks:

“Can I automate this?”

That is why loops exist.

What is a while Loop?

A while loop repeats code while a condition remains True.

Basic syntax:

while condition:
    code

Printing the Same Number Multiple Times

count = 1

while count <= 5:
    print(1, end=' ')
    count = count + 1

Think Before Understanding the Loop

Ask yourself:

Where does the loop start?
When does it stop?
What changes inside the loop?

These three questions help you understand any loop in programming.

Step-by-Step Explanation

Step 1 — Initialize Variable

count = 1

This variable controls the loop.

Step 2 — Condition

while count <= 5:

Meaning:

Repeat while count is less than or equal to 5.

Step 3 — Print Statement

print(1, end=' ')

This prints 1.

The end=' ' keeps everything on the same line.

Step 4 — Increment

count = count + 1

This increases the count value.

Without this line, the loop would never stop.

Output

1 1 1 1 1

Printing Numbers from 1 to 5

Now instead of printing the same number, let’s print the changing value of count.

count = 1

while count <= 5:
    print(count, end=' ')
    count = count + 1

What Happens Internally?

count	Output
1	1
2	2
3	3
4	4
5	5

When count becomes 6:

6 <= 5

This becomes False.

So the loop stops.

Output

1 2 3 4 5

Printing with Addition Logic

Now let’s make the loop smarter.

count = 1

while count <= 5:
    print(count + 5, end=' ')
    count = count + 1

print(count)
print(count * 2)

Thinking Process

Instead of printing count, we print:

count + 5

So Python calculates:

count	count + 5
1	6
2	7
3	8
4	9
5	10

Output from Loop

6 7 8 9 10

What Happens After the Loop?

After the loop finishes:

count = 6

Because the loop stops only after count becomes greater than 5.

First Print

print(count)

Output:

Second Print

print(count * 2)

Python calculates:

6 * 2 = 12

Output:

Final Output

6 7 8 9 10
6
12

Common Beginner Mistakes

1. Forgetting Indentation

Python uses spaces to understand blocks.

Correct:

if a > b:
    print(a)

Wrong:

if a > b:
print(a)

2. Infinite Loops

If you forget:

count = count + 1

the loop runs forever.

3. Confusing = and ==

=   → assignment
==  → comparison

This mistake is extremely common for beginners.

Final Thoughts

Programming is not about memorizing syntax.

It is about:

observing problems,
thinking logically,
and breaking solutions into steps.

Conditional statements teach computers how to make decisions.

Loops teach computers how to repeat tasks efficiently.

Once you truly understand these concepts, you start thinking like a programmer.

And that is the real beginning of learning Python.

The Art of Reading Red JavaScript Errors Without Panicking

Kathirvel S — Sun, 24 May 2026 09:59:07 +0000

Welcome to Episode 4 of "Sunday Source".

Today’s villain?

Errors in the JavaScript Console.

That scary red text developers pretend they understand instantly.

And honestly, console errors are one of those things every developer eventually becomes friends with. Not because we want to… but because JavaScript forces us to.

At first, console errors feel intimidating.
You see giant red messages.
Random line numbers.
Weird terms like:

Uncaught TypeError

Unexpected token

And suddenly it feels like the browser is speaking another language.

But after enough broken projects, failed experiments, and late-night debugging sessions, you start realizing something important:

The console is actually trying to help you.

It’s not attacking you.

It’s reporting what went wrong.

And once you learn how to read those messages properly, debugging becomes less scary and more like solving small puzzles.

This episode is basically about turning those scary red errors into something understandable.

Because every developer reaches a point where the console stops being terrifying…

…and starts becoming useful.

The First Time the Console Destroyed My Confidence

I still remember writing something super simple:

console.log(userName)

I refreshed the page expecting magic.

Instead, the browser responded with this:

Uncaught ReferenceError: userName is not defined

At that moment, I had two thoughts:

“What is uncaught?”
“Why is JavaScript angry at me?”

And the funniest part?

I genuinely thought my browser was broken.

I refreshed the page multiple times like that would somehow fix my typo.

Spoiler:

It did not.

If you've ever opened DevTools and seen a wall of red messages, congratulations — you're officially coding.

The console is not your enemy.

It’s actually JavaScript trying very hard to tell you:

“Hey… something broke. Here’s where. Please fix it before users see this.”

And once you learn how to read console errors, debugging becomes way less terrifying.

The problem is that most developers initially treat errors emotionally instead of logically.

You see red text and immediately think:

“Everything is ruined.”

But most errors are actually small.

A typo.
A missing bracket.
A wrong variable name.
A file that didn’t load.

Tiny mistakes causing dramatic reactions.

Which honestly describes JavaScript perfectly.

What Even Is the JavaScript Console?

The console is like a live communication channel between your code and the browser.

Your browser logs:

errors
warnings
failed network requests
custom messages
debugging information

You can open it with:

Chrome / Edge

F12

Ctrl + Shift + I

Then go to the Console tab.

Now you can officially watch your bugs in real time.

Fun.

But the console is more powerful than most developers realize.

It’s not just a place where errors appear.

It’s also a testing environment.

You can run JavaScript directly inside the console.

Example:

2 + 2

The browser immediately responds:

You can inspect variables, test functions, manipulate the DOM, and debug logic without constantly editing files.

That’s why experienced developers spend a huge amount of time inside DevTools.

The browser console becomes part of your workflow.

And eventually, you stop fearing it.

You actually start depending on it.

Which sounds weird until your application breaks in production and the console becomes your only clue.

Official Definition

The JavaScript Console is a developer tool provided by web browsers that displays messages, warnings, errors, and debugging information generated by JavaScript code running on a webpage.

Why Console Errors Matter

Here’s the dangerous part:

Sometimes your website looks fine…

…but JavaScript is silently failing in the background.

Examples:

button clicks stop working
API data never loads
forms refuse to submit
animations freeze
entire components disappear

And the only place revealing the truth?

The console.

That tiny tab developers ignore until production catches fire.

One of the biggest misconceptions in web development is assuming:

“If the UI loads, everything works.”

Absolutely not.

Modern websites depend heavily on JavaScript.

A single failed script can break authentication, payments, search functionality, or user interactions while the page still visually appears normal.

That’s what makes debugging tricky.

Sometimes the failure is obvious.

Sometimes users discover it before developers do.

And those are the painful bugs.

Especially when the issue only happens on specific browsers, devices, or internet conditions.

The console helps expose those hidden problems before users start sending messages like:

“Hey… your website doesn’t work.”

Which is basically every developer’s least favorite notification.

The 5 Most Common JavaScript Console Errors

Let’s go through the errors almost every developer hits.

These are the “welcome to JavaScript” errors.

And the funny thing is…

You never completely escape them.

Even experienced developers still accidentally trigger these errors constantly.

The difference is they panic less now.

Mostly.

1. ReferenceError

Probably the most common one.

Example:

console.log(username)

But the variable was actually:

let userName = "John"

Console says:

ReferenceError: username is not defined

What this means

JavaScript looked for username.

It searched.

It suffered.

It found nothing.

The browser basically checked memory and said:

“I have absolutely no idea what this variable is.”

Official Definition

A ReferenceError occurs when JavaScript tries to access a variable or identifier that has not been declared or is not available in the current scope.

Why This Happens

Usually because of:

spelling mistakes
wrong variable names
variables used before declaration
scope issues

This error becomes extremely common in larger applications because variables move across multiple files, functions, and components.

One tiny naming mismatch can break everything.

And because JavaScript is case-sensitive:

userName

and

username

are completely different things.

Which feels rude sometimes.

How to Fix It

Check:

capitalization
spelling
whether the variable exists
where it’s declared

Because:

userName !== username

JavaScript is case-sensitive.

And yes, it absolutely cares.

One helpful habit is using editor autocomplete instead of manually typing variable names repeatedly.

It reduces stupid mistakes dramatically.

And trust me…

Most debugging sessions begin with a stupid mistake.

2. SyntaxError

This one means your code structure is invalid.

Example:

if (true {
  console.log("Hello")
}

Missing ).

Console:

SyntaxError: Unexpected token '{'

Official Definition

A SyntaxError occurs when JavaScript encounters code that does not follow the correct language syntax rules, preventing the script from being parsed and executed.

Why This Happens

Usually because of:

missing brackets
forgotten commas
extra parentheses
incorrect syntax

This error happens before your code even runs.

The browser tries reading your JavaScript file…

…and immediately gives up.

Think of it like broken grammar in a sentence.

If the structure is invalid, JavaScript cannot understand your instructions.

The Painful Part

One missing bracket can break an entire file.

You’ll spend 20 minutes debugging…

Only to discover this:

was missing.

Character development.

And somehow, the missing bracket is always hidden in the most invisible place possible.

Especially inside nested conditions.

Example:

if (loggedIn) {
  if (isAdmin) {
    console.log("Welcome")

Looks harmless.

Completely broken.

This is why proper indentation matters so much.

Good formatting literally prevents debugging pain.

3. TypeError

This happens when you try to use something incorrectly.

Example:

const user = null

console.log(user.name)

Console:

TypeError: Cannot read properties of null

Translation in Human Language

JavaScript is saying:

“You’re trying to access something that doesn’t exist.”

This usually happens when developers assume data is available before it actually is.

And modern web apps deal with async data constantly.

So this error appears everywhere.

Official Definition

A TypeError occurs when a value is used in an invalid way, such as trying to access properties or call methods on undefined or null.

Where This Happens A LOT

Especially when working with:

APIs
DOM elements
async data
arrays
forms

Example:

document.getElementById("btn").addEventListener(...)

But the button doesn’t exist yet.

Boom.

Error.

Another common situation:

The backend returns unexpected data.

You expect:

user.name

But the API responds with:

null

Now your frontend explodes.

And suddenly debugging becomes detective work.

How to Fix It

Check if the value exists first:

if (user) {
  console.log(user.name)
}

Or use optional chaining:

console.log(user?.name)

Tiny operator.

Massive peace of mind.

You can also use defensive coding habits where you assume external data might fail.

Because eventually…

It will.

4. Uncaught Promise Error

This one appears when async code fails.

Example:

fetch("/api/data")

If the request fails:

Uncaught (in promise)

Official Definition

An Uncaught Promise Error occurs when a Promise is rejected but the rejection is not properly handled using .catch() or try...catch.

Why This Feels Confusing

Because the error doesn’t happen immediately.

It happens later.

Which makes debugging feel like chasing a ghost.

Async JavaScript changes how errors behave.

Instead of failing instantly, operations happen in the background.

And when something breaks there, the error can feel disconnected from the original code.

That’s why async debugging initially feels confusing.

How to Handle It Properly

Use try...catch.

async function loadData() {
  try {
    const response = await fetch("/api/data")
    const data = await response.json()

    console.log(data)
  } catch (error) {
    console.error(error)
  }
}

Now instead of crashing silently, you actually control the error.

That’s a huge upgrade.

Good error handling becomes extremely important in real applications.

Because networks fail.

Servers crash.

Users lose internet connection.

APIs timeout.

And production apps must survive those failures gracefully.

5. Failed to Load Resource

This error usually means:

“The browser tried loading something and failed.”

Could be:

image
API
CSS file
JS file
font

Example:

Failed to load resource: 404

Official Definition

A Failed to Load Resource error occurs when the browser cannot successfully retrieve a requested file or resource from the server.

The Real Meaning of 404

Your browser went looking for a file…

…and the server basically said:

“Never heard of it.”

A 404 error means the requested resource does not exist at the specified location.

That resource could be:

an image
an API route
a JavaScript file
a CSS file
or an entire webpage

One wrong character in a file path is enough to trigger this error.

And sometimes the website still partially works, making the problem harder to notice immediately.

This is why developers constantly inspect both the Console and Network tabs together while debugging.

Official Definition

A 404 Not Found status code means the server was reached successfully, but the requested resource could not be found at the specified URL.

Also, I wrote a complete breakdown about HTTP status codes like 404, 403, 500, and other server mysteries here:

Every Developer’s Nightmare: Decoding 404, 403, 500, and Other HTTP Mysteries

If those numbers have ever confused you during debugging, that article explains them in a much deeper way.

Common Causes

wrong file path
typo in URL
deleted file
backend server not running

Sometimes developers rename files but forget updating import paths.

Sometimes frontend code requests an API endpoint that doesn’t exist anymore.

Sometimes the backend server simply isn’t running.

And sometimes…

You spend an hour debugging before realizing you typed:

/api/user

instead of:

/api/users

Pain.

The Biggest Mistake Developers Make

Seeing an error…

…and instantly searching:

how to fix uncaught promise javascript stackoverflow

Without actually reading the error.

Here’s the truth:

Most console errors literally tell you the problem.

Example:

Cannot read properties of undefined

That’s not cryptic.

That’s JavaScript directly telling you:

“Something is undefined. Stop pretending it exists.”

The real skill is learning to slow down and read carefully.

A lot of debugging mistakes happen because developers rush.

They assume.

They panic.

They randomly change code hoping something works.

But debugging improves dramatically once you start treating errors like clues instead of enemies.

The console usually gives:

the error type
the file name
the line number
and sometimes even the exact variable causing problems

That information is incredibly valuable.

How I Actually Debug Console Errors

Here’s my real process.

Not the fancy YouTube version.

Step 1 — Read the First Line

Not the entire stack trace.

Just the first meaningful line.

Example:

ReferenceError: user is not defined

That alone already tells you a lot.

Most developers get overwhelmed because they read the entire error dump immediately.

But usually the first line already identifies the core issue.

Focus there first.

Step 2 — Find the File and Line Number

Console usually shows:

app.js:42

Click it.

The browser takes you directly to the problem area.

This feature alone feels illegal sometimes.

And once you start using source maps and proper debugging tools, finding issues becomes much faster.

Modern browsers are honestly incredible debugging environments now.

Step 3 — Use `console.log()`

Yes.

Still.

Even experienced developers use it constantly.

Example:

console.log(user)
console.log(data)
console.log(response)

You’re basically interrogating your code.

You ask:

“What are you actually storing right now?”

And the console answers honestly.

Sometimes debugging is literally just printing values until reality makes sense again.

Step 4 — Isolate the Problem

Don’t debug the whole app.

Debug one thing.

Ask:

Is the variable undefined?
Is the API failing?
Is the element missing?
Is the function even running?

Debugging gets easier when you stop treating errors like mysteries.

Most bugs become manageable once you isolate the exact failing part.

Trying to debug everything at once only creates confusion.

The Console Is Actually a Teacher

This sounds dramatic, but it’s true.

Every console error teaches:

how JavaScript works
how browsers behave
how async code flows
how scope works
how DOM rendering works

The developers who improve fastest are usually the ones who debug the most.

Not the ones who memorize tutorials.

Because real learning usually happens after things break.

Not before.

Every bug forces you to understand something deeper about how the language actually behaves.

And over time, you stop fearing errors.

You start learning from them.

One Important Thing Nobody Tells You

Good developers still get console errors.

Daily.

The difference is:

Beginners panic.
Experienced developers investigate.

That’s it.

There’s no secret “I never get errors anymore” phase.

There’s only:

“I know how to find the problem faster now.”

Even senior developers spend hours debugging weird problems.

The difference is experience helps them narrow possibilities faster.

But nobody completely escapes bugs.

That’s just part of software development.

Honestly, if your console is perfectly clean all the time…

You’re probably not building enough things.

Final Thoughts

If your console is full of red text right now…

Good.

Seriously.

That means you’re building things.

Breaking things.

Learning things.

And that’s exactly what this series is about.

Sunday Source – I Break It, Then Explain It was never about perfect code.

It’s about understanding the mess after things explode.

And honestly?

JavaScript errors are one of the best teachers you’ll ever have.

The console can feel overwhelming initially.

But eventually, you realize those red messages are actually helping you improve.

Every confusing bug teaches patience.

Every debugging session improves problem-solving.

Every error slowly makes you better at understanding how software actually works behind the scenes.

And weirdly enough…

That’s one of the most satisfying parts of coding.

Before You Leave…

Quick question:

Which console error annoys you the most?

undefined
null
404
Unexpected token
Uncaught promise

Every developer has that one error that ruins their mood instantly.

Don't panic

At a time solve without panic

See you in Episode 5.

DEV Community: Kathirvel S

From Java Methods to Method Overloading: A Complete Beginner's Guide to Compile-Time Polymorphism

Introduction

Objects Access Non-Static Variables

Official Definition

Beginner-Friendly Explanation

Common Beginner Error

Objects Can Also Access Methods

Real-World Analogy

What Happens If the Method Does Not Exist?

Why Does This Error Occur?

What Exactly Is a Method?

Beginner-Friendly Definition

Creating Your First Method

Understanding Every Keyword in a Method

public

Official Meaning

Beginner-Friendly Meaning

void

Official Meaning

Beginner-Friendly Meaning

printActivity

Parentheses ()

Curly Braces {}

Return Types in Java

Why Does Java Need a Return Type?

Error: Missing Return Type

Why?

Understanding the return Keyword

Why Do We Use void?

Parameters and Arguments

Parameter

Argument

No-Argument Method

Error: Passing an Argument to a No-Argument Method

One-Parameter Method

Error: Missing Required Argument

Two-Parameter Method

Error: Passing One Argument Instead of Two

String Parameters

Error: Passing Wrong Data Type

Why Method Overloading Exists

Method Overloading

Official Definition

Rules of Method Overloading

What Is Compile-Time Polymorphism?

Why Is Method Overloading Called Compile-Time Polymorphism?

Final Summary

References

How to Find a Prime Number in Python — A Thinking Journey

Introduction

1. Understanding the Problem First

2. Thinking Like a Human Before Coding

3. Turning Thinking into a Basic Algorithm

4. First Working Logic (Direct Implementation)

5. Understanding What Happens Here

6. The Problem With This Approach

7. Introducing Functions in Python

8. Simple Example to Understand Functions

9. Understanding the return Keyword

10. Converting Prime Logic into a Function

11. Understanding This Function

12. Using the Function (But Still Not Efficient)

13. The Problem Again

14. Using a Loop to Remove Repetition

15. What Changed Here

16. Final Improved Version (Cleaner Logic)

17. Final Understanding

18. Key Learning Path

Conclusion

Static vs Non-Static in Java: Understanding Class and Object Through a Shop Story

Meet Our Java Shop

What Is a Class?

Why Do We Need Classes?

What Is an Object?

Why Do We Need Objects?

The Most Important Line in Java

Step 1: Shop

Step 2: s1

Step 3: new

Step 1: `Shop`

Step 2: `s1`

Step 3: `new`

Step 4: `Shop()`

The Secret Weapon: `%` Modulus Operator