DEV Community: Arul .A

useReducer in React?

Arul .A — Wed, 10 Jun 2026 15:47:00 +0000

React provides several hooks to manage in functional components.One of the mostly used hook in react.
It is used in mostly when the state management is complex.

What is useReducer?

Usereducer is a react hook that manages state using reducer function .Instead of update state directly,using dispatch action describe what should happen ,and the reducer decides how the state changes.

Syntax :

const [state, dispatch] = useReducer(reducer, initialState);

state – Current state value.
dispatch – Function used to send actions.
reducer – Function that updates the state.
initialState – Initial value of the state.

Why use useReducer?

While useState is perfect for simple state updates, useReducer is better when:

1.State contains multiple values.
2.State update logic is complex.
3.Multiple actions affect the same state.
4.You want cleaner and more organized code.

Why Java?

Arul .A — Tue, 09 Jun 2026 14:33:07 +0000

Java

Java is an Object-Oriented Programming (OOP) language.
It is platform-independent, following the principle "Write Once, Run Anywhere (WORA)".
It is highly secure and is widely used in banking, enterprise, and business applications.
Java is robust because of its strong error handling and memory management features.
Java has a large community with a huge number of libraries, frameworks, and learning resources.

Where Java is Used

Enterprise Applications
Banking Systems
E-commerce Websites
Backend APIs
Desktop Applications

Applications Built Using Java

Netflix
Spotify
Uber
Twitter
LinkedIn
NASA World Wind

What Are JavaScript Libraries and Frameworks?

Arul .A — Mon, 08 Jun 2026 16:33:21 +0000

What Are JavaScript Libraries and Frameworks?

JavaScript is a popular programming language used to create interactive websites and web applications. To make development easier and faster, developers use libraries and frameworks. These tools provide pre-written code that helps reduce development time and improve productivity.

What is a JavaScript Library?

A JavaScript library is a collection of pre-written functions and code that developers can use whenever needed. The developer remains in control and decides when and where to use the library's features.

Some popular JavaScript libraries include:

React – Used for building user interfaces.
jQuery – Simplifies DOM manipulation and event handling.
Axios – Helps make HTTP requests to APIs.
Lodash – Provides utility functions for working with data.

Advantages of Libraries

Easy to learn and use
Flexible and lightweight
Can be integrated into existing projects
Reduces development effort

What is a JavaScript Framework?

A JavaScript framework is a complete structure for building applications. It provides predefined architecture, tools, and guidelines that developers follow while creating applications. In a framework, the framework controls the overall flow of the application.

Some popular JavaScript frameworks include:

Angular – A full-featured framework developed by Google.
Vue.js – A progressive framework for building user interfaces.
Next.js – A React-based framework for web applications.
Nuxt.js – A framework built on top of Vue.js.

Advantages of Frameworks

Provides a structured development approach
Includes many built-in features
Suitable for large-scale applications
Encourages best coding practices

Difference Between Libraries and Frameworks

Library	Framework
Developer controls the flow of the application	Framework controls the flow of the application
Used for specific tasks	Used to build complete applications
More flexible	More structured
Easier to learn	Usually has a steeper learning curve
Examples: React, jQuery, Axios	Examples: Angular, Vue.js, Next.js

Real-Life Example

Think of a library as a toolbox. You choose the tools you need and use them whenever required.

Think of a framework as a house blueprint. It provides a complete plan and guides how everything should be built.

Difference Between == and equals() in Java

Arul .A — Sun, 07 Jun 2026 16:34:50 +0000

What is ==?

The operator is used reference comparison.
It compares whether two variables refer to the same object in memory.

Example:

String s1 = new String("Java");
String s2 = new String("Java");

System.out.println(s1 == s2);

Output:

false

Here, s1 and s2 contain the same text, but they are stored in different memory locations. Therefore, == returns false.

What is equals()?

The equals() method compares the actual content or values of two objects.

Example:

String s1 = new String("Java");
String s2 = new String("Java");

System.out.println(s1.equals(s2));

Output:

true

The content of both strings is "Java", so equals() returns true.

Why Use UTF-8 in File Handling?

Arul .A — Sat, 06 Jun 2026 13:45:04 +0000

UTF-8 is a character encoding standard.It is used to store and read text files correctly. -It supports mostly all languages and special characters.Nowadays mostly is used for encoding format.

Benefits of UTF-8:

1.Supports Multiple Languages

UTF-8 can store text from different languages such as:
English: Hello
Tamil: வணக்கம்
Hindi: नमस्ते
Chinese: 你好
This ensures that users from different regions can read the file correctly.

Prevents Character Corruption

If a file is written using one encoding and read using another, the text may appear as unreadable symbols. Using UTF-8 consistently prevents this problem.

Cross-Platform Compatibility

UTF-8 is supported by most operating systems, programming languages, databases, and web browsers. Files encoded in UTF-8 can be shared easily between different systems.

Supports Special Characters and Emojis

UTF-8 can store symbols, currency signs, and emojis such as:

₹  ©  ®  😊

Example:

Reading a file using UTF-8:

BufferedReader br = new BufferedReader(
    new InputStreamReader(
        new FileInputStream("data.txt"),
        "UTF-8"
    )
);

In this example, Java reads the file using UTF-8 encoding, ensuring that all characters are displayed correctly.

Understanding File, FileReader, FileWriter, BufferedReader, and BufferedWriter in Java

Arul .A — Fri, 05 Jun 2026 12:51:51 +0000

File Class :

The file class is represents file or directory(folder).They used to file related operations such as creating,deleting,renaming,check whether file or folder.
However the file does not write or read.

Example:

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

if(file.exists()) {
    System.out.println("File exists");
}

2.FileReader:

The FileReader is used to read text data from a file by character by character.
It is suitable for reading small text files.

Example:

FileReader fr = new FileReader("data.txt");

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

fr.close();

FileWriter :

The FileWriter is used to write text data into a file . If the file does not exist ,java creates file automatically.

Example:

FileWriter fw = new FileWriter("data.txt");

fw.write("Hello Java");

fw.close();

BufferedReader :

The BufferReader is used to improves reading performance by instead of using internal buffer.
Instead of accessing the file for every character, it reads a larger block of data into memory. It also provides the convenient readLine() method.

Example:

BufferedReader br =
    new BufferedReader(
        new FileReader("data.txt"));

String line;

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

br.close();

5.BufferedWriter :

-The BufferedWriter is used to write text data improves writing performance by storing data in a buffer before writing it to the file.

The reduces the number of disk operatins and makes file writing faster.

Example:

BufferedWriter bw =
    new BufferedWriter(
        new FileWriter("data.txt"));

bw.write("Hello");
bw.newLine();
bw.write("Java");

bw.close();

Why Use Mostly IOException in File Handling in Java?

Arul .A — Wed, 03 Jun 2026 16:07:04 +0000

When working with files in Java, many operations can fail. For example:

The file may not exist.
The file may be locked by another program.
The user may not have permission to access the file.
The disk may be full.
A read or write operation may fail unexpectedly.

Because of these possible errors, Java uses IOException to handle file-related problems.

Example:

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

public class Example {
    public static void main(String[] args) {

        try {
            FileWriter writer = new FileWriter("data.txt");
            writer.write("Hello Java");
            writer.close();

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

Why IOException?

FileWriter, FileReader, BufferedReader, BufferedWriter, and many other file classes can throw IOException.

Since Java forces us to handle checked exceptions, we must either:

Use try-catch
Or declare throws IOException

Example:

catch (IOException e)

This catches file-related errors and prevents the program from crashing.

IOException is used in Java file handling because file operations are not guaranteed to succeed. Files may be missing, inaccessible, or fail during reading and writing. By catching IOException, we can handle these errors safely and prevent our program from crashing.

Why useEffect Causes Infinite Loops in React?

Arul .A — Tue, 26 May 2026 13:00:49 +0000

React’s useEffect() Hook is used for side effects like API calls, timers, and event listeners. One common beginner mistake is creating infinite loops inside useEffect().

Example of wrong code:

useEffect(() => {
   setCount(count + 1);
});

This creates an infinite loop because:

Component renders
useEffect() runs
State updates
Component re-renders
useEffect() runs again

This process repeats forever.

The correct way is:

useEffect(() => {
   setCount(count + 1);
}, []);

The empty dependency array [] tells React to run the effect only once after the first render.

Dependency array behavior:

No dependency array → runs after every render
Empty array [] → runs once
[value] → runs when value changes

Another common mistake is using objects or functions in dependency arrays because React compares references, not actual values.

Best practices:

Use dependency arrays correctly
Avoid unnecessary state updates
Keep useEffect() simple
Understand React rendering flow

Understanding useEffect() properly helps developers avoid performance issues and debugging problems in React applications.

Difference Between JavaScript (.js) and JSX (.jsx)

Arul .A — Sat, 23 May 2026 17:04:56 +0000

JavaScript and JSX are closely related technologies used in modern web development, especially in React applications.

-What is JavaScript (.js)?

JavaScript is a programming language used to create dynamic and interactive web applications. Files with the .js extension contain pure JavaScript code.
JavaScript is commonly used for:

1.Variables and functions
2.Loops and conditions
3.API calls
4.Event handling
5.DOM manipulation
6.Business logic

Example :

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

console.log(add(5, 3));

What is JSX (.jsx)?
JSX stands for JavaScript XML. It is a syntax extension for JavaScript that allows developers to write HTML-like code inside JavaScript.
JSX is mainly used in React to create user interface components.

Example :

function App() {
  return (
    <div>
      <h1>Hello React</h1>
    </div>
  );
}

export default App;

Difference Between @PathVariable and @RequestParam

Arul .A — Fri, 22 May 2026 17:37:37 +0000

Both @PathVariable and @RequestParam are used to receive data from the client request in Spring Boot.But they work in completely different ways.

What is @PathVariable?

@PathVariable is used to get values directly from the URL path.

Example:

@GetMapping("/product/{id}")
public String getProduct(@PathVariable int id) {
    return "Product ID: " + id;
}

URL:

/product/10

Here:

id = 10 => The value 10 becomes part of the URL path itself.

Usually used for:

Specific resource IDs
Mandatory values
Unique objects
What is @RequestParam?

@RequestParam gets values from query parameters.

Example:

@GetMapping("/products")
public String search(@RequestParam String category) {
    return category;
}

URL:

/products?category=mobile

Here:

category = "mobile"

Usually used for:

Filtering
Searching
Sorting
Pagination
Optional data

Examples:

/products?category=mobile
/products?page=2
/products?sort=price
/products?search=iphone

These are not unique resources.

They are conditions or filters.

What is Maven?And Pom.xml?

Arul .A — Wed, 06 May 2026 04:58:18 +0000

What is Maven in Spring Boot?

Maven is a build automation and project management tool used in Java projects. In Spring Boot, Maven handles:
Downloading dependencies (libraries/jars) automatically
Compiling your Java code
Running tests
Packaging your app into a .jar or .war file
Deploying your application

What Maven Actually Does

Maven mainly handles 3 things:

Dependency Management

It downloads required libraries automatically.

Example:
You want to use MySQL in Spring Boot.

Without Maven:

search MySQL connector online
download jar
add to project manually

With Maven:

just add this in pom.xml

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <version>8.3.0</version>
</dependency>

Maven downloads it automatically from the Maven repository.

Build Automation

Maven can:

compile code
run tests
package project
create .jar or .war

Instead of: javac Main.java

You simply run: mvn compile

To create a JAR: mvn package

Standard Project Structure

Maven forces a clean structure.

Example:

project-name/
│
├── src/
│   ├── main/
│   │   ├── java/
│   │   └── resources/
│   │
│   └── test/
│       └── java/
│
├── pom.xml

What is pom.xml ?

This is the heart of Maven.

POM = Project Object Model

It contains:

project name
dependencies
plugins
Java version
build settings

Example:

<project xmlns="http://maven.apache.org/POM/4.0.0">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>1.0</version>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>3.2.5</version>
        </dependency>

    </dependencies>

</project>

Important Maven Commands :

Command	Purpose
`mvn compile`	Compiles code
`mvn test`	Runs tests
`mvn package`	Creates JAR/WAR
`mvn clean`	Deletes old build files
`mvn install`	Installs into local repository

Spring Boot MVC Explained: Build Smarter Web Apps with Model-View-Controller

Arul .A — Tue, 05 May 2026 07:19:52 +0000

Introduction

When building applications with Spring Boot, one of the most important architectural patterns you’ll encounter is MVC (Model-View-Controller). Many developers claim to “use MVC,” but in reality, they only use annotations like @RestController without understanding the separation of responsibilities.

This article breaks MVC down properly—what it is, how Spring Boot implements it, and how to use it correctly in real-world applications.

What is MVC?

MVC stands for:

Model
View
Controller

It is a design pattern that separates an application into three layers, each with a distinct responsibility. The goal is to reduce code complexity and improve maintainability.

Why MVC Matters (No-Nonsense Explanation)

If you don’t follow MVC:

Your controller becomes a dumping ground
Business logic gets duplicated everywhere
Debugging becomes painful
Scaling the application becomes difficult

MVC in Spring Boot

Spring Boot uses Spring MVC, which provides built-in support for this architecture using annotations and conventions.

Typical layers in a Spring Boot MVC application:

Controller → Service → Repository → Database

1. Model Layer (Data + Business Logic)

The Model represents:

Application data
Business rules
Database interaction

Components:

Entity classes (@Entity)
Repository interfaces (JpaRepository)
Sometimes DTOs

Example:

@Entity
public class User {

    @Id
    @GeneratedValue
    private Long id;

    private String name;
    private String email;

    // getters and setters
}

Repository:

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

2. View Layer (What the User Sees)

The View is responsible for presenting data.

Two common types in Spring Boot:

1. Traditional MVC

Thymeleaf
JSP

2. REST APIs (Most common today)

JSON responses
Used with frontend frameworks (React, Angular)

Example (JSON View):

{
  "id": 1,
  "name": "Arul",
  "email": "arul@example.com"
}

3. Controller Layer (Request Handling)

The Controller:

Receives HTTP requests
Validates input
Calls the service layer
Returns response

Example:

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService service;

    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return service.getUserById(id);
    }
}

4. Service Layer (The Most Ignored Layer)

This is where most beginners fail.

The Service layer:

Contains business logic
Acts as a bridge between Controller and Repository
Keeps controllers clean

Example:

@Service
public class UserService {

    @Autowired
    private UserRepository repo;

    public User getUserById(Long id) {
        return repo.findById(id)
                   .orElseThrow(() -> new RuntimeException("User not found"));
    }
}

How MVC Flow Works (Step-by-Step)

Let’s say a client requests:

GET /users/1

Flow:

Request hits Controller
Controller calls Service
Service calls Repository
Repository fetches data from Database
Data returns to Service
Service returns to Controller
Controller sends response to client (View)

Real Project Structure

A clean Spring Boot project should look like this:

com.example.project
│
├── controller
├── service
├── repository
├── model
└── dto

If your project doesn’t look like this (or similar), you’re probably mixing responsibilities.

Advantages of MVC

Clear separation of concerns
Easier debugging
Scalable architecture
Better team collaboration
Reusable components