Forem: SILAMBARASAN A

Client Server Architechture

SILAMBARASAN A — Mon, 13 Apr 2026 04:53:35 +0000

The main idea — Clients ask. Servers give. They each have one job.
Client — your phone, laptop, or app. It asks for things — like when you tap a link or open Instagram. It doesn't store anything big. It just shows you what the server sends back.
Server — a big, always-on computer somewhere. It listens for requests, does the work, and sends back the answer. It talks to hundreds of people at the same time.
How it works, step by step:

You click a link → your browser asks the server "give me this page"
The server gets the request, looks up the data it needs
The server sends the page back to you
Your browser shows it on screen

Why it's a good system:

One place for data — everything is saved on the server, not scattered across everyone's devices. Easy to keep safe and up to date.
Can grow easily — if too many people use it at once, you just add more servers.
Each side does its own thing — your device handles what you see, the server handles what happens behind the scenes.

User side is everything that runs on your device — your browser or app, the screen you see, and a tiny bit of temporary storage (like saved passwords or cookies). It sends requests and displays whatever the server sends back. It does not make big decisions or store important data.

Server side is everything running on a remote computer — it receives your request, checks who you are (authentication), runs the rules (business logic), talks to the database, and sends back a clean response.

System Software and Application Software

SILAMBARASAN A — Sun, 12 Apr 2026 02:38:10 +0000

SYSTEM SOFTWARE :

System software is software that helps to operate and control a computer.

system software is helps to the computer (CPU, RAM, etc.) to work properly.

system software is providing a platform for application software to run on.

Types of System Software

Operating system(os) --> the core system software (e.g., Windows, macOS, Linux, Android). It manages the CPU, memory, storage, and input/output devices, and provides a user interface.

Device Drivers --> small programs that allow the OS to communicate with hardware components like printers, graphics cards, and keyboards.

Utility Software --> tools that help maintain, optimize, or protect the system. Examples include antivirus programs, disk cleanup tools, and file managers.

Firmware --> low-level software permanently embedded in hardware (e.g., BIOS/UEFI in a motherboard), responsible for booting the system.

Language Translators --> compilers, interpreters, and assemblers that convert programming code into machine-readable instructions.

APPLICATION SOFTWARE :

Application software (also called apps or programs) is software designed to help users perform specific tasks. It runs on top of system software (the OS) and directly interacts with the user.

Types of Application Software

Word Processing Software
Used to create and edit documents.
Examples: Microsoft Word, Google Docs, LibreOffice Writer
Presentation Software
Used to create slideshows and visual presentations.
Examples: Microsoft PowerPoint, Google Slides, Canva
Database Software
Used to store, manage, and retrieve data.
Examples: MySQL, Microsoft Access, Oracle
Web Browsers
Used to access and browse the internet.
Examples: Google Chrome, Firefox, Safari
Communication Software
Used for messaging, email, and video calls.
Examples: Gmail, WhatsApp, Zoom, Microsoft Teams

About Me

SILAMBARASAN A — Thu, 09 Apr 2026 17:58:57 +0000

myself silambarasan, from guindy, and my native is thiruvannamalai,
I have completed my BSC computer science at kgc chennai in 2025.

I am a quick learner and highly interested in learning new technologies, especially in programming. I have knowledge in HTML, CSS, JavaScript, and React.

I have worked on small projects using React, such as a portfolio website, a quiz application, and a simple e-commerce application. These projects helped me improve my front-end development and problem-solving skills.

I am currently working every day to improve my technical skills, and my goal is to start my career as a software developer where I can apply my knowledge and grow professionally.

What is ASCII Code?

SILAMBARASAN A — Thu, 09 Apr 2026 03:42:00 +0000

ASCII means American Standard Code for Information Interchange.

It is a system that changes letters, numbers, and symbols into numbers, so computers can understand them.

Examples:

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

Computers cannot understand text directly
They understand only numbers

So, ASCII helps convert characters into numbers.

Why was ASCII introduced?

Before ASCII, each computer had its own way of storing characters

This created problems when sharing data between computers.

Problems before ASCII:

Different systems used different codes
Same character had different meanings
Data sharing was difficult

Solution: ASCII

ASCII was introduced to:

Standardize characters
- Same number for same character everywhere
Make data sharing easy
- Files can be opened in different systems
Improve communication
- Helpful in early internet and networking

ASCII range = 0 to 127

0–31 → Control characters
32–126 → Printable characters
127 → Delete

Printable Characters (32–126)

These are visible characters:

32 → Space
48–57 → Numbers (0–9)
65–90 → Uppercase letters (A–Z)
97–122 → Lowercase letters (a–z)
Others → Symbols (!, @, #, etc.)

ASCII PROGRAM :

name="silambu9391a@gmail.com"
index=0
while (index < name.length) {
    console.log(name[index]+ " = " + name.charCodeAt(index));
    index+=1
}

OUTPUT :

Method Overloading in Java

SILAMBARASAN A — Wed, 08 Apr 2026 19:04:08 +0000

Introduction

In Java, method overloading is a concept where you can define multiple methods with the same name but different parameters in the same class.

It is one of the important features of compile-time polymorphism.

Method overloading means creating multiple methods with the same name but different parameter lists and diffrent data type.

Why Do We Need Method Overloading?

Imagine you want to perform the same operation (like addition) with different inputs:

Add 2 numbers
Add 3 numbers
Add decimal numbers

Instead of using different method names, we can use one method name.

class Calculator {

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

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

    // Method 3
    double add(double a, double b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator obj = new Calculator();

        System.out.println(obj.add(10, 20));        // 30
        System.out.println(obj.add(10, 20, 30));    // 60
        System.out.println(obj.add(5.5, 2.5));      // 8.0
    }
}

How Java Decides Which Method to Call

Java checks based on:

Number of parameters
Type of parameters
Order of parameters

This happens at compile time.

Rules of Method Overloading

✔ Method name must be same
✔ Parameters must be different (type / number / order)

Return type alone is NOT enough

int add(int a, int b)
double add(int a, int b) // Not allowed

Real-Life Example

Think like a remote control

Same button → "Volume"
But action changes:
- Press once → increase little
- Hold → increase continuously

Same name, different behavior = Overloading

What is a Constructor ?

SILAMBARASAN A — Wed, 08 Apr 2026 18:15:30 +0000

Introduction

In JavaScript, a constructor is a special function or method used to create and initialize objects. Whenever you want to create multiple objects with similar structure, constructors help you do it easily and efficiently.

Why Do We Need Constructors?

Without constructors, you would have to manually create objects like this:

let student1 = { name: "Silambu", age: 21 };
let student2 = { name: "sanjay", age: 22 };

This becomes repetitive and messy when creating many objects.

Constructors solve this problem by providing a template (blueprint).

Constructor Using Class (Modern Way)

class Student {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
}

let s1 = new Student("Silambu", 21);
console.log(s1);

Output:

{ name: "Silambu", age: 21 }

How It Works Internally

When you write:

let s1 = new Student("Silambu", 21);

JavaScript does the following steps:

Creates an empty object { }
Sets this to point to that object
Calls the constructor function
Assigns values (name, age)
Returns the object

Concepts

constructor()

Special method inside a class
Runs automatically when object is created

this

Refers to the current object
Used to assign values

new keyword

Creates object
Calls constructor

Constructor Function (Old Way)

Before ES6, constructors were written like this:

function Student(name, age) { 
    this.name = name; 
    this.age = age; 
} 

let s1 = new Student("Silambu", 21);

This still works, but modern JS prefers class syntax.

Return Types in Java

SILAMBARASAN A — Tue, 07 Apr 2026 18:43:13 +0000

What is a Return Type?

In Java, a return type means the type of value a method gives back after execution.

Syntax :

returnType methodName() {
    // code
    return value;
}

Types of Return

1. void (No return value)

Method does not return anything

class Demo {
    void display() {
        System.out.println("Hello");
    }
}

Use: When you just want to print / perform action

2. Return with value (int, String, etc.)

Method returns a value

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

Calling:

int result = add(10, 20);
System.out.println(result); // 30

3. String return type

class Demo {
    String getName() {
        return "Silambu";
    }
}

4. Boolean return type

class Demo {
    boolean isEven(int n) {
        return n % 2 == 0;
    }
}

Flow of Execution

Let’s understand step-by-step:

Example:


class Demo {

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

    public static void main(String[] args) {
        Demo obj = new Demo();
        int result = obj.add(5, 3);
        System.out.println(result);
    }
}

Flow:

Program starts from main()
Object is created → Demo obj = new Demo();
Method call happens → obj.add(5, 3)
Control goes to add() method
Calculation happens → 5 + 3 = 8
return 8 → value goes back to main()
Stored in result
Printed → 8

void → no return
Other types (int, String, etc.) → must use return
Return value goes back to caller method
Execution always starts from main()

Return type in Java defines what type of value a method returns after execution.

String Operations

SILAMBARASAN A — Tue, 07 Apr 2026 17:50:01 +0000

What is a String ?

A string is a sequence of characters (letters, numbers, symbols, spaces, etc.) enclosed within quotes.

In simple words:
Text data = String

How to create a string

You can use:

Single quotes ' '
Double quotes " "
Triple quotes ''' ''' or """ """ (for multi-line)


name = "Silambu"
city = 'Chennai'
msg = """This is
multiple line string"""

String is immutable → you cannot change characters directly
Each character has an index (position)

text = "Python"

print(text[0])  # P
print(text[1])  # y

Common string operations

name = "silambu"

print(name.upper())      # SILAMBU
print(name.capitalize()) # Silambu
print(name.lower())      # silambu
print(len(name))         # 7
print("My name is " + name) #My name is Silambu

Both first & last letter capital

name = "silambu"

result = name[0].upper() + name[1:-1] + name[-1].upper()

print(result)

Output: SilambU

First letter → name[0].upper()
Last letter → name[-1].upper()

Understanding Methods in Java

SILAMBARASAN A — Tue, 07 Apr 2026 05:57:39 +0000

When you write a Java program, you quickly run into a problem — you end up writing the same lines of code over and over. Methods solve this. Think of a method as a named block of code that you write once and can run as many times as you want.

What is a method?

A method is a reusable block of instructions that performs a specific task. Instead of repeating code, you give that code a name and call it whenever you need it.

Types of Methods in Java

Understanding Predefined and User-defined methods using a real Calculator example.

Java methods come in two flavors. Some are already built into Java — you just use them. Others you write yourself to solve your specific problem. Let's understand both using a Calculator program.

1. Predefined Methods

These are methods that Java has already written for you. They live inside Java's built-in libraries. You don't need to define them — just call them directly.

Look at this line inside our Calculator example:

System.out.println(a + b);

println() is a predefined method. Java wrote it. You simply use it to print something to the screen. You never had to define how printing works — Java handles it internally.
More predefined method examples

// Math class predefined methods
int big = Math.max(10, 5);        // → 10
double root = Math.sqrt(25);     // → 5.0
int abs = Math.abs(-7);          // → 7

// String class predefined methods
"hello".toUpperCase();          // → "HELLO"
"Java".length();                 // → 4

2. User-defined Methods

These are methods you write to perform tasks specific to your program. In our example, add(), sub(), multiply(), and div() are all user-defined methods.

The full Calculator example

public class Calculator {

    public static void main(String[] args) {
        Calculator casio = new Calculator();  // create object

        casio.add(10, 5);       // calls user-defined method
        casio.sub(10, 5);       // calls user-defined method
        casio.multiply(10, 5); // calls user-defined method
        casio.div(10, 5);       // calls user-defined method
    }

    // User-defined method: add
    void add(int a, int b) {
        System.out.println(a + b);
    }

    // User-defined method: sub
    void sub(int a, int b) {
        System.out.println(a - b);
    }

    // User-defined method: multiply
    void multiply(int a, int b) {
        System.out.println(a * b);
    }

    // User-defined method: div
    void div(int a, int b) {
        System.out.println(a / b);
    }
}

OUTPUT :

Global vs local variables in Java

SILAMBARASAN A — Mon, 06 Apr 2026 11:02:33 +0000

When you write Java code, every variable has a home — a place where it lives and can be used. That home is called its scope. Today we'll learn about two kinds of variable homes: global and local.

Local variable — lives inside a method

A local variable is created inside a method. It only exists while that method is running. Once the method finishes, the variable disappears.

Think of it like this: A local variable is like a sticky note you write during a meeting. Once the meeting ends, you throw it away.

public class MyClass {

    public void sayHello() {

        String name = "Ravi";  // local variable

        System.out.println("Hello " + name);
    }
    // name is gone here — outside the method
}

The variable name is only usable inside sayHello(). Try to use it anywhere else and Java will give you an error.

Local variable

Written inside a method
Only that method can use it
Dies when method ends
Must be given a value first
No default value

Global variable — lives inside the class

A global variable (also called an instance variable) is created inside the class but outside any method. All methods in that class can see and use it.

Think of it like this: A global variable is like a whiteboard in the office. Everyone in the room can read it and write on it at any time.

public class MyClass {

    String name = "Ravi";  // global (instance) variable

    public void sayHello() {
        System.out.println("Hello " + name);  // ✓ works
    }

    public void sayBye() {
        System.out.println("Bye " + name);    // ✓ also works
    }
}

Global variable

Written inside the class
Outside any method
All methods can use it
Lives as long as the object
Gets a default value (0, null)

Both methods can use name because it's declared at the class level.

See both together

Here's a simple example that shows both in one class:

public class Student {

    String studentName = "Priya";  // global — all methods can use this

    public void showMarks() {
        int marks = 95;               // local — only lives inside showMarks()
        System.out.println(studentName + " scored " + marks);
    }

    public void showName() {
        System.out.println(studentName); // ✓ global, works fine
        // System.out.println(marks);   ✗ ERROR — marks is not here!
    }
}

SCRIPTING LANGUAGE VS PROGRAMMING LANGUAGE

SILAMBARASAN A — Mon, 06 Apr 2026 06:28:07 +0000

Scripting Language vs Programming Language

In the world of software development, you might often hear the terms scripting language and programming language. While they may seem similar, they serve different purposes and are used in different scenarios.

Let’s break it down in a simple way

What is a Programming Language?

A programming language is used to build complete software applications from scratch.

These languages are typically compiled and give full control over system resources.

Examples:

C
C++
Java
Rust

Features:

Needs compilation before execution
Faster performance
Used for system-level programming
More complex to learn

Use Cases:

Operating systems
Game development
Desktop applications

What is a Scripting Language?

A scripting language is used to automate tasks or control other software.

These languages are usually interpreted, meaning they run line-by-line without compilation.

Examples:

Python
JavaScript
PHP
Bash

Features:

No compilation needed
Easier to write and learn
Slower compared to compiled languages
Used for automation and quick tasks

Use Cases:

Web development
Automation scripts
Data analysis
Backend services

EMIRP

SILAMBARASAN A — Sun, 05 Apr 2026 14:00:15 +0000

Emirp Number – Explanation

What is an Emirp Number?

An Emirp number is a special type of prime number.

Conditions:

The number itself must be prime
Its reverse must also be prime
The reversed number should be different from the original

Example:

17 → Prime
Reverse (71) → Prime
17 ≠ 71 → Valid Emirp

So, 17 is an Emirp number

PYTHON :

def prime(no):
    div=2
    while div < no/2:
        if no % div == 0:
            return False
        div += 1
    return True

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

num = 17

if prime(num) and prime(reverse(num)):
    print(num, "is emirp")
else:
    print(num, "is not emirp")

Start
↓
Take number (17)
↓
Check if prime → YES
↓
Reverse number → 71
↓
Check reverse is prime → YES
↓
Both true → Emirp number
↓
End

JAVA SCRIPT CODE :

function prime(no) {
    let div = 2;

    while (div < no / 2) {
        if (no % div === 0) {
            return false;
        }
        div++;
    }
    return true;
}

function reverse(no) {
    let rev = 0;

    while (no > 0) {
        rev = rev * 10 + (no % 10);
        no = Math.floor(no / 10);
    }
    return rev;
}

let num = 17;

if (prime(num) && prime(reverse(num))) {
    console.log(num + " is emirp");
} else {
    console.log(num + " is not emirp");
}

JAVA CODE :

public class EmirpNumber {

    // Function to check prime
    static boolean prime(int no) {
        int div = 2;

        while (div < no / 2) {
            if (no % div == 0) {
                return false;
            }
            div++;
        }
        return true;
    }

    // Function to reverse number
    static int reverse(int no) {
        int rev = 0;

        while (no > 0) {
            rev = rev * 10 + (no % 10);
            no = no / 10;
        }
        return rev;
    }

    public static void main(String[] args) {
        int num = 17;

        if (prime(num) && prime(reverse(num))) {
            System.out.println(num + " is emirp");
        } else {
            System.out.println(num + " is not emirp");
        }
    }
}