DEV Community: Sivakumar Mathiyalagan

Platform Architecture of Programming Languages

Sivakumar Mathiyalagan — Fri, 26 Jun 2026 05:42:52 +0000

JAVA

Java Development Kit(JDK):

This kit provides all required tools and libraries to develop java program this contains

JDK
├── JRE
│ ├── JVM
│ └── Libraries
└── Development tools

Development Tools helps to develop and to compile code
where java code is translated to byte code and class file is created

Java Runtime Environment(JRE):

he JRE contains the core Java libraries that your program needs at runtime

The JVM(Java Virtual Machine) inside the JRE executes the bytecode. It may interpret it or compile frequently used code to machine code using the Just-In-Time (JIT) compiler.

JavaScript

JavaScript's architecture is different from Java because it doesn't have separate JDK, JRE, and JVM components. Instead, it consists of a runtime and a JavaScript engine

JavaScript Development Environment

Developers typically use:

Node.js (for server-side development)
npm (package manager)
Build tools like Vite, Webpack, Babel, or TypeScript (optional)
JavaScript Runtime

The runtime is the environment where JavaScript executes.

Examples:

Browser (Chrome, Firefox, Safari, Edge)
Node.js
JavaScript Engine

The engine is responsible for executing JavaScript code.

Examples:

V8 – Chrome and Node.js
SpiderMonkey – Firefox
JavaScriptCore – Safari

Python

Python's architecture is closer to Java's than JavaScript's because it also compiles source code into bytecode, which is then executed by a virtual machine.

          Python Source (.py)
                   │
                   ▼
          Python Interpreter
                   │
      Compiles to Bytecode (.pyc)
                   │
                   ▼
     Python Virtual Machine (PVM)
                   │
         Executes Bytecode
                   │
                   ▼
             Machine Code
                   │
                   ▼
            Operating System

Python Interpreter changes the python code to byte code then Python Virtual machine executes byte code to machine code

Java - Object Oriented Programming

Sivakumar Mathiyalagan — Thu, 25 Jun 2026 05:23:42 +0000

What is Object Oriented programming ?

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of objects that contain data (fields) and behavior (methods). It focuses on designing software that closely represents real-world entities. It is used to:
- Improves code reusability
- Enhances maintainability and scalability
- Makes programs easier to understand and manage
- Closely models real-world entities

Characteristics of OOP:

Characteristic	Description
Class	Blueprint for objects
Object	Instance of a class
Encapsulation	Data hiding and protection
Abstraction	Hiding implementation details
Inheritance	Acquiring properties from another class
Polymorphism	One interface, multiple behaviors

Class:
A class is a user-defined blueprint or template used to create objects. It defines the data (attributes) and behavior (methods) that objects of that class will have.

Think of a class as a design or blueprint, and an object as the actual thing built from that blueprint.

Object
An object is an instance of a class. It is a real entity created from the blueprint (class) and occupies memory during program execution.

Class = Blueprint/Template
Object = Actual thing created from that blueprint

Inheritance
Inheritance is an OOP mechanism that allows one class to acquire the properties (fields) and behaviors (methods) of another class.

It promotes code reusability because common features are written once in a parent class and reused by child classes.

Programming Paradigms

Sivakumar Mathiyalagan — Thu, 25 Jun 2026 05:14:11 +0000

A programming paradigm is a method or style of solving problems using a programming language. It provides a structured approach and set of principles that guide how programs are designed and implemented
Different programming paradigms use different techniques and strategies to solve software development problems efficiently.
A programming language may support one or more paradigms, allowing developers to choose the best approach based on project requirements.

Types of programming paradigms
1. Imperative Programming Paradigm
2. Declarative programming paradigm

1.Imperative Programming Paradigm:
Imperative programming is one of the oldest programming paradigms and is closely related to machine architecture and Von Neumann architecture. It works by changing the program state through assignment statements and executes tasks step-by-step to achieve the desired result.
Object oriented programming
Parallel processing approach

Object oriented programming
The program is written as a collection of classes and object which are meant for communication. The smallest and basic entity is object and all kind of computation is performed on the objects only

Parallel processing approach
Parallel processing is the processing of program instructions by dividing them among multiple processors. A parallel processing system posses many numbers of processor with the objective of running a program in less time by dividing them

2. Declarative programming paradigm
Declarative programming is a programming style that focuses on what needs to be done rather than how to do it. It expresses the logic of computation without describing the step-by-step control flow of the program
Functional programming paradigms
Data driven programming approach

Functional programming paradigms
Functional programming is a paradigm based on mathematical functions where computation is performed through the execution of functions. It focuses on using functions for specific tasks while keeping data loosely coupled and minimizing changes in program state

Data driven programming approach
Database or data-driven programming focuses on data and its movement rather than hard-coded program steps. In this approach, program behavior is controlled by data operations such as storage, retrieval, filtering, and reporting

Interview Question - Technical

Sivakumar Mathiyalagan — Wed, 24 Jun 2026 05:33:06 +0000

Question:

There are N light bulbs, all initially turned OFF (0).

You are given K operations, where each operation is represented as a range [L, R].

For each operation, you must toggle the state of all bulbs in the range:

If a bulb is 0 (OFF), turn it 1 (ON)
If a bulb is 1 (ON), turn it 0 (OFF)

CODE

         let n = 5
         let k = 2
         let operations = [[1,3],[2,4]]

         const arrN = new Array(n).fill(0);
         console.log(arrN);

         for(let i=0;i<k;i++){
            let[start,end] = operations[i]
            console.log(start,end)
            for(let j=start-1;j<end;j++){
                if(arrN[j]===0){
                    arrN[j]=1;
                }
                else{
                    arrN[j] = 0;
                }
            }
         }

         console.log(arrN)

OUTPUT

Java is a case sensitive and structured program

Sivakumar Mathiyalagan — Wed, 24 Jun 2026 05:26:11 +0000

Class name case-sensitive error

main method spelling/case error

System case error

Missing semicolon

Missing braces

Finding the given word

Sivakumar Mathiyalagan — Wed, 24 Jun 2026 05:06:12 +0000

Question:
In this sentence 'My favourite cricketer is Dhoni, Kohli and Rohit' find the word 'Dhoni'

Code:

word = 'My favourite cricketer is Dhoni, Kohli and Rohit'
key = 'dhoni'
word = word.lower()

key_length = len(key)
print(key_length)
word_length = len(word)

for i in range(word_length):
    if key == word[i:i+key_length]:
        print('found')
        break

else :
   print("not found")

Output:

Exercise python

Sivakumar Mathiyalagan — Mon, 15 Jun 2026 05:17:57 +0000

Two numbers are said to be amicable numbers if the sum of the factors of one number (except the number itself) gives the other number.
The numbers 220 and 284 are amicable, since the sum of the factors of 220 (except 220)

Check whether 1184 and 1210 are amicable numbers.

num1 = 1184
num2 = 1210

def sumOfFactor (num):
    divisor = 2
    sum = 1
    while divisor <= num//2:
        if num%divisor == 0:
            sum = sum + divisor
        divisor+=1
    return sum


if sumOfFactor(num1) == sumOfFactor(num2):
    print (sumOfFactor(num1), "is amicable to",sumOfFactor(num2))
else:
    print (sumOfFactor(num1), "is not amicable to",sumOfFactor(num2))

A book seller has 175 English books, 245 Science books and 385 Mathematics books. He wants to sell the books in a box, subject-wise in equal numbers. What will be the greatest number of the boxes required? Also find the number of books for each subject
in a box.

english = 175
science = 245
maths = 385
hcf = 0
divisor = 2

while divisor < maths//2:
    if(english%divisor==0 and science%divisor==0 and maths%divisor==0):
        hcf = divisor
    divisor+=1

englishBooks = english // hcf
scienceBooks = science // hcf
mathsBooks = maths // hcf

print("no of boxes required is", hcf, "and no of books in each box to be", "English-books",englishBooks, "Science-books",scienceBooks,"Maths-books", mathsBooks)

python-exercises

Sivakumar Mathiyalagan — Fri, 12 Jun 2026 14:58:05 +0000

# smallest four digit prime number


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

givenNumber = 1000

while givenNumber >= 1000:
    if (find_prime(givenNumber)):
        print("smallest prime number", givenNumber)
        break
![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8uc0afb1lvycntrath2t.png)
    givenNumber = givenNumber+1

# Write the smallest and the Largest two digit prime number

givenNumber = 100
start = 10

while start < givenNumber:
    if (find_prime(start)):
        print("smallest prime number", start)
        break
    start = start+1

while givenNumber > start:
    if(find_prime(givenNumber)):
        print("largest prime number", givenNumber)
        break
    givenNumber = givenNumber - 1

# I am a two digit prime number and the sum of my digits is 10. I am also one of the factors of 57. Who am I?

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

start = 10


while start < 100:
    if (find_prime(start)):
        sum =0
        sum = sum + start % 10 + start // 10
        if(sum ==10 and  57 % start == 0):
            print("i am that two digit number",start)
            break
    start = start+1

python-exercise

Sivakumar Mathiyalagan — Thu, 11 Jun 2026 14:32:18 +0000

# print 34 23 12

givenNumber = 342312

while givenNumber > 0:
    print (givenNumber % 100)
    givenNumber = givenNumber // 100

# print 34 12

givenNumber = 342312

print (givenNumber % 100)
print (givenNumber//10000)

# print  sum of 34 23 12

givenNumber = 342312

while givenNumber > 0:
    num = (givenNumber % 100)
    sum = 0
    while num > 0:

        sum = sum + num % 10
        num = num//10
    print(sum)
    givenNumber = givenNumber//100

#  print sum of  34 12

givenNumber = 342312

num = givenNumber % 100
num2 = givenNumber//10000
sum = 0
while num > 0:
    sum = sum + num % 10
    num = num//10
print(sum)
sum = 0
while num2 > 0:
    sum = sum + num2 % 10
    num2 = num2//10
print(sum)

# Task5: given number 123456 --> 456 123

givenNumber = 123456

print(givenNumber % 1000)
print (givenNumber // 1000)

Check Divisibility - Python

Sivakumar Mathiyalagan — Wed, 10 Jun 2026 04:40:22 +0000

# divisible by 11

num = 135802467913580246790
val1 = 0
val2 = 0


while num > 0:

    total = num % 100
    val1 = val1 + total % 10
    val2 = val2 + total // 10

    num = num//100

if (val1 - val2) % 11 == 0:
    print("divisible by 11")
else:
    print("not divisible by 11")

# divisible by 2

num = 135802467913580246790

value = num%10

if value % 2 == 0:
    print("divisible by 2")
else:
    print("Not divisible by 2")

# divisible by 3

num = 135802467913580246790  
sum = 0

while num > 0:
    sum = sum + num % 10
    num = num // 10

if sum % 3 == 0:
    print("divisible by 3")
else:
    print("not divisible by 3")

# divisible by 5
num = 135802467913580246790

value = num%10

if value == 0 or value == 5:
    print("divisible by 5")
else:
    print("Not divisible by 5")

# divisible by 4

num = 135802467913580246790

value = num%100

if value % 4 == 0:
    print("divisible by 4")
else:
    print("Not divisible by 4")

# divisible by 6

num = 135802467913580246790

value = num%10

sum = 0

while num > 0:
    sum = sum + num % 10
    num = num // 10

if value % 2 == 0 and sum % 3 == 0:
      print("divisible by 6")
else:
    print("Not divisible by 6")

# divisible by 8

num = 135802467913580246790

value = num%1000

if value % 8 == 0:
    print("divisible by 8")
else:
    print("Not divisible by 8")

# divisible by 9

num = 135802467913580246790  
sum = 0

while num > 0:
    sum = sum + num % 10
    num = num // 10

if sum % 9 == 0:
    print("divisible by 9")
else:
    print("not divisible by 9")

# divisible by 10

num = 135802467913580246790

value = num%10

if value == 0:
    print("divisible by 10")
else:
    print("Not divisible by 10")

Python-Exercise

Sivakumar Mathiyalagan — Sat, 06 Jun 2026 08:21:41 +0000

CODE

# print [1 1 1 1 1]

count = 0
i = 5

while count < i:
    print ("1" ,end=" ")
    count = count+1



# print [1 2 3 4 5]

count = 1
i = 5

while count <= i:
    print (count ,end=" ")
    count = count+1



# print [1 3 5 7 9]

count = 1
i = 10

while count < i:
    print (count ,end=" ")
    count = count+2



# print [3 6 9 12 15]

count = 1
i = 5

while count <= i:
    print (count * 3 ,end=" ")
    count = count+1


# print [15 12 9 6 3]

count = 5
i = 1

while count >= i:
    print (count * 3 ,end=" ")
    count = count-1



# print [10 8 6 4 2]

count = 5
i = 1

while count >= i:
    print (count * 2 ,end=" ")
    count = count-1



# print [9 7 5 3 1]

count = 9
i = 1

while count >= i:
    print (count ,end=" ")
    count = count-2



# print Multiples of 3 and 5

max = 100
start = 1

while start <= max:
    if start % 3 == 0 and start % 5 == 0:
        print (start)
    start = start + 1   



#  print Multiples of 3 or 5

max = 100
start = 1

while start <= max:
    if start % 3 == 0 or start % 5 == 0:
        print (start)
    start = start + 1  



# print the divisors of given number

givenNumber = 25
start = 1

while start <= givenNumber:
    if givenNumber % start == 0:
        print (start)
    start+=1



# count the divisors of given number

givenNumber = 25
start = 1
total = 0

while start <= givenNumber:
    if givenNumber % start == 0:
        total += 1
    start+=1

print(total)



# check for perfect number

givenNumber = 498
start = 1
total = 0

while start < givenNumber:
    if givenNumber % start == 0:
       total = total + start
    start += 1 

if total == givenNumber:
    print("perfect number")
else :
    print ("not a perfect number")



# print [1 3 5 7 9 2 4 6 8 10]

count = 1

while count <= 10:
    if count <= 5:
        print(2 * count - 1, end=" ")
    else:
        print(2 * (count - 5), end=" ")
    count += 1




# factorial of given number

givenNumber = 4
total = 1

while givenNumber >= 1:
    total = total * givenNumber
    givenNumber -= 1
print (total)




# sum of first n numbers

givenNumber = 5
total = 0

while givenNumber >= 1:
    total = total + givenNumber
    givenNumber -= 1
print (total)


# print first five prime number

givenNumber = 25
start = 1
total = 0

while start <= givenNumber and total < 5:
    newStart = 1
    count = 0

    while newStart <= start:
        if start % newStart == 0:
            count += 1
        newStart +=1

    if count == 2:
        print(start)
        total += 1

    start +=1



# print sum of first five prime number

givenNumber = 100
start = 50
total = 0
primeTotal = 0

while start <= givenNumber and total < 5:
    newStart = 1
    count = 0

    while newStart <= start:
        if start % newStart == 0:
            count += 1
        newStart +=1

    if count == 2:
        primeTotal = primeTotal + start
        total += 1

    start +=1

print(primeTotal)

OUTPUT

useReducer - React

Sivakumar Mathiyalagan — Fri, 05 Jun 2026 04:06:20 +0000

useReducer:

useReducer is a React Hook used to manage complex state logic in your components. It is often described as a more powerful alternative to useState, particularly when the next state depends on the previous one or when you have multiple related state values that need to change together.

Syntax:

const [state, dispatch] = useReducer(reducer, initialArg, init?)

Reference:

reducer: The reducer function that specifies how the state gets updated. It must be pure, should take the state and action as arguments, and should return the next state. State and action can be of any types.

initialArg: The value from which the initial state is calculated. It can be a value of any type. How the initial state is calculated from it depends on the next init argument

optional init: The initializer function that should return the initial state. If it’s not specified, the initial state is set to initialArg. Otherwise, the initial state is set to the result of calling init(initialArg)(TBD)

dispatch: The dispatch function returned by useReducer lets you update the state to a different value and trigger a re-render. You need to pass the action as the only argument to the dispatch function

state: It holds the initial value and changes the value accordingly when the dispatch function executes

Code:

import React from "react";
import { useReducer } from "react";

function Counter(){


    function counterReducer(state,action){
        switch (action.type) {
            case "Increment" :
                return {count : state.count + 1}
            case "Decrement" :
                return {count : state.count - 1}   
            case "Reset" :
                return {count : 0}     
        }
    }

    const [state,dispatch] = useReducer(counterReducer,{count : 0})

    return(
        <>
        <h1>{state.count}</h1>
        <button onClick={()=>dispatch({type:"Increment"})}>Increment</button>
        <button onClick={()=>dispatch({type:"Decrement"})}>Decrement</button>
        <button onClick={()=>dispatch({type:"Reset"})}>Reset</button>
        </>
    )
}

  export default Counter

Output: