Forem: Dhanush

[Boost]

Dhanush — Wed, 17 Sep 2025 09:28:21 +0000

Anmol Baranwal for CopilotKit

Sep 16 '25

Here's How To Build Fullstack Agent Apps (Gemini, CopilotKit & LangGraph)

#programming #webdev #opensource #ai

273

Comments 19

19 min read

Securing Sessions in Spring Boot

Dhanush — Mon, 15 Sep 2025 01:28:37 +0000

Securing user sessions in Spring Boot is a fundamental part of building web applications, especially those for larger businesses or in regulated industries. You know that while Spring Boot handles a lot of the heavy lifting, real-world applications demand a proactive strategy.

Why Session Security Matters?

Without safeguards like session ID regeneration, attackers can pre-assign or steal session identifiers and impersonate users. This is called session fixation and hijacking. How you handle state also matters. A stateless approach with JWTs or a stateful one with web sessions will influence your architecture and security.

In-memory sessions are quick but fragile. Scaling horizontally requires distributed stores, like JDBC or Redis, to maintain session continuity. Using timeouts helps you enforce auto-logout, cut down on memory leaks, and meet compliance rules for inactivity limits.

Session Management Strategies

Spring Security offers several session creation policies. The default, IF_REQUIRED, creates sessions only when the application needs one. You can also configure it to NEVER create a new session, ALWAYS create one, or to be completely STATELESS, which is ideal for APIs. For an API-first app, setting the session creation policy to stateless avoids unnecessary overhead and misuse.

You also have a few options for session persistence. In-memory storage is fast but doesn't survive a restart and won't scale. JDBC stores sessions in a database, which makes them durable and shareable but also slower due to database I/O. Redis is a high-performance in-memory store that provides excellent scalability and resilience, but it requires more infrastructure to manage.

To prevent session fixation, make sure you regenerate the session ID on login. This stops any session attributes from persisting from a pre-authenticated session. Similarly, invalidate sessions when a user logs out. You can also configure a specific URL for users to land on if their session expires.

You can also limit concurrent logins and manage how a user's new session affects an old one. This mitigates hijacking risks. For example, you can prevent more than one session per user.

With Spring Security 6+, the SecurityContext no longer persists automatically. You now have to explicitly configure it to save, which cuts down on unnecessary writes and improves performance. This extra step provides better clarity and control.

A Sample Configuration

A good security configuration incorporates multiple layers of protection. A typical setup would enforce session creation, regenerate session IDs on login, and limit concurrent sessions. You'd also want to invalidate the session and delete cookies on logout.

To integrate with a distributed store, like Redis, you'd configure the session store type in your application properties. This ensures your sessions are shared, persistent, and can be timed out after a set period of inactivity.

spring.session.store-type=redis
spring.data.redis.host=localhost
spring.data.redis.port=6379

Sample Spring Security Configuration

A robust security configuration combines several layers of protection. Here's a sample SecurityFilterChain that enforces concurrent sessions, regenerates the session ID on login, and invalidates the session on logout:

Benefits of Robust Session Security

Building a solid session security strategy reduces your application's attack surface. ID regeneration and invalidation are key here. Using distributed stores like Redis also ensures high availability and scalability. Explicit context persistence and modern defaults optimize performance. Finally, controlled timeouts and other security flows give you a clear path to compliance and predictable behavior.

Best Practices

Always set cookie attributes like HttpOnly, Secure, and SameSite. These protect against cross-site scripting and other attacks. For timeouts, rely solely on server-side logic; don't trust the client. You should also track any session anomalies or failed access attempts. As a final note, keep your dependencies up to date, as Spring Security is always evolving.

Community Insights

The Spring Boot community consistently agrees on a few key points. They almost universally recommend using Spring Session and a backing store like Redis. The consensus is that it's a mistake to reinvent the wheel. This widespread use is an excellent real-world validation of these strategies.

Securing sessions in Spring Boot isn't just about technical configuration; it's about aligning architecture, performance, and user experience. By leveraging Spring Security's capabilities from session policies to fixation protection and concurrent controls, you empower your applications with both rigor and scale.

This article in published on my LinkedIn Newsletter. You can subscribe to my newsletter here:

LinkedIn Login, Sign in | LinkedIn

linkedin.com

Change the Thickness of hr Tag using CSS

Dhanush — Mon, 01 Sep 2025 11:49:23 +0000

Introduction

The < hr > tag in HTML is used to create a simple horizontal line that separates different sections on a webpage. By default, browsers show this line with a thin thickness (usually 1 to 2 pixels) and a basic color. In modern web design, you might want to change this style so that it fits better with your website's overall look. This post will teach you a few simple CSS methods to adjust the thickness of the < hr > tag, making your design look neat and consistent.

Different Approaches to Change Thickness

There are two primary methods to adjust the thickness of the < hr > tag using CSS. Each approach offers flexibility depending on your design goals.

Approach 1: Using the height and background-color Properties

This method involves overriding the < hr > tag’s default border and using the height property to control thickness.

Syntax

hr.custom-hr {
height: [desired-thickness];
border: none;
background-color: [desired-color];
}

Example 1: Basic Thickness Adjustment
In this example, we create a 4-pixel-thick gray line:

<!DOCTYPE html>
<html>
<head>
<style>
hr.thick-hr {
height: 4px;
border: none;
background-color: #666;
}
</style>
</head>
<body>
<p>Section 1</p>
<hr class="thick-hr">
<p>Section 2</p>
</body>
</html>

Example 2: Gradient Line
For a modern look, replace the solid color with a gradient:

<!DOCTYPE html>
<html>
<head>
<style>
hr.gradient-hr {
height: 6px;
border: none;
background: linear-gradient(90deg, #ff6b6b, #4ecdc4);
}
</style>
</head>
<body>
<p>Section 1</p>
<hr class="gradient-hr">
<p>Section 2</p>
</body>
</html>

Approach 2: Using the border Property

Instead of modifying the height, this method styles the top border of the < hr > element.

Syntax

hr.border-hr {
border: none; /* Removes all borders */
border-top: [desired-thickness] [style] [color];
}

Example 3: Solid Colored Border
Create a 5-pixel-thick red line:

<!DOCTYPE html>
<html>
<head>
<style>
hr.red-hr {
border: none;
border-top: 5px solid #ff0000;
}
</style>
</head>
<body>
<p>Section 1</p>
<hr class="red-hr">
<p>Section 2</p>
</body>
</html>

Example 4: Dashed Border
Customize the line style with a dashed border:

<!DOCTYPE html>
<html>
<head>
<style>
hr.dashed-hr {
border: none;
border-top: 3px dashed #00a8ff;
}
</style>
</head>
<body>
<p>Section 1</p>
<hr class="dashed-hr">
<p>Section 2</p>
</body>
</html>

Additional Tips

Adjust Margins: Use margin-top and margin-bottom to control spacing around the < hr >.
Browser Compatibility: Both methods work across modern browsers.
Combine Techniques: Mix gradients with borders for unique effects.

Conclusion

Changing the thickness of the < hr > tag is very easy with CSS. You can either use the height and background-color method or style the border property to get the look you want. Both techniques give you good control over how the line appears. I hope this guide helps you understand and improve your web design.

What is the difference between static and default methods in a Java interface?

Dhanush — Fri, 28 Feb 2025 08:58:45 +0000

Static methods

Static methods in interfaces are methods that belong to the interface itself, not to any instance of a class that implements the interface. They can't be overridden by implementing classes, right? You call them using the interface name, like InterfaceName.staticMethod().

Default methods

Default methods, on the other hand, provide a default implementation that implementing classes can use or override. They were introduced in Java 8 to allow adding new methods to interfaces without breaking existing implementations. So if a class doesn't override a default method, it gets the default behavior.

For example, adding a new method to an existing interface where all existing implementations can use the default until they decide to implement their own.

interface Vehicle {  
// Static method  
static String getEngineInfo() 
{ 
return "Generic Engine"; 
}  

// Default method  
default void honk() 
{ 
System.out.println("Beep!"); 
}  
}  

// Usage  
class Car implements Vehicle {}  
Car car = new Car();  
car.honk();                // Output: Beep! (uses default)  
String info = Vehicle.getEngineInfo(); // Calls static method

There is no need for getEngineInfo() method or honk() method to override in the implementing classes.
Refer: stackoverflow

Java Version 24 Performance Updates: Faster and Smarter!

Dhanush — Sat, 15 Feb 2025 13:24:06 +0000

Java is one of the most popular programming languages in the world, and it keeps getting better with every new version. Java 24 is here, and it brings some exciting performance updates that make it faster, more efficient, and easier to use. If you’re a developer, this is great news because your applications can now run smoother and handle more tasks without slowing down. Let’s take a closer look at what’s new in Java 24 and how it can help you write better code.

Java’s Journey to Becoming Faster

Java has always been known for its reliability, but in recent years, it has also become a leader in performance. Java 21 was a big step forward, but Java 22 and 23 made it even faster. Now, with Java 24, the language is reaching new heights. These improvements are thanks to the hard work of the OpenJDK community, a group of developers who are constantly working on projects to make Java better.

Key Projects Behind Java 24’s Improvements

Several projects are driving the performance upgrades in Java 24. These projects focus on different areas, like making code cleaner, improving memory management, and enabling better scalability. Here are some of the most important ones:

Project Amber: Cleaner Code, Better Performance
This project adds new features to the Java language to make code shorter and easier to read. While the main goal is to help developers write code faster, it also has a nice side effect: cleaner code often runs faster and uses fewer resources.
Project Babylon: Smarter Code Analysis
Babylon gives Java the ability to analyze and modify its own code. This opens up new possibilities for optimization, including using GPUs for heavy computations. This means Java can now handle tasks that require a lot of processing power much more efficiently.
Project Loom: Lightweight Threads for Better Scalability
Handling multiple tasks at the same time can be tricky, but Project Loom makes it easier. It introduces lightweight threads that allow developers to manage millions of tasks without the overhead of traditional threads. This makes applications more scalable and efficient.
Project Valhalla: Better Handling of Data Types
Valhalla aims to close the gap between primitive data types (like integers) and objects. By introducing value types, it allows developers to work with data in a way that’s both fast and flexible. This means better performance without sacrificing the benefits of object-oriented programming.

Challenges in Performance Optimization

Improving performance isn’t always easy. Developers often have to make tough choices, like balancing speed with memory usage or improving one part of the code at the expense of another. For example, making an application faster in some cases might make it slower in others. There are also technical challenges, like avoiding memory errors or dealing with complex code structures. These issues require careful planning and testing to get right.

Top 5 Performance Improvements in Java 24

Java 24 introduces several major optimizations that make it stand out. Here are the top five:

1️⃣ Foreign Function and Memory API
This feature allows Java to work more efficiently with native code and memory. It also supports SIMD (Single Instruction, Multiple Data) instructions, which let Java process multiple pieces of data at the same time. This is a big boost for tasks that require heavy computation.

// 1. Foreign Function and Memory API
import jdk.incubator.foreign.*;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;

public class ForeignMemoryExample {
    public static void main(String[] args) throws Throwable {
        // Allocate off-heap memory
        MemorySegment segment = MemorySegment.allocateNative(1024);
        try {
            MemoryAccess.setIntAtOffset(segment, 0, 42); // Write to memory
            int value = MemoryAccess.getIntAtOffset(segment, 0); // Read from memory
            System.out.println("Value: " + value);

            // Example with foreign function
            MethodHandle strlen = CLinker.systemCLinker().downcallHandle(
                CLinker.systemCLinker().lookup("strlen").get(),
                MethodType.methodType(long.class, MemoryAddress.class),
                FunctionDescriptor.of(CLinker.C_LONG, CLinker.C_POINTER)
            );

            String str = "Hello, Foreign Memory!";
            try (MemorySegment cString = CLinker.toCString(str)) {
                long length = (long) strlen.invokeExact(cString.address());
                System.out.println("String length: " + length);
            }
        } finally {
            segment.close();
        }
    }
}

2️⃣ Improved Garbage Collector
Java 24’s garbage collector has been redesigned to manage memory more effectively. It divides memory into sections and handles objects more precisely, reducing delays and making applications more responsive.

// 2. Improved Garbage Collector
public class ImprovedGCExample {
    public static void main(String[] args) {
        System.out.println("Running with improved GC in Java 24.");
        for (int i = 0; i < 1_000_000; i++) {
            new String("Object " + i); // Generate garbage
        }
        System.gc(); // Trigger garbage collection
        System.out.println("GC executed!");
    }
}

3️⃣ Method Inlining and Loop Unrolling
The Java compiler now inlines methods (replacing method calls with the actual code) and unrolls loops (processing multiple iterations at once). These changes make code run faster by reducing unnecessary steps.

// 3. Method Inlining and Loop Unrolling
public class InliningExample {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i < 10_000; i++) {
            sum += addNumbers(i, i + 1);
        }
        System.out.println("Sum: " + sum);
    }

    private static int addNumbers(int a, int b) {
        return a + b;
    }
}

4️⃣ Invariant Hoisting
This optimization moves calculations that don’t change inside loops to outside the loop. This reduces redundant work and speeds up execution.

// 4. Invariant Hoisting
public class InvariantHoistingExample {
    public static void main(String[] args) {
        int constant = 5;
        int sum = 0;
        for (int i = 0; i < 10_000; i++) {
            sum += i * constant; // Compiler moves `constant` multiplication out of loop
        }
        System.out.println("Sum: " + sum);
    }
}

5️⃣ Ahead-of-Time Compilation
While still in development, this feature allows Java code to be compiled before it runs. This could lead to near-instant startup times for applications, making Java even more competitive.

// 5. Ahead-of-Time Compilation
// Requires configuration and specific tools (e.g., `jaotc`)
public class AOTExample {
    public static void main(String[] args) {
        System.out.println("Ahead-of-Time Compilation Example");
        for (int i = 0; i < 100; i++) {
            System.out.println(fibonacci(i));
        }
    }

    private static int fibonacci(int n) {
        if (n <= 1) return n;
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}
// Compile with: jaotc --output AOTExample.so --class-name AOTExample

Stream Gatherers (JEP 485)

Stream Gatherers introduce a new intermediate operation, Stream::gather(Gatherer), that transforms stream elements with unprecedented flexibility. Similar to how Stream::collect(Collector) works for terminal operations, gather empowers you to implement one-to-one, one-to-many, many-to-one, or many-to-many transformations. Gatherers allow you to:

Maintain state during processing through an initializer function.
Process each element using an integrator that can emit one or more results.
Enable parallel execution when a combiner function is provided.
Finalize processing with a finisher that may output additional elements.

For example, using a built-in gatherer like Gatherers.windowFixed(3) groups stream elements into fixed-size windows:

List<List<Integer>> windows = Stream.of(1,2,3,4,5,6,7,8,9)
    .gather(Gatherers.windowFixed(3))
    .toList();

Output

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

This approach not only simplifies grouping logic but also supports parallel processing, making it a versatile addition to the Java Stream API.

Enhanced `synchronized` with Virtual Threads

Java now allows virtual threads to acquire, hold, and release monitors independently of their carrier threads. When a virtual thread blocks on a monitor, it unmounts—freeing its carrier thread—then remounts when the monitor is available. This improvement reduces performance bottlenecks, and there's no longer a need to replace synchronized with alternative locking mechanisms for this reason.

Example:

public class SyncVirtualThreadExample {
    private final Object lock = new Object();

    public void syncTask() {
        synchronized (lock) {
            System.out.println("Thread " + Thread.currentThread().getName() + " acquired the lock.");
            try {
                // Simulate waiting: the virtual thread unmounts while waiting.
                lock.wait(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("Thread " + Thread.currentThread().getName() + " resumed execution.");
        }
    }

    public static void main(String[] args) {
        SyncVirtualThreadExample example = new SyncVirtualThreadExample();

        // Start two virtual threads that use the synchronized block.
        Thread.startVirtualThread(example::syncTask);
        Thread.startVirtualThread(example::syncTask);
    }
}

In this example, virtual threads block on the monitor (via wait), unmounting from their carrier threads. When the lock is released, they remount and resume execution—all while maintaining the familiar synchronized semantics.

What’s Next for Java?

Java 24 is just the beginning. Projects like Loom and Valhalla are still evolving, and new features like stream gatherers (for faster data processing) and ahead-of-time compilation are on the horizon. The future of Java looks bright, and developers have a lot to look forward to.

Why You Should Try Java 24

If you’re a developer, Java 24 is worth exploring. The performance improvements can make your applications faster and more efficient, and the new features can help you write cleaner, more maintainable code. Whether you’re working on a small project or a large-scale application, Java 24 has something to offer.

Conclusion

Java 24 is a big step forward for the language. With its focus on speed, scalability, and efficiency, it’s clear that Java is still evolving to meet the needs of modern developers. So, if you haven’t already, give Java 24 a try and see how it can improve your code. The future of Java is here, and it’s faster than ever!

Follow @dhanush9952 for more updates
Follow me on X @monkdhanush

60 Days Habit Tracker - Productivity Tool : Github Challenge

Dhanush — Sun, 12 Jan 2025 09:39:36 +0000

This is a submission for the GitHub Copilot Challenge : New Beginnings

What I Built

A productivity tool to keep track of your habits and each day starting from the date specified. Add note to each task done on that day to build your habit.

You can select the start date and from that 60 days will be displayed showing the date and checkbox and an input to add your note.

At the bottom, you can see the percentage of task or days completed which you followed to develop your habit.

Demo

Live demo at: Github Copilot Challenge 2

Repo

Github-Copilot-Challenge-2

Copilot Experience

Initially, I tried to structure the project. But this is a productivity tool, so I directly started with prompt asking for the HTML file for a 60 Days Habit Tracker app.

After creating a skeleton, I started to add styles to the existing HTML which is nothing but a banner like page. It looks like this

Then I added date picker to select the start date. Asked Github copilot to add a material styled reset button to revert changes. It was done well with css alone.

Previous project using Github Copilot

Javascript code for darkmode and lightmode were included to make it more attractive.

A rounded display to show the percentage of task completed.

GitHub Models

I have used only Github copilot VS Code extension for this project.

Conclusion

It was a great experience to develop a simple app like this using Github copilot alone. Literally anyone can create this type of tools with the help of copilot. It saves a lot of time. All these for free.

I would suggest watching this YouTube video Master the core principles of prompt engineering with GitHub Copilot before trying on your own for a better experience.

        Happy building with Github Copilot🤖

Debunking the Myths: Why Learning Java is a Great Career Move

Dhanush — Fri, 10 Jan 2025 10:23:01 +0000

Java is one of the most popular programming languages in the world, and for good reason. It's a versatile, platform-independent language that's widely used in a variety of industries, from Android app development to enterprise software solutions.

However, despite its popularity, Java is often surrounded by myths and misconceptions that can discourage beginners from learning the language. In this post, we'll debunk some of the most common myths about Java and explore the benefits of learning this powerful language.

Myth #1: Java is too hard to learn

One of the most common myths about Java is that it's a steep learning curve for beginners. While it's true that Java can be a complex language, the reality is that the learning curve depends largely on the instructor or resource you're using. If you're learning from someone who struggled to grasp Java themselves, it's likely to be a more challenging experience. However, with the right guidance and resources, Java can be a relatively accessible language to learn, even for beginners.

Myth #2: Java is not suitable for lightweight, quick tasks

Another myth about Java is that it's not suitable for lightweight, quick tasks. While it's true that Java is better suited for larger and more complex applications, this doesn't mean it can't be used for smaller tasks. In fact, Java's versatility and platform independence make it a great choice for a wide range of applications, from simple scripts to complex enterprise systems. And with the rise of multi-file source code and shebang execution under Linux, Java is becoming an increasingly popular choice for quick and lightweight tasks.

Myth #3: Oracle Java Development Kit (JDK) is not open source

One of the most common misconceptions about Java is that the Oracle Java Development Kit (JDK) is not open source. However, this is not true. OpenJDK is a completely open-source implementation of the JDK, and it's where the majority of Java development happens. Oracle Java developers contribute to the OpenJDK project, ensuring that Java remains a community-driven and open-source language.

Myth #4: Java is an "old" language

Another myth about Java is that it's an "old" language, with some developers viewing it as outdated or obsolete. However, the reality is that Java's age is actually a benefit. Java's maturity means it's a well-established and widely used language, with a vast ecosystem of libraries, frameworks, and tools. This also translates to excellent documentation and a large community of developers who can provide support and guidance.

Myth #5: There are too many Java programmers

Finally, some developers believe that there are too many Java programmers, making it a less desirable skill to have. However, the reality is that having a large community of Java developers is actually a benefit. With so many Java developers out there, it's easy to find people who can help you out and mentor you, whether you're a beginner or an experienced developer.

                           Happy Coding 😎

Winter Solstice: Frontend Challenge - December Edition

Dhanush — Sun, 22 Dec 2024 06:48:38 +0000

This is a submission for Frontend Challenge - December Edition, Glam Up My Markup: Winter Solstice

Here’s an updated version of your project description for the Frontend Challenge - December Edition, Glam Up My Markup: Winter Solstice that incorporates your HTML and CSS code into a concise, professional dev post format:

What I Built

For the Frontend Challenge - December Edition, Glam Up My Markup: Winter Solstice, I created a visually dynamic and informative landing page dedicated to the celebrations of the Winter Solstice around the world. The page is designed to offer a blend of educational content and winter-themed aesthetics, with a modern touch using animations and interactive elements. The focus of the project is to engage users with vibrant visuals, smooth transitions, and responsive layout while presenting important cultural information about the solstice.

Key Features:

Snowfall Animation: Using CSS keyframes, I created an immersive snowfall background effect that gives the page a wintry feel, perfect for the theme of the Winter Solstice.
Gradient Texts and Buttons: The headings and navigation links feature vibrant gradient effects, bringing the content to life with colors reflecting the seasonal theme.
Responsive Design: The layout adjusts seamlessly across devices, making sure users can enjoy the experience on mobile, tablet, or desktop screens.
Content Sections: The page includes various sections that cover the science behind the solstice, hemispherical differences, global celebrations, and cultural traditions associated with this celestial event.

Demo

You can view the live demo of the project by clicking here.

Journey

Creating this landing page was an exciting and rewarding experience. I focused on three main areas: design, interactivity, and content presentation.

Design & Aesthetic Choices:

To create a wintry atmosphere, I used a linear gradient background for the body, coupled with a snow animation that flows gently over the background throughout the page. This gave it a dynamic touch while keeping the theme cohesive. The header and navigation are styled to be clean yet visually appealing with gradient text and hover effects.

CSS Animations:

The snowfall background animation was one of the main highlights of the page. The use of CSS animations (@keyframes) helped me achieve a smooth scrolling effect for the snowflakes, adding a touch of liveliness to the page. Additionally, I added hover effects to buttons and links to increase user engagement.

Learning:

I learned more about CSS keyframes and background animations while working on this challenge. I also improved my ability to use responsive design techniques to ensure that the layout adapts across multiple screen sizes.

Challenges:

The primary challenge was integrating the snowfall animation smoothly without affecting the page's loading speed. To address this, I optimized the background images and animations, ensuring a smooth experience for users.

Next Steps:

I would like to explore JavaScript animations to add more interactivity to the page, such as interactive tooltips or scrolling effects. Additionally, I plan to integrate more multimedia content such as videos or interactive timelines to make the experience even more engaging.

Technology Stack:

HTML
CSS (including keyframe animations)
Google Fonts (for font style)
Git & Github (for version control)
Vercel (for deployment)

Code License:

This project is licensed under the MIT License.

Thanks for reading, and I hope you enjoy the wintery journey through solstice celebrations!

Happy Coding😎

TypeScript for Professionals

Dhanush — Sun, 22 Dec 2024 02:57:08 +0000

Advanced and Creative TypeScript Techniques for Professionals

Shafayet Hossain Yashfi ・ Dec 15 '24

#typescript #webdev #programming #tutorial

A detailed analysis of Java Object size and its comparision with primitive data types.

Dhanush — Sun, 01 Dec 2024 03:54:05 +0000

How to estimate Java object size

Dayananda ・ Nov 25 '24

#java #architecture #spring #memory

Git commands tips and useful guides

Dhanush — Thu, 28 Nov 2024 06:43:40 +0000

Git Like a Pro: 10 Things I Regret Not Knowing Earlier

chintanonweb ・ Nov 22 '24

#webdev #programming #tutorial #git

A Guide to Functional Programming

Dhanush — Mon, 11 Nov 2024 11:19:58 +0000

Functional programming has gained popularity due to its ability to provide efficient and scalable solutions. It's a declarative approach to programming, where the focus is on specifying what the program should accomplish, rather than how it should accomplish it.

In this post, we'll look into the core concepts and advantages of functional programming, as well as explore some of the most popular functional programming languages.

What is Functional Programming?

Functional programming is a declarative programming paradigm that focuses on applying pure functions in sequence to solve complex problems. It treats functions as first-class citizens, allowing them to be passed as arguments to other functions, returned as values from functions, and stored in data structures.

👉Functional programming excels at mathematical functions where values don't have any correlation and doesn't make use of concepts like shared state and mutable data used in object-oriented programming.

Core Concepts of Functional Programming

1️⃣ First-class functions:

Functions are treated as data type variables and can be used like any other variables.

Example 1: In JavaScript, we can pass a function as an argument to another function, just like we would pass a variable.

function add(x, y) {
  return x + y;
}

function multiply(x, y) {
  return x * y;
}

function calculator(operation, x, y) {
  return operation(x, y);
}

console.log(calculator(add, 2, 3)); // Output: 5
console.log(calculator(multiply, 2, 3)); // Output: 6

In this example, the calculator function takes another function (add or multiply) as an argument, and uses it to perform the calculation.

Example 2: In Haskell, functions are treated as first-class citizens, allowing them to be passed as arguments to other functions, returned as values from functions, and stored in data structures.

2️⃣ Recursion:

Functional programs avoid constructions that create different outputs on every execution. Instead, recursive functions call themselves repeatedly until they reach the desired state or solution known as the base case.

Example: In Python, we can use recursion to calculate the factorial of a number.

def factorial(n):
  if n == 0:
    return 1
  else:
    return n * factorial(n-1)

print(factorial(5)) // Output: 120

In this example, the factorial function calls itself repeatedly until it reaches the base case (n == 0), at which point it returns the final result.

3️⃣ Immutability:

Variables cannot be modified after being created. This ensures that the program's state remains constant throughout its runtime.

Example: In Haskell, we can create an immutable list and then use a function to create a new list with the elements transformed.

myList = [1, 2, 3, 4, 5]

doubleList = map (*2) myList

print doubleList // Output: [2, 4, 6, 8, 10]

In this example, the myList variable is immutable, and we create a new list doubleList by applying the map function to myList. The original list remains unchanged.

For more resources on Haskell: https://www.haskell.org/documentation/

4️⃣ Pure functions:

Pure functions produce the same output if the given input is the same and have no side effects.

Example: In JavaScript, we can create a pure function that takes a string as input and returns the string with all vowels removed.

function removeVowels(str) {
  return str.replace(/[aeiou]/gi, '');
}

console.log(removeVowels("Hello World")); // Output: "Hll Wrld"
console.log(removeVowels("Hello World")); // Output: "Hll Wrld"

In this example, the removeVowels function takes a string as input and returns a new string with all vowels removed. The function has no side effects and always returns the same output given the same input.

5️⃣ High-order functions:

Functions that accept other functions as parameters or return functions as outputs.

Example: In Python, we can create a high-order function that takes another function as an argument and applies it to a list of numbers.

def applyFunction(func, numbers):
  return [func(x) for x in numbers]

def double(x):
  return x * 2

def square(x):
  return x * x

numbers = [1, 2, 3, 4, 5]

print(applyFunction(double, numbers)) // Output: [2, 4, 6, 8, 10]
print(applyFunction(square, numbers)) // Output: [1, 4, 9, 16, 25]

In this example, the applyFunction function takes another function (double or square) as an argument, and applies it to a list of numbers. The function returns a new list with the results of applying the function to each number.

Example 2: Haskell's high-order functions accept other functions as parameters or return functions as outputs.

Advantages of Functional Programming

Easy to debug: Pure functions produce the same output as the given input, making it easier to check for errors in code.
Lazy evaluation: Computations are only evaluated when needed, reducing unnecessary computations.
Supports parallel programming: Immutable variables make it easy to create parallel programs, reducing the amount of change within the program.
Easy to read: Functions are easy to read and understand, making it easier to understand the codebase and purpose.
Efficient: Functional programs don't rely on external sources or variables, making them easily reusable across the program.

Drawbacks of Functional Programming

Terminology problems: Functional programming has a lot of terminologies that may be difficult to explain to a layman.
Recursion: Although recursion is a powerful feature, it can be expensive to use, requiring higher memory usage.

Popular Functional Programming Languages

Haskell: A statically typed programming language designed specifically for functional programming.
Python: Although designed for object-oriented programming, Python supports functional programming features like lambda expressions and attributes.
Erlang: A functional programming language best suited for concurrent systems, used by messaging apps like WhatsApp and Discord.
JavaScript: Supports functional programming features like lambda expressions and attributes, making it a popular choice among multi-paradigm languages.
Clojure: A functional programming language that provides tools to avoid mutable states, supporting both mutable and immutable data types.
Scala: A language that supports both functional and object-oriented programming, designed to address the shortcomings of Java.
Rust: A systems programming language that supports functional programming concepts like immutability and recursion.
Swift: A modern programming language developed by Apple, which supports functional programming features like closures and higher-order functions.
F#: A functional programming language developed by Microsoft, which is part of the .NET ecosystem.
Lisp: A family of programming languages that are based on functional programming concepts, including Scheme and Common Lisp.
OCaml: A functional programming language developed by INRIA, which is used in a variety of applications, including web development and scientific computing.
R: A programming language and environment for statistical computing and graphics, which supports functional programming concepts like closures and higher-order functions.
Julia: A high-performance programming language that supports functional programming concepts like immutability and recursion.
Kotlin: A modern programming language developed by JetBrains, which supports functional programming features like lambda expressions and higher-order functions.
TypeScript: A statically typed programming language developed by Microsoft, which supports functional programming features like lambda expressions and higher-order functions.

NOTE:There are still many other programming languages that support functional programming concepts.

Conclusion

Functional programming is a powerful paradigm that provides efficient and scalable solutions to complex business problems. By understanding the core concepts and advantages of functional programming, developers can unlock new ways to solve problems and increase their chances of standing out in the global talent pool. Whether you're a seasoned programmer or just starting out, functional programming is definitely worth exploring.

Summary of Key Points

Functional programming is a declarative programming paradigm that focuses on applying pure functions in sequence to solve complex problems.
Core concepts of functional programming include first-class functions, recursion, immutability, pure functions, and high-order functions.
Advantages of functional programming include easy debugging, lazy evaluation, support for parallel programming, easy readability, and efficiency.
Drawbacks of functional programming include terminology problems and recursion.
Popular functional programming languages include Haskell, OCaml, Elixir, Python, Erlang, JavaScript, Clojure, and Scala.

🔴Any corrections or additions to this post are welcome.🔴

Thanks for reading

                           Happy Coding😎

Forem: Dhanush

[Boost]

Here's How To Build Fullstack Agent Apps (Gemini, CopilotKit & LangGraph)

Securing Sessions in Spring Boot

Why Session Security Matters?

Session Management Strategies

A Sample Configuration

Sample Spring Security Configuration

Benefits of Robust Session Security

Best Practices

Community Insights

LinkedIn Login, Sign in | LinkedIn

Change the Thickness of hr Tag using CSS

Introduction

Different Approaches to Change Thickness

Approach 1: Using the height and background-color Properties

Approach 2: Using the border Property

Additional Tips

Conclusion

What is the difference between static and default methods in a Java interface?

Static methods

Default methods

Java Version 24 Performance Updates: Faster and Smarter!

Java’s Journey to Becoming Faster

Key Projects Behind Java 24’s Improvements

Challenges in Performance Optimization

Top 5 Performance Improvements in Java 24

Stream Gatherers (JEP 485)

Enhanced synchronized with Virtual Threads

What’s Next for Java?

Why You Should Try Java 24

Conclusion

60 Days Habit Tracker - Productivity Tool : Github Challenge

What I Built

Demo

Repo

Copilot Experience

GitHub Models

Conclusion

Debunking the Myths: Why Learning Java is a Great Career Move

Myth #1: Java is too hard to learn

Myth #2: Java is not suitable for lightweight, quick tasks

Myth #3: Oracle Java Development Kit (JDK) is not open source

Myth #4: Java is an "old" language

Myth #5: There are too many Java programmers

Winter Solstice: Frontend Challenge - December Edition

What I Built

Key Features:

Demo

Journey

Design & Aesthetic Choices:

CSS Animations:

Learning:

Challenges:

Next Steps:

Technology Stack:

Code License:

TypeScript for Professionals

Advanced and Creative TypeScript Techniques for Professionals

Shafayet Hossain Yashfi ・ Dec 15 '24

A detailed analysis of Java Object size and its comparision with primitive data types.

How to estimate Java object size

Dayananda ・ Nov 25 '24

Git commands tips and useful guides

Git Like a Pro: 10 Things I Regret Not Knowing Earlier

chintanonweb ・ Nov 22 '24

A Guide to Functional Programming

What is Functional Programming?

Core Concepts of Functional Programming

1️⃣ First-class functions:

2️⃣ Recursion:

3️⃣ Immutability:

4️⃣ Pure functions:

5️⃣ High-order functions:

Advantages of Functional Programming

Drawbacks of Functional Programming

Popular Functional Programming Languages

Conclusion

Enhanced `synchronized` with Virtual Threads