DEV Community: M.Kabileshwaran

I Created a Structured JavaScript and React Learning Repository as Part of My Learning Journey

M.Kabileshwaran — Sun, 26 Jul 2026 08:51:35 +0000

Learning frontend development can sometimes feel overwhelming.

There are countless tutorials, courses, and resources available online, but one challenge I faced was finding a structured path where I could learn concepts step by step, practice them properly, and understand the reasoning behind each concept.

As a Computer Science student, I wanted to move away from only following tutorials and start building my own learning system.

So I started creating:

Learn Frontend

GitHub:

KabileshwaranKabil / learn-frontend

A personal learning repo documenting my journey from JavaScript fundamentals to React development

Learn Frontend

A structured self-learning repository to master frontend development through detailed notes, practice code, experiments, and projects.

About This Repository

Learn Frontend is a comprehensive learning repository created to learn modern frontend development from the basics.

This repository is designed for anyone who wants to learn:

JavaScript from fundamentals
React.js from the basics
Modern frontend development concepts
Building real-world frontend applications

No previous frontend experience is required.

The learning journey starts from the foundation and gradually builds towards advanced frontend development through a structured, module-based approach.

The purpose of this repository is not just to memorize syntax, but to understand:

Why concepts exist
How concepts work internally
How different technologies connect together
How to apply knowledge through practical development

Learning Approach

This repository follows a step-by-step learning approach.

Each concept is divided into smaller learning modules, allowing learners to understand, practice, and apply concepts gradually.

The learning process:

Understand

…

View on GitHub

This is my personal learning repository where I document my journey of learning JavaScript and React.

The repository includes:

Structured learning notes
Code examples
Practice exercises
Concept explanations
Small experiments
Projects

My approach is simple:

Understand the concept → Take notes → Practice → Experiment → Build

The content is created using official documentation and other free learning resources available online, combined with my own understanding and explanations.

This repository is still evolving because I am also learning while building it. New concepts, improvements, and projects will continue to be added.

I am sharing this with the community because I believe learning becomes more meaningful when knowledge is shared.

If you are a beginner starting your frontend journey, I hope this can help you learn in a more structured and effective way.

If you are an experienced developer, your feedback, suggestions, and contributions are highly appreciated.

Feel free to contribute, improve explanations, add examples, or suggest better ways to help other learners.

Learning together makes the journey better.

Spring Security for Beginners — Authentication, Authorization & Basic Setup

M.Kabileshwaran — Wed, 22 Jul 2026 11:00:11 +0000

I'm currently learning Spring Security, and these are my beginner-friendly notes after understanding the fundamentals. I wanted to organize everything into one place so it can help other students who are just getting started.

What is Spring Security?

Spring Security is a security framework for Spring Boot applications. It helps protect your application by handling two major responsibilities:

Authentication – Verifying who the user is.
Authorization – Deciding what the authenticated user is allowed to access.

These are the three topics I learned first:

Fundamentals
Basic Setup
Authorization Rules

Authentication vs Authorization

Let's understand this with a simple example.

Imagine Nimethan, a university student, logging into the university portal.

He enters his username and password, and the system verifies his credentials before allowing him to log in.

This is Authentication — verifying who the user is.

After logging in, Nimethan can view his own grades, but he cannot modify them or access another student's records because he is only a student.

This is Authorization — deciding what the authenticated user is allowed to do.

Authentication

Authentication answers the question:

"Who are you?"

Examples:

Logging in with a username and password
Verifying user identity
Creating an authenticated session

Authorization

Authorization answers the question:

"What are you allowed to do?"

Examples:

Accessing /admin
Viewing protected resources
Checking user roles and permissions

If a normal user tries to access an admin endpoint, Spring Security checks whether that user has the required role before granting access.

Basic Setup

When Spring Security is added to a Spring Boot project, every endpoint becomes protected by default.

Step 1 — Add the dependency

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

After adding the dependency and running the application, visiting:

http://localhost:8080

redirects you to Spring Security's default login page.

Spring Boot automatically creates a temporary user.

Default Username

user

Default Password

The password is printed in the application console every time the application starts.

Step 2 — Create a Security Configuration

Create a class called SecurityConfig.java.

@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {

        http
            .authorizeHttpRequests(auth -> auth
                .anyRequest().authenticated())
            .formLogin(withDefaults());

        return http.build();
    }
}

This configuration means:

Every request requires authentication.
Spring Security provides the default login page.
All security rules are managed through a SecurityFilterChain.

Understanding the Security Configuration

@EnableWebSecurity

Enables Spring Security's web security support and tells Spring that you want to customize the security configuration instead of relying only on the defaults.

SecurityConfig

A regular Java configuration class where all security rules are defined.

You can think of it as the application's security blueprint.

Bean

Marks a method whose returned object will be managed by Spring.

Here, we're telling Spring to use our custom SecurityFilterChain for handling security.

SecurityFilterChain

This is the modern way to configure Spring Security.

It replaces the older WebSecurityConfigurerAdapter.

A filter chain is simply a sequence of security filters that process every incoming HTTP request before it reaches your controller.

HttpSecurity

HttpSecurity provides methods for configuring your application's security.

Some commonly used methods include:

authorizeHttpRequests()
formLogin()
httpBasic()
logout()
csrf()

authorizeHttpRequests()

Defines the authorization rules.

.authorizeHttpRequests(auth ->
    auth.anyRequest().authenticated()
)

This configuration tells Spring Security:

Every request must be authenticated before it can access any endpoint.

formLogin(withDefaults())

.formLogin(withDefaults())

This enables Spring Security's default login page.

When an unauthenticated user attempts to access a protected resource:

Spring redirects the user to the login page.
The user enters their credentials.
Spring authenticates the user.
The authenticated user's information is stored inside the SecurityContext.
Future requests recognize the logged-in user.

http.build()

return http.build();

This finalizes the security configuration and returns the SecurityFilterChain bean that Spring Boot will use.

Without calling build(), the configuration would never be applied.

Request Flow

Here's what happens when a user visits /home.

The user requests /home.
Spring Security checks the configured authorization rules.
The endpoint requires authentication.
Since the user is not logged in, Spring redirects them to the login page.
The user enters valid credentials.
Spring authenticates the user and stores the authentication information in the SecurityContext.
The user is redirected back to /home.

Authorization Rules

In a real application, not every user should have the same level of access.

For example:

Users → Can access general pages.
Admins → Can access administrative pages.

This is where authorization rules become important.

The basic process is:

Create users with different roles.
Configure endpoint access rules.
Create controllers.
Test the application.

Creating Multiple Users

@Bean
public UserDetailsService users() {

    UserDetails user = User.withUsername("user")
            .password(passwordEncoder().encode("pass"))
            .roles("USER")
            .build();

    UserDetails admin = User.withUsername("admin")
            .password(passwordEncoder().encode("admin"))
            .roles("ADMIN")
            .build();

    return new InMemoryUserDetailsManager(user, admin);
}

@Bean
public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
}

Understanding the Classes

UserDetails

UserDetails represents a user that Spring Security can authenticate.

It stores information such as:

Username
Password
Roles
Account status

Example:

UserDetails user = User.withUsername("user")
        .password(passwordEncoder().encode("pass"))
        .roles("USER")
        .build();

This creates a user with:

Username: user
Password: pass
Role: USER

UserDetailsService

UserDetailsService is an interface used by Spring Security to retrieve user information during authentication.

When a user attempts to log in, Spring Security asks:

"Can you provide the user details for this username?"

An implementation of this interface is responsible for returning the corresponding UserDetails object.

InMemoryUserDetailsManager

InMemoryUserDetailsManager is a simple implementation of UserDetailsService.

Instead of retrieving users from a database, it stores them directly in memory.

This makes it ideal for learning, testing, and small demo applications.

PasswordEncoder

Passwords should never be stored as plain text.

PasswordEncoder securely hashes passwords before storing them.

In this example, we use:

BCryptPasswordEncoder

which is one of the most commonly used password hashing algorithms in Spring Security.

These are the core concepts I learned while getting started with Spring Security.

Understanding Authentication, Authorization, and the SecurityFilterChain makes it much easier to understand the more advanced topics that come next, such as:

JWT Authentication
Stateless Security
Custom Login
Role-Based Access Control (RBAC)
OAuth2
Method-Level Security

I'm still learning, so if you notice anything that could be improved or explained better, feel free to leave a comment. I'm always happy to learn from others.

OOP in Java: A First-Year Student’s Cheat Sheet

M.Kabileshwaran — Wed, 02 Jul 2025 10:50:42 +0000

Think of OOP like building with blueprints and real-world creations.
1. Classes vs. Objects – The Simple Difference
A class is like a recipe for a cake. It lists the ingredients (data) and steps (actions). An object is the actual cake you bake using that recipe. You can make many cakes from one recipe, just like you can create many objects from one class.
Example:
Class (Recipe): "How to make a car" (has wheels, color, speed).
Object (Real Car): Your red Toyota (with 4 wheels, going 60 mph).
In Java:

Class = blueprint or template
Object = an instance of that blueprint, a real thing created based on the class

Example:
Think of a Car class — it describes what a car is (color, model, year) and what it can do (drive, brake). When you create a Car object, say myCar, you’re making a specific car, like a red 2020 Toyota.

class Car {
    String color;
    int year;

    void drive() {
        System.out.println("The " + color + " car is driving.");
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();  // Creating an object
        myCar.color = "Red";
        myCar.year = 2020;
        myCar.drive();  // Output: The Red car is driving.
    }
}

2. What Are Constructors? Do We Have Destructors in Java Like C++?
Constructor:
Think of it as a special method that builds your object. When you create an object, the constructor sets up initial values — like choosing the color and year of your car right when you build it.

class Car {
    String color;
    int year;

    // Constructor
    Car(String c, int y) {
        color = c;
        year = y;
    }
}

Destructors?
In C++, destructors clean up when an object is destroyed (like cleaning your room after playing). In Java, there are no destructors because Java has a garbage collector that automatically cleans up unused objects. So, you don’t have to worry about manually deleting objects.

3. What Is static?
static is like a shared property or method that belongs to the class itself, not to any specific object.
Example: Imagine a school where every student has a name (instance variable), but the school’s name is the same for all students (static variable).

class Student {
    String name;              // each student has a name
    static String school = "ABC High School";  // shared by all students
}

You can access static stuff without creating an object:
System.out.println(Student.school); // Output: ABC High School

4. What Are Access Modifiers?

Access modifiers control who can see or use your class members (variables, methods). Think of them as privacy levels:

public: Everyone can see and use it — like a public park.
private: Only the class itself can see it — like your diary.
protected: The class and its subclasses (children) can see it — like family secrets.
default (no modifier): Only classes in the same package can see it — like your neighborhood friends.

5. Example Scenarios & Scope of Access Modifiers

6. The 4 Pillars of OOP and How to Implement Them in Java
Encapsulation — Wrapping data and methods together, hiding details. Use private variables + public getters/setters.

class Person {
    private String name;

    public String getName() { return name; }
    public void setName(String n) { name = n; }
}

Inheritance — A class inherits properties/methods from another (like a child inheriting traits).

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

class Dog extends Animal {
    void bark() { System.out.println("Barking"); }
}

Polymorphism — One interface, many forms. Methods can behave differently in subclasses.

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

class Dog extends Animal {
    void sound() { System.out.println("Bark"); }
}

Abstraction — Hiding complex details, showing only what’s necessary. Use abstract classes or interfaces.

abstract class Vehicle {
    abstract void move();
}

class Bike extends Vehicle {
    void move() { System.out.println("Bike is moving"); }
}

7. How Are Objects Instantiated in Memory?
When you create an object with new, Java allocates memory for it on the heap (the big memory area for objects). The reference (like a pointer) to that object lives on the stack.
Example:

Car myCar = new Car("Blue", 2021);

myCar is a reference on the stack.
The actual Car object is stored on the heap.

8. Can We Pass Objects as Arguments to Other Objects? How?
Objects can be passed as parameters to methods or constructors, enabling interaction between objects.
Example: A Driver object can have a Car object passed to it.

class Car {
    String model;
    Car(String m) { model = m; }
}

class Driver {
    void drive(Car car) {
        System.out.println("Driving a " + car.model);
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("Tesla");
        Driver d = new Driver();
        d.drive(myCar);  // Output: Driving a Tesla
    }
}