DEV Community: Sonali Gupta

Understanding Backend (part 1)

Sonali Gupta — Tue, 01 Sep 2026 15:37:42 +0000

Before understanding backend development in depth, we first need to understand how a backend actually works.

1) how does a Backend actually works?🖥️
-> When a frontend(client) sends a request, it reaches the backend server through an Ip address and port.

The backend then identifies the appropriate endpoint/route for that request and processes it according to the business logic.

If required communicate with the database to read or store data.

Finally, the backend sends a response to the frontend, often in JSON format and the frontend uses that response to display the result to the user.

2) How exactly happens when we enter a URL in the browser?🌐
-> suppose we entered : https://example.com/products
https : protocol(tells browser I want to communicate using https)
example.com : Domain name (which humans can understand)
/products : This tells server which resource you are requesting.

But computer communicate over networks using Ip addresses, not human- friendly domain name. Here DNS comes in.....🕺

DNS (Domain name system) is a phonebook of the internet it converts human-readable domain name (example.com ) to Ip address which computers can understands.

Now how the browser reaches to the server? here TCP walks in...🤷‍♀️

TCP establish a connection between client(browser) and server

But but...we are using https (the communication needs to be protected right) so TLS comes in

TLS provides : Encryption, server authentication and data integrity

Now browser sends an http request telling the server what it wants
for example : Get/products

After that, request reaches to server where backend identifies a appropriate endpoint and processes the request.

If request needs data, the backend communicates with database to read or modify it.

The backend sends HTTP response back to the browser. The response may contain HTML, JSON, images, or other data depending on the request.

Finally, the browser processes the response and displays the webpage or uses the returned data.

In simple terms:

URL → DNS → IP → Connection → HTTP Request → Backend → Database → Response → Browser

Arraylist in java recap 🎏

Sonali Gupta — Sat, 22 Aug 2026 16:04:02 +0000

How JVM handles exception

Sonali Gupta — Fri, 12 Jun 2026 10:28:34 +0000

@RequestParam vs @RequestBody

Sonali Gupta — Wed, 22 Apr 2026 03:58:41 +0000

1) @RequestParam
Extracts small values from the URL (query string).

Eg:

@GetMapping("/search")
public String searchUser(@RequestParam String name) {
return "Searching for " + name;
}

*Call: *
GET /search?name=sonali

name=sonali → comes from URL
No JSON involved

When to use?
Use @RequestParam when:
• Filtering / searching
• Pagination (page=1&size=10)
• Sorting (sort=name)
• Simple values only

If you're sending multiple fields, @RequestParam becomes messy:
/users?name=sonali&email=a@gmail.com&age=21
That’s a bad API design beyond small cases.

2)@RequestBody
Converts JSON request body → Java object.
@PostMapping("/users")
public User createUser(@RequestBody User user) {
return user;
}

Call: POST /users
Body:
{
"name": "Sonali",
"email": "sonali@gmail.com"
}
JSON → mapped to User object
Happens automatically via Spring

When to use?

Use @RequestBody when:

Creating data (POST)
Updating data (PUT)
Sending structured data (objects)

Combine both (real-world usage)
@PostMapping("/users")
public String createUser(
@RequestParam String role,
@RequestBody User user) {

return user.getName() + " is " + role;

}
Call:POST /users?role=admin
Body:
{
"name": "Sonali",
"email": "a@gmail.com"
}

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.