DEV Community: Sonali Gupta

chapter 2 : structure of JWT

Sonali Gupta — Wed, 01 Apr 2026 08:25:16 +0000

Every JWT has 3 parts: Header, payload and signature

For example :

Common mistake

❌ “JWT is encrypted”
→ Wrong

✅ JWT is encoded + signed, not encrypted (by default)

JWT (JSON Web Token)

Sonali Gupta — Sun, 29 Mar 2026 14:50:23 +0000

lets divide into chapter :
chapter 1 : What JWT actually is?
chapter 2 : structure of JWT
chapter 3 : JWT Flow
chapter 4 : creating JWT in SpringBoot
chapter 5 : JWT + RBAC Integration
chapter 6 : Common mistakes

CHAPTER 1 — What JWT actually is?
JSON Web Token is a signed token used to verify user identity without storing session data on the server.

Strip it down
JWT is just:
A string
That contains user data
And is digitally signed

What problem it solves

Without JWT: Server stores sessions → memory heavy

With JWT: Client stores token → server stays stateless

Analogy (lock this in your head)

JWT = college ID card
You carry it
College doesn’t check database every second
They just verify ID

Key idea (don’t forget)

JWT does NOT store user
JWT carries user info

stay updated for chapter 2

Mastering java 8 (Lambda expression & functional interface) - day 2

Sonali Gupta — Sun, 01 Feb 2026 15:55:26 +0000

As a developer, I'm always looking for ways to write cleaner, more efficient, and more readable code. One of the most significant leaps in Java's evolution towards this goal came with Java 8: Lambda Expressions and Functional Interfaces.

Initially, these concepts can feel a bit abstract. But after diving deep, I've realized they're powerful tools that simplify common programming patterns. Let me walk you through what I've learned, breaking down the core anatomy and the most essential types.

What is a Lambda Expression? The "Anonymous Function"
At its heart, a Lambda Expression is a concise way to represent an anonymous function – a function without a name. Think of it as a small, self-contained piece of code that you can pass around and execute. Its primary goal is to reduce boilerplate code and allow you to treat "code as data."

The basic anatomy of a lambda expression is surprisingly simple:

(parameters) -> { body of the logic }

Let's break down each part:

(parameters): The input arguments for your code.

If there's only one parameter, you can omit the parentheses (e.g., s -> ...).

If there are no parameters, you use empty parentheses (e.g., () -> ...).

-> (The Arrow Token): This is the crucial separator. It connects the input parameters to the logic you want to execute. It literally means "goes to" or "executes."

{ body of the logic }: This is where your code lives.

If the body consists of a single expression, you can omit the curly braces {} and the return keyword (the result is implicitly returned).

If the body contains multiple statements, you must use curly braces and explicitly return a value if the lambda is expected to produce one.

Example: Old Way vs. Lambda Way
To truly appreciate lambdas, let's see them in action. Imagine you want to add an action listener to a button.

Before Java 8 (Anonymous Inner Class):

With Lambda Expression (Clean and Concise):

Look at that difference! The lambda expression drastically cuts down on the ceremonial code, focusing purely on the action we want to perform.

The "Home" for Lambdas: Functional Interfaces
Lambdas don't just float freely; they need a "home." This home is a Functional Interface.

A Functional Interface is any interface that has exactly one abstract method. It can have multiple default or static methods, but only one that needs to be implemented.

Common examples built into Java include Runnable, Callable, and Comparator. To make our lives easier, Java 8 also introduced the java.util.function package, which provides several ready-to-use functional interfaces.

The Big Four: Essential Functional Interfaces
These four interfaces from java.util.function are your daily drivers when working with lambdas:

1. Predicate (The Tester)
Purpose: Takes one input of type T and returns a boolean result. Ideal for filtering or testing conditions.

Abstract Method: boolean test(T t)

Example: Checking if a number is even.

2.Function (The Transformer)
Purpose: Takes one input of type T and returns one result of type R. Great for mapping one type to another.

Abstract Method: R apply(T t)

Example: Converting a String to its length (an Integer).

3. BiFunction (The Combiner)
Purpose: Takes two inputs (of types T and U) and returns one result of type R. Useful for combining values.

Abstract Method: R apply(T t, U u)

Example: Adding two integers.

4. Consumer (The Doer)
Purpose: Takes one input of type T but returns no result (void). It "consumes" the input to perform an action.

Abstract Method: void accept(T t)

Example: Printing a message to the console.

Bonus: The Supplier (The Provider)
While not one of the "Big Four," the Supplier is equally important:

Purpose: Takes no inputs and returns one result of type T. It "supplies" a value.

Abstract Method: T get()

Example: Generating a random number.

Why Bother with Lambdas?
The benefits are clear:

Concise Code: Less boilerplate, more focus on business logic.

Readability: Often reads more like plain English, especially with Streams.

Functional Programming: Enables a more functional style of programming in Java.

Stream API Integration: Lambdas are the backbone of the powerful Java Stream API, allowing for elegant data processing.

Mastering java 8( Stream API) - day 1

Sonali Gupta — Mon, 15 Dec 2025 08:39:03 +0000

Java 8 introduced stream API which allows developer to process collections of data in functional and declarative way.

Note : unlike collections, a stream does not store the data it only process it.

1.Features of Stream API

1.Declarative : Write concise and readable code using functional style.
2.Lazy Evaluation : Operations are executed only when
needed (terminal operation).
3.Parallel Execution : Supports parallel streams to leverage multi-core processors.
4.Reusable Operations : Supports chaining of operations like map(), filter(), sorted().
5.No Storage : Streams don’t store data; they only process it.

2.How Stream works internally?

1.Create a stream : From collections, arrays or static methods.
2.Apply intermediate operations : Transform data (eg.filter(), map(), sorter() ).
3.Apply Terminal Operation : Produce a result (e.g., forEach(), collect(), reduce()).

3.Creation of streams
Streams creation can be done in multiple ways:

1.From a Collection : Create a stream directly from a List, Set or any Collection using stream()
2.From an Array : Use Arrays.stream(array) to convert an array into a stream.
3.Using Stream.of() : Create a stream from a fixed set of values using Stream.of()
4.Infinite Stream : Generate an unbounded sequence using Stream.iterate() or Stream.generate()

Intermediate operations

Intermediate operations transform a stream into another stream. Some common intermediate operations include:

filter(): Filters elements based on a specified condition.
map(): Transforms each element in a stream to another value.
Sorted(): Sorts the elements of a stream.
Distinct(): Remove duplicates.
Skip(): Skip first n elements.

Types of streams

1.Sequential Stream
Processes elements one by one in a single thread.
Created by default when you call stream().

2.Parallel Streams
Parallel Streams are the type of streams that can perform operations concurrently on multiple threads.

3.infinite Streams
Streams can also generate unbounded sequences. Use limit() to avoid infinite execution.

why there were a need of collection framework in java?

Sonali Gupta — Wed, 23 Jul 2025 19:40:48 +0000

The Collection Framework, introduced in Java 1.2, is a unified architecture to store, manipulate, and process data.

Before Java 1.2, Java had only arrays and some basic data structures like:

vector
Hashtable
stack
But they had limitations:

✅ What is Java Collection Framework?
The Collection Framework, introduced in Java 1.2, is a unified architecture to store, manipulate, and process data.

🧠 Example Comparison Without Collections (using array):

With Collections:

🎯 Summary
✅ The Java Collection Framework was created to make life easier by giving us powerful, reusable, flexible, and consistent tools for working with groups of objects.

what is Hoisting in javascript

Sonali Gupta — Mon, 14 Jul 2025 08:56:31 +0000

Hoisting is not about physically moving code to the top , but rather about how javascript allocates memory for variables and functions during memory creation phase

you can call function before its declaration in the code because entire function is available in code from start.

But function expression can't be hoisted

but trying to access variable before its declaration will result in "undefined"

what javascript sees?

Q) why it gives us a impression that declarations are move to top of their scope but its actually not ?

because only declaration is processed before any code is executed not a initialization.

DECODING...java word by word

Sonali Gupta — Tue, 01 Jul 2025 18:26:10 +0000

🔹 System
A built-in class in Java that belongs to the package java.lang.

It contains useful tools for interacting with the system — like input/output, error handling, etc.

It has a special member called out that helps send output to the screen.

🔹 out
A static object inside the System class.

It represents the standard output stream — usually your terminal or console.

It is of type PrintStream.

💡 Imagine out as Java’s speaker 📢 — whatever you send here gets spoken (printed) to your screen.

🔹 println
A method of PrintStream class (which out is an object of).

println stands for print line.

It prints the message and then moves to the next line (like pressing Enter).

💡 If print() is like typing on the same line, println() presses Enter after printing.

iconic lines...of java

Sonali Gupta — Tue, 01 Jul 2025 18:18:53 +0000

✔️ public – open to everyone (even JVM)

✔️ static – can run without creating an object

✔️ void – doesn’t return anything

✔️ main – starting point of every Java program

✔️ String[] args – takes command-line input if passed

🔹 Can we remove String[] args from main in Java?
Technically — NO, you should not remove it.
The correct signature that the JVM looks for is:

This is the standard method signature that the JVM recognizes to start your Java program.

❌ If you remove it like this:

🧨 What will happen?

✅ It will compile successfully (no syntax error).

❌ But when you run it using:

✅ Why does JVM expect String[] args?
JVM needs to pass command-line arguments, even if you don’t use them.

That’s why the method must be defined with that exact signature.

Evolution of java...From Simple to Supercharged 🚀(part 5)

Sonali Gupta — Wed, 19 Feb 2025 09:37:30 +0000

Once upon a time, in the world of programming, Java was born in 1995. It was simple, powerful, and became a favorite among developers. But as time passed, Java needed to evolve to keep up with the growing demands of software development. So, Java kept upgrading itself, just like how a smartphone gets better with new updates! 📱✨

📜 The Old Days (Java 5 & 7) – The Foundation Years 🏛️

In the early 2000s, Java was like a sturdy old castle 🏰—strong, reliable, but a little outdated. Developers were writing long and repetitive code, and Java needed to change.

🛠 Java 5 (2004) arrived as a savior!

🔹 It introduced Generics, making collections like List type-safe.
🔹 The for-each loop (for(String s : list)) was added, making iteration easier.

Then came Java 7 (2011), the helper knight 🏇

🔹 It introduced try-with-resources, which automatically closed files and resources, reducing errors.
🔹 It made coding cleaner and safer.

But Java was still not fast enough. It needed a big transformation!

🔥 The Golden Age – Java 8 (2014): A New Era Begins! 🌟

Java 8 was a revolution, like a kingdom discovering magic spells! 🧙‍♂️✨ It introduced three powerful weapons:

🪄 1.Lambdas (Magic Spells for Code)
Before Java 8, writing even a simple function required long lines of code. But with Lambda Expressions, code became shorter and cleaner.

With Java 8's Lambda Magic:

🔥 Much shorter, right?

💧 2.Streams (A River of Data)
Java 8 also introduced Streams, which let developers process data without writing long loops.

👑 3. Default Methods in Interfaces
Before Java 8, interfaces couldn’t have method implementations. But now, interfaces could have default methods, making them more flexible!

🚀 Java 11 (2018) – The Smart Kingdom 🤖
Java 11 was all about making things easier and faster.

💡 The var keyword was introduced:

🐉 Java 17 (2021) – The Dragon Upgrade 🐉🔥
Java 17 introduced Sealed Classes, which controlled who can extend a class. It was like guarding the kingdom’s secrets.

🔒 Example:

Only Dog and Cat can extend Animal, keeping things secure!

⚡ Java 21 (2023) – The Fastest Java Ever! 🏎️💨

The latest update, Java 21, introduced Virtual Threads, which made Java super fast for handling multiple tasks.

Now, Java could handle thousands of tasks at once without slowing down! 🚀

🚀

🔮 The Future of Java: What’s Next?
Java continues to evolve every two years, making coding easier, faster, and more powerful. From the simple old Java 5 to the high-speed Java 21, it has become a modern programming language while keeping its original strengths.

Which version should you learn?
🔹 Java 8 → Best for beginners (most companies still use it).
🔹 Java 11 → Faster and smarter, widely used.
🔹 Java 17+ → The future of Java, with new features and optimizations!

The Tale of Java's Building Blocks: Variables, Data Types, and Operators....(part 4)

Sonali Gupta — Mon, 03 Feb 2025 05:00:00 +0000

Once upon a time, in the land of Java, there lived a young programmer named Alex. Alex had recently entered the kingdom of programming and wanted to learn the magical ways of Java. The elder programmers told him, "To build any program, you must understand the building blocks: Variables, Data Types, and Operators."

1. Variables: The Magical Containers

Alex was introduced to variables—the magical containers that could hold data. Just like a container that stores treasures, variables in Java hold values. But here's the twist: variables had to be named, and they could only store certain types of data.

For example:

A container could hold a number, and that would be an integer type.
A container could hold a single character, and that would be a char type.
A container could hold a piece of text, and that would be a String type.
Alex learned that to use these containers properly, he needed to declare them.

For example:

2. Data Types: The Nature of the Treasures

Now, Alex realized that the treasures held in the containers could have different shapes and sizes. These were called data types.

Primitive Data Types: The simplest types, like int, char, boolean, and double.

int for whole numbers like 20, 30.
double for numbers with decimals, like 3.14.
char for a single letter, like 'A'.
boolean for truth values, like true or false.
Reference Data Types: These were more complex, like objects and arrays, which could hold collections of data.

Alex started creating various variables and learned that Java had a rule: each container (variable) must have a specific type, and the value stored must match it.

3. Operators: The Spellcasters of Java

To make the containers more useful, Alex needed some operators. Operators in Java were like spells that allowed him to perform magical tasks, like adding numbers, comparing them, and even combining text.

Arithmetic Operators: These operators allowed Alex to do simple math.

for addition: int result = 5 + 10;
for subtraction: int result = 10 - 5;
for multiplication: int result = 5 * 4; / for division: int result = 20 / 5; % for remainder (modulus): int result = 5 % 2;

**Comparison Operators: **These helped Alex compare two things, just like a wizard deciding if two spells were equal.

== for equality: if (a == b)
!= for inequality: if (a != b)

for greater than: if (a > b)
< for less than: if (a < b)

Logical Operators: These were used to combine different conditions, like two magical forces working together.

&& for AND: Both conditions must be true.
|| for OR: At least one condition must be true.
! for NOT: Reverses the condition’s truth.

Alex was amazed at how these operators helped him control the flow of magic in his code.

4. Control Flow: The Path to the Desired Outcome

Soon, Alex realized that he needed a way to decide which path to take in his program. The elder wizards told him about control flow statements, which helped him guide his program to follow different paths based on conditions.

If-Else Statements: Alex could use these to decide what action to take based on a condition.

Switch Statements: If Alex had many options, he could use the switch statement to select a specific case.

These statements allowed Alex to be in control, deciding what should happen based on the situation at hand.

As Alex continued his journey through Java, he realized that every concept, like loops (for repeating actions) and functions (for organizing his code into magical spells), had a purpose and contributed to making his programs powerful.

The kingdom of Java was vast, and Alex had only just begun exploring it, but he was on the right path. He had learned the core building blocks, and now he could start creating programs that were as magical as the stories of old.

The Tale of JavaLand: The Memory Kingdom...(part 3)

Sonali Gupta — Sun, 02 Feb 2025 14:17:02 +0000

Once upon a time, in the magical world of JavaLand, there was a grand kingdom called Memory. This kingdom was divided into two main regions:

The Stack Realm – A fast, organized, and disciplined place where things were stored in an orderly manner.

The Heap Forest – A vast, free-spirited land where objects roamed freely and lived as long as they were needed.

The Stack Realm (For Local Variables and Method Calls)
In the Stack Realm, there was a powerful ruler called The JVM (Java Virtual Machine). He had a group of loyal workers known as Threads, who were responsible for handling tasks efficiently.

Every time a new task (a method) was called, a new stack frame was created in the Stack Realm. This frame held all the local variables and function calls related to that task. The kingdom’s law was strict—once a task was completed, its stack frame was destroyed immediately, making space for the next one.

For example, when a knight named Sir Java declared:

A tiny space in the Stack Realm was allocated for gold, and it remained there until the method finished executing. After that, it disappeared like magic!
But there was one problem—The Stack Realm had limited space. If too many tasks were created without finishing old ones, it led to a disaster called StackOverflowError, causing chaos in JavaLand.

The Heap Forest (For Objects and Long-Lived Data)
Beyond the Stack Realm lay the vast Heap Forest, where all objects, arrays, and class instances lived. Unlike the Stack, Heap Forest was not as strict. Objects could stay as long as someone needed them.

For instance, when Sir Java created a new sword:

The excalibur sword was born in the Heap Forest, while its reference (the name "excalibur") was stored in the Stack Realm.
But here’s the catch—if an object was no longer needed, it didn’t just vanish. The Heap Forest had a mighty guardian called Garbage Collector (GC). This silent warrior roamed the land, hunting down abandoned objects and reclaiming their space, keeping the kingdom clean and efficient.

The Clash Between Stack and Heap

Here’s what happened inside JavaLand:

The variables h1 and h2 (which held references) were created in the Stack Realm.
The actual Hero objects ("Arthur" and "Lancelot") were born in the Heap Forest.
If Alice later set h1 = null;, the object "Arthur" was left alone in the Heap until Garbage Collector came to remove it.

Here’s what happened inside JavaLand:

The Moral of the Story
The Stack Realm is fast but short-lived (used for method calls and local variables).
The Heap Forest is large but needs cleanup (used for objects).
The Garbage Collector makes sure no memory is wasted.
And so, the kingdom of JavaLand continued to run smoothly, making Java one of the most efficient programming languages in the world.

The Story of Java's Architecture: A Digital Empire Built on a Virtual Machine ☕🏛️(part 2)

Sonali Gupta — Fri, 31 Jan 2025 17:52:20 +0000

Once upon a time, when Java was born in 1995, its creators at Sun Microsystems had a vision—a programming language that could run on any device, no matter the operating system. But to achieve this, they needed an architecture that was unique and revolutionary.

Thus, the Java architecture was designed with three powerful pillars:

Java Virtual Machine (JVM) – The Universal Interpreter
Java Runtime Environment (JRE) – The Magic Toolkit
Java Development Kit (JDK) – The Master’s Workshop**

Chapter 1: The Birth of the JVM – Java’s Digital Kingdom 🏰

In the land of programming languages, every language had to speak the native language of the operating system it ran on. C and C++ had to be compiled separately for Windows, Mac, and Linux.

But Java’s creators wanted something universal—a translator that could understand Java code and run it anywhere.

Thus, they built the Java Virtual Machine (JVM)—a powerful digital engine that acted as a middle layer between Java programs and different operating systems.

👉 How JVM Works:

Java code is written in a .java file.
This code is compiled into an intermediate language called bytecode (.class file).
The JVM reads the bytecode and converts it into machine code, which the operating system can understand.
This idea was revolutionary because it made Java independent of any operating system. Whether you were using Windows, Mac, or Linux, as long as you had a JVM installed, you could run Java applications! This is what made Java "Write Once, Run Anywhere" (WORA). 🚀

Chapter 2: The Java Runtime Environment (JRE) – The Magic Toolkit 🔮

The JVM alone wasn’t enough. Java needed a set of essential tools—a collection of pre-built libraries and support files that every Java program required to run smoothly.

Thus, the Java Runtime Environment (JRE) was introduced. It contained:

The JVM 🏛️
A set of core libraries 📚
Some helpful tools to execute Java applications 🔧
The JRE became the magic toolkit that allowed Java programs to run seamlessly without developers worrying about memory management, garbage collection, or system dependencies.

Chapter 3: The Java Development Kit (JDK) – The Master’s Workshop ⚒️

Now that Java could run anywhere, it was time to empower the developers—the architects of the digital world. They needed a toolkit to build Java applications.

Thus, the Java Development Kit (JDK) was created, which contained:
✅ The JRE -java runtime environment.. (to run Java programs)
✅ The Java compiler (javac) (to convert Java code into bytecode)
✅ Developer tools like the debugger and documentation generator

Every Java programmer needed the JDK to write, compile, and test their applications. It was like a blacksmith’s workshop, where powerful Java applications were forged! 🔥

Chapter 4: The Evolution of Java Architecture ⚙️

As Java evolved, so did its architecture. It introduced:
📌 Just-In-Time (JIT) Compilation – JVM started compiling frequently used code into native machine code, making Java programs faster! 🚀
📌 Automatic Garbage Collection – Java took care of memory management, freeing up unused memory automatically. 🗑️
📌 Multi-threading – Java allowed programs to run multiple tasks simultaneously, making applications efficient. ⚡
📌 Security Features – Java’s architecture introduced sandboxes, bytecode verification, and encryption to keep programs safe from cyber threats. 🔐

Chapter 5: The Future of Java’s Architecture 🔮

Today, Java's architecture continues to evolve. With new versions like Java 17 and beyond, we see:
✅ Faster startup times with improved JVM performance
✅ More lightweight versions of Java for cloud computing
✅ Integration with AI, big data, and modern frameworks

The JVM now supports multiple languages like Kotlin, Scala, and Groovy, making Java’s architecture more powerful than ever!

Moral of the Story: The Legacy of Java’s Architecture ☕

From the birth of JVM, JRE, and JDK to its rise as a universal programming language, Java’s architecture was designed to be robust, secure, and portable. This is why Java still remains one of the most powerful and widely used languages in the world today.

And so, the story of Java’s architecture continues—powering everything from enterprise applications to Android devices, AI systems, and cloud computing. 🚀💻

Would you like to explore a specific part of Java’s architecture in more detail? 😊