SpringSoft

Friend Circles – Coding Interview Problem

Thu, 25 Dec 2025 00:00:00 -0500

Graph

Depth First Search

Breadth First Search

Union Find

There are N students in a class. Some of them are friends, while others are not. Friendship is transitive: - If A is a friend of B - And B is a friend of C - Then A is also a friend of C A friend circle is a group of students who are directly or indirectly friends. You must implement: int friendCircles(char[][] friends) or int friendCircles(List<String> friends)

This function returns the number of friend circles in the class.

The input friends is an N × N matrix of characters 'Y' or 'N':

friends[i][j] = 'Y' → student i and student j are friends
friends[i][j] = 'N' → they are not friends

Self‑connections such as (0,0), (1,1), (2,2) should not be counted as edges.

Example

Given the matrix:

	0	1	2	3
0	Y	Y	N	N
1	Y	Y	Y	N
2	N	Y	Y	N
3	N	N	N	Y

Interpretation

Students are labeled 0, 1, 2, 3
Each row/column pair indicates whether two students are connected
Example: In row 0, "YYNN" means:
- 0–0 → ignore (self)
- 0–1 → connected
- 0–2 → not connected
- 0–3 → not connected

Goal

Find the number of connected components in this graph, where 'Y' represents an edge.

Constraints

Time Complexity: O(N²)
Space Complexity: O(N)

Interpretation of edges

0 ↔ 1

1 ↔ 2

3 is only connected to itself (ignore self‑loops)

Graph:
(0) —– (1) —– (2)

(3)

Explanation

Students 0, 1, and 2 form one connected component (a friend circle).

Student 3 is isolated and forms its own friend circle.

So the graph has 2 friend circles.

Solution:

java

int friendCircles(List<String> friends) {
    int n = friends.size();
    boolean[] visited = new boolean[n];
    int count = 0;

    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            dfs(friends, visited, i);
            count++;
        }
    }

    return count;
}

private void dfs(List<String> friends, boolean[] visited, int student) {
    visited[student] = true;
    String connectedStudents = friends.get(student);
    for (int j = 0; j < connectedStudents.length(); j++) {
        if (connectedStudents.charAt(j) == 'Y' && !visited[j] && student != j) {
                dfs(friends, visited, j);
        }
    }
}

python

def friend_circles(friends):
    n = len(friends)
    visited = [False] * n
    count = 0

    def dfs(student):
        visited[student] = True
        for j in range(n):
            if friends[student][j] == 'Y' and not visited[j] and student != j:
                dfs(j)

    for i in range(n):
        if not visited[i]:
            dfs(i)
            count += 1

    return count

friends = [
    "YYNN",
    "YYYN",
    "NYYN",
    "NNNY"
]

print(friend_circles(friends))  # Output: 2

Time Complexity: O(N²)

Space Complexity: O(N)

Github - Finding Friend Circles

Author: Mohammad J Iqbal

Follow Mohammad J Iqbal on LinkedIn

What Is a Microservice and Why It Matters in Modern Software Architecture

Sun, 30 Nov 2025 00:00:00 -0500

In today’s fast-paced tech landscape, building scalable, maintainable applications is no longer optional—it’s essential. That’s where microservices come in. If you’ve ever struggled with bloated monolithic codebases or deployment bottlenecks, this post is for you.

We’ll break down what microservices are, why they’ve become so popular, and how they’re transforming the way we build software—with a special focus on Spring Boot.

🧱 The Monolith Problem

Traditional applications are often built as monoliths—a single, unified codebase where all features are tightly coupled. While this approach is simple to start with, it quickly becomes a nightmare as the app grows:

One bug can crash the entire system
Scaling requires duplicating the whole app
Deployments are slow and risky
Teams are blocked by dependencies

Sound familiar? That’s why companies are moving toward microservices.

🧩 What Is a Microservice?

A microservice is a small, independent service that performs a specific business function. Think of it as a self-contained module that:

Runs in its own process
Has its own database
Communicates with other services via APIs

For example, in an e-commerce app, you might have separate microservices for:

User authentication
Product catalog
Order processing
Payment gateway

Each service can be developed, deployed, and scaled independently.

🚀 Why Microservices, Why Now?

Microservices have gained traction because they solve real-world problems:

Scalability: You can scale only the services that need it
Resilience: A failure in one service doesn’t crash the whole system
Agility: Teams can work in parallel and deploy faster
Flexibility: Different services can use different tech stacks

With the rise of cloud computing, Docker, and Kubernetes, microservices are easier to manage than ever. And frameworks like Spring Boot make building them fast and intuitive.

⚖️ Pros and Cons of microservice

✅ Pros	⚠️ Cons
Independent deployment	Complex inter-service communication
Fault isolation	Requires DevOps maturity
Tech stack flexibility	Distributed debugging
Easier scaling	Higher initial setup cost

Microservices aren’t a silver bullet—but when done right, they offer a powerful way to build modern, cloud-native applications.

🔗 Next Steps

Now that you understand the “what” and “why,” it’s time to build. Head over to our tutorial:
👉 Kickstarting Microservices with Spring Boot

We’ll walk you through creating your first Spring Boot microservice, step by step.

— Mohammad, Founder of Spring-Soft

Follow Mohammad J Iqbal on LinkedIn

Kickstarting Microservices with Spring Boot: A New Chapter at Spring-Soft

Sun, 07 Sep 2025 00:00:00 -0400

Welcome to a new era at Spring-Soft—where clean code meets scalable architecture. If you’ve been following our journey, you know we’re passionate about building robust, maintainable software. Today, we’re thrilled to introduce a brand-new content series focused on Spring Boot Microservices—a modern approach to designing enterprise-grade applications that are modular, resilient, and cloud-ready.

🌱 Why Microservices, Why Now?

Monolithic applications served us well for years, but as systems grow, they become harder to scale, maintain, and deploy. Microservices solve this by breaking down applications into smaller, independent services that communicate over lightweight protocols.

With Spring Boot, developers get a powerful toolkit to build microservices quickly and efficiently:

Embedded servers (Tomcat, Jetty) for easy deployment
Auto-configuration and starter dependencies
Seamless integration with Spring Cloud for distributed systems

Whether you’re a seasoned Java developer or just stepping into backend architecture, this series will guide you through the entire journey—from concept to production.

📚 What You Can Expect

Over the coming weeks, we’ll publish tutorials, walkthroughs, and real-world examples covering topics like:

What Is a Microservice and Why It Matters in Modern Software Architecture
Building your first microservice with Spring Boot
Service discovery using Eureka
API Gateway setup with Spring Cloud Gateway
Inter-service communication with REST, Kafka, and RabbitMQ
Securing services with OAuth2 and Keycloak
Dockerizing and deploying to Kubernetes

Each blog post will be paired with a YouTube video on our channel code_design to give you hands-on guidance and visual walkthroughs.

🎯 Who This Is For

This series is crafted for:

Java developers looking to transition into microservices
Architects exploring scalable system design
Students and tech enthusiasts eager to build modern apps
Anyone who loves clean code and smart design

🔔 Stay Tuned

Our first tutorial—“Creating Your First Spring Boot Microservice”—drops next week. Follow my LinkedIn or our YouTube channel to stay updated. We promise to keep things practical, beginner-friendly, and production-focused.

Ready to break the monolith? Let’s build something scalable together.

— Mohammad, Founder of Spring-Soft

Follow Mohammad J Iqbal on LinkedIn

Java 17 Random Generation Improvement

Sun, 25 May 2025 00:00:00 -0400

In Java 17, the new RandomGenerator API was introduced to enhance the flexibility, efficiency, and variety of random number generation. Here’s how it improves upon previous random generation methods:

Improvements over `java.util.Random`

Previously, Java provided the basic Random class for generating random numbers, but:

It lacked advanced algorithms for different use cases.
Developers had limited control over random number distributions.
There were no standardized interfaces for different random algorithms.

Key Enhancements in Java 17’s Random Generator API

Multiple Random Number Algorithms
- Java 17 introduces several algorithms like:
  - L32X64MixRandom
  - L128X128MixRandom
  - L128X256MixRandom
  - Xoshiro256PlusPlus
- These offer different trade-offs in speed, unpredictability, and performance.
Unified Interface
- The new RandomGenerator interface allows developers to work with different random algorithms seamlessly:
```
RandomGenerator rng = RandomGenerator.of("L128X256MixRandom");
System.out.println(rng.nextInt(100));
```
- This makes it easy to swap out different random generation strategies without changing much code.
Better Performance & Efficiency
- Some algorithms are optimized for concurrency, meaning they work better in multi-threaded environments.
- They can be selected based on specific needs, such as cryptographic security, simulation, or statistical randomness.
Thread-Safe Implementations
- Java 17 improves parallel random number generation, reducing contention in multi-threaded applications.
- Some generators are designed for fast, scalable random number creation.
Stream-Based Random Number Generation
- Supports new methods that allow random numbers to be generated as streams:
```
rng.ints(5, 1, 100).forEach(System.out::println);
```
- Helps work seamlessly with Java’s functional programming style.

Why It’s Important

The new API standardizes random number generation, making it more efficient, flexible, and adaptable for developers. Instead of relying solely on the outdated Random class, developers can now choose the best random number algorithm for their specific use case.

Java 24 Features

Sat, 24 May 2025 00:00:00 -0400

Java 24 Features (Released March 2025)

Primitive Types in Patterns (Second Preview)
- This feature enhances pattern matching by allowing primitive types in all pattern contexts, including instanceof and switch.
Module Import Declarations (Second Preview)
- Allows importing all packages exported by a module in a more concise way.
- Simplifies modular library reuse.
Flexible Constructor Bodies (Third Preview)
- Enables statements to appear before an explicit constructor invocation (super(...) or this(...)).
- Improves reliability when initializing fields before calling another constructor.
Simple Source Files & Instance Main Methods(Fourth Preview)
- Makes it easier for beginners to write Java programs without needing complex class structures.
- Helps experienced developers write small programs more succinctly.
Quantum-Resistant Cryptography
- Introduces quantum-resistant digital signature algorithms to enhance security.
- Helps protect against future quantum computing threats.
Ahead-of-Time Class Loading & Linking [JEP 483]
- Improves startup time by making the classes of an application instantly available, in a loaded and linked state, when the HotSpot Java Virtual Machine starts. Achieve this by monitoring the application during one run and storing the loaded and linked forms of all classes in a cache for use in subsequent runs. Lay a foundation for future improvements to both startup and warmup time.
Generational Shenandoah Garbage Collector
- Improves memory management efficiency by introducing generational GC for Shenandoah.
Stream Gatherers
- Adds new methods to Stream API for more flexible data processing.
Vector API Enhancements
- Improves performance for mathematical computations using vectorized operations.
Expanded AI Support
- Enhancements in pattern matching and module imports make Java more suitable for AI-powered applications.

Java 24 is packed with improvements across performance, security, concurrency, and AI integration.

To learn more, you can check out the full details here or here

Java 22 and Java 23 Features

Fri, 23 May 2025 00:00:00 -0400

Java 22 and Java 23 continue the trend of refining existing features while introducing new enhancements focused on performance, developer productivity, and modern language improvements.

Java 22 Features (Released March 2024)

String Templates (Second Preview)
- Expands on the preview from Java 21.
- Allows embedding expressions directly inside strings.
```
String name = "Java";
String greeting = STR."Hello, \{name} 22!";
```
Scoped Values (Second Preview)
- Improves efficiency in sharing immutable data between threads.
- More optimized compared to ThreadLocal.
Vector API (Sixth Incubator)
- Enhanced support for mathematical computations using vectorization.
- Helps improve performance in data processing applications.
Foreign Function & Memory API (Finalized)
- This API is now a stable feature.
- Provides efficient interoperability with native code.
Pattern Matching for switch (Finalized)
- The feature that started as a preview is now officially part of Java.

Java 23 Features (Released September 2024)

Primitive Types in Patterns (Preview)
- Expands pattern matching capabilities to include primitive types.
- Enhances instanceof and switch statements for better performance.
Generational ZGC
- Improves memory management efficiency through a generational approach.
- Enhances garbage collection performance for large-scale applications.
Expanded Virtual Threads Features
- Further refinements in concurrency management.
- Improving performance and debugging tools.
Markdown Documentation Comments
- Introduces native Markdown support for Java documentation.
- Allows better formatting and readability in Javadoc comments.
Class-File API (Second Preview)
- Enables advanced manipulation of Java class files.
- Useful for tools and frameworks that interact with bytecode.
Performance Boost for JVM
- Includes enhancements to runtime efficiency.
- The Graal JIT Compiler further optimizes performance.

Looking Ahead

Java 22 stabilized many features previewed in Java 21, while Java 23 refines concurrency, memory management, and modern syntax improvements. These releases set the stage for Java’s continued evolution toward better efficiency and developer experience.

Java 21 features

Tue, 20 May 2025 00:00:00 -0400

Java 21 is a long-term support (LTS) release, meaning it will receive extended support and updates. This version builds upon the experimental features of previous releases and brings several refinements. Here are the key enhancements:

Java 21 Features (Released September 2023)

1. Virtual Threads (Final)

Provides lightweight threads for efficient concurrency management.

Reduces overhead compared to traditional platform threads.

   try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
  executor.submit(() -> System.out.println("Running in a virtual thread"));
   }

2. Structured Concurrency (Preview)

Simplifies parallel programming and thread management.
Ensures tasks are completed reliably, reducing concurrency bugs.

3. Pattern Matching for `switch` (Final)

Allows more expressive type matching in switch statements.

   switch (obj) {
  case String s -> System.out.println("String: " + s);
  case Integer i -> System.out.println("Integer: " + i);
  default -> System.out.println("Unknown type");
   }

4. Scoped Values (Preview)

Provides an efficient way for threads to share data.
Helps avoid reliance on ThreadLocal storage.

5. Foreign Function & Memory API (Final)

Allows Java programs to interact with native libraries without JNI.
Improves interoperability with external systems.

6. Sequenced Collections

Introduces SequencedCollection, SequencedSet, and SequencedMap.
Standardizes methods like reverse() for collections.

7. String Templates (Preview)

Allows inline expressions inside strings, similar to other language using The STR Template Processor The STR Template Processor performs string interpolation by iteratively replacing each embedded expression of the provided template with the stringified value of that expression. Below We’ll have an example of STR processor String template:

   String name = "Java";
   String message = STR."Welcome to \{name} 21!";

8. Performance and Security Improvements

General optimizations for JVM efficiency.
Enhanced security measures for safer execution.

Why Java 21 Matters

Being an LTS version, Java 21 is expected to be widely adopted by enterprises and long-term projects. It finalizes key features such as virtual threads, pattern matching, and foreign function API, making Java more modern and developer-friendly.

Java 18 to Java 20 features

Mon, 05 May 2025 00:00:00 -0400

Java 18 to Java 20 introduced several enhancements focused on performance, developer productivity, and new language features. Let’s go through each version:

Java 18 Features (Released March 2022)

Java 18 was a relatively small update but introduced useful enhancements:

UTF-8 as Default Charset
- Java now defaults to UTF-8 for encoding text across different platforms.
- Helps ensure consistency when handling text files globally.
Simple Web Server
- Introduced a built-in lightweight web server useful for development/testing:
```
jwebserver --port 8080
```
- No need for third-party tools for basic testing.
Code Snippets in Java API Documentation
- Enhances Javadoc by allowing structured code snippets for better documentation.
Vector API (Third Incubator)
- Improved vector computation support, optimizing performance for mathematical operations.

Java 19 Features (Released September 2022)

Java 19 introduced preview and incubating features paving the way for future improvements:

Virtual Threads (Preview)

Provides lightweight, high-performance threads for concurrent programming.

Significantly reduces thread management overhead:

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> System.out.println("Hello from Virtual Thread!"));
}

Structured Concurrency (Incubator)
- Helps simplify multi-threaded applications with better lifecycle management.
Foreign Function & Memory API (Second Incubator)
- Allows Java to interact efficiently with native libraries without JNI.
Pattern Matching for switch (Third Preview)
- Enhances pattern matching by allowing type-based case handling.
Linux-RISC-V Port
- Introduces official support for the RISC-V architecture in Java.

Java 20 Features (Released March 2023)

Java 20 built upon Java 19’s preview features with refinements:

Virtual Threads (Second Preview)
- More improvements to make virtual threads production-ready.
Scoped Values (Incubator)
- Optimizes data sharing between threads without relying on thread-local storage.
Structured Concurrency (Second Incubator)
- Enhances parallel programming models, making multi-threading safer.
Pattern Matching for switch (Fourth Preview)
- Extends pattern matching capabilities with richer case handling.
Foreign Function & Memory API (Third Incubator)
- Brings it closer to becoming a standard feature in Java.

Java 18 to 20 focused on performance improvements, virtual threads, enhanced concurrency, and foreign memory interactions. Java is steadily evolving toward better parallel execution and native interoperability.

Java 17 features

Sun, 04 May 2025 00:00:00 -0400

Java 17 is a long-term support (LTS) release, meaning it will receive updates and support for an extended period. It introduced several enhancements aimed at improving performance, security, and productivity. Here are the key features:

Java 17 Features (Released September 2021)

1. Sealed Classes (Final)

Restricts which classes can inherit from a superclass.
Helps enforce better design patterns.

   
   public sealed class Animal permits Dog, Cat {}
   

2. Pattern Matching for `switch` (Preview)

Allows pattern matching within switch expressions.
Makes code more concise and readable.

   
      switch (obj) {
       case Integer i -> System.out.println("Integer: " + i);
       case String s -> System.out.println("String: " + s);
       default -> System.out.println("Unknown type");
      }
   

3. New macOS Rendering Pipeline

Uses Metal API instead of the outdated OpenGL.
Improves graphical performance for macOS applications.

4. Removal of Deprecated Features

Eliminated Applet API, which was outdated.
Removed Security Manager, simplifying security handling.

5. Foreign Function & Memory API (Incubating)

Helps Java interact with native libraries without JNI.
Improves interoperability with external code.

6. New `RandomGenerator` API

Provides improved and flexible random number generation.

   RandomGenerator rng = RandomGenerator.of("L128X256MixRandom");
   System.out.println(rng.nextInt(100));
   

Java 17 solidifies many preview features from previous versions and sets the stage for modern Java development. It’s particularly valuable for enterprise applications due to its LTS status.

Java 12 to Java 16 features

Sat, 03 May 2025 00:00:00 -0400

Java 12 to Java 16 brought steady improvements, refining features and introducing new enhancements. Let’s break it down:

Java 12 Features (Released March 2019)

Switch Expressions (Preview)

Allowed switch to return a value in a more concise way:

var result = switch (day) {
    case MONDAY, FRIDAY -> "Busy day!";
    case SATURDAY, SUNDAY -> "Weekend!";
    default -> "Regular day.";
};

Improves readability and eliminates repetitive break statements.

Improved Garbage Collection
- Introduced Shenandoah GC, reducing pause times for large heaps.
- Enhanced performance in memory management.

Compact Number Formatting

Helps format numbers in a human-readable way:

NumberFormat formatter = NumberFormat.getCompactNumberInstance(Locale.US, NumberFormat.Style.SHORT);
System.out.println(formatter.format(1000)); // Outputs "1K"

Java 13 Features (Released September 2019)

Text Blocks (Preview)
- Enables easier multiline string handling:
```
String json = """
    {
        "name": "Java",
        "version": 13
    }
    """;
```
- Improves readability and reduces escape sequences.
Enhancements to Switch Expressions
- Further refinement of switch case for clearer structure.

Java 14 Features (Released March 2020)

Records (Preview)
- Introduced a simpler way to create immutable data carriers:
```
record Person(String name, int age) {}
```
- Reduces boilerplate code in POJOs.

Pattern Matching for instanceof (Preview)

Eliminates redundant casting:

if (obj instanceof String str) {
    System.out.println(str.length());
}

Helpful NullPointerException Messages
- Improves debugging by clearly indicating what was null.

Java 15 Features (Released September 2020)

Text Blocks (Final)
- Multiline strings were finalized after previews in Java 13 & 14.
Sealed Classes (Preview)
- Restricts inheritance to specific subclasses:
```
public sealed class Animal permits Dog, Cat {}
```
Hidden Classes
- Allows creating runtime classes that aren’t visible outside their defining class loader.

Java 16 Features (Released March 2021)

Records (Final)
- Records became a permanent part of Java.
Pattern Matching for instanceof (Final)
- Officially part of the language after preview versions.

Improved Stream API

Added toList() method for easier list conversion:

Stream<String> stream = Stream.of("A", "B", "C");
List<String> list = stream.toList();

Java 12 to 16 focused on refining usability, improving syntax, and optimizing performance.

SpringSoft

Friend Circles – Coding Interview Problem

Example

Interpretation

Goal

Constraints

What Is a Microservice and Why It Matters in Modern Software Architecture

🧱 The Monolith Problem

🧩 What Is a Microservice?

🚀 Why Microservices, Why Now?

⚖️ Pros and Cons of microservice

🔗 Next Steps

Kickstarting Microservices with Spring Boot: A New Chapter at Spring-Soft

🌱 Why Microservices, Why Now?

📚 What You Can Expect

🎯 Who This Is For

🔔 Stay Tuned

Java 17 Random Generation Improvement

Improvements over java.util.Random

Key Enhancements in Java 17’s Random Generator API

Why It’s Important

Java 24 Features

Java 24 Features (Released March 2025)

Java 22 and Java 23 Features

Java 22 Features (Released March 2024)

Java 23 Features (Released September 2024)

Looking Ahead

Java 21 features

Java 21 Features (Released September 2023)

1. Virtual Threads (Final)

2. Structured Concurrency (Preview)

3. Pattern Matching for switch (Final)

4. Scoped Values (Preview)

5. Foreign Function & Memory API (Final)

6. Sequenced Collections

7. String Templates (Preview)

8. Performance and Security Improvements

Why Java 21 Matters

Java 18 to Java 20 features

Java 18 Features (Released March 2022)

Java 19 Features (Released September 2022)

Java 20 Features (Released March 2023)

Java 17 features

Java 17 Features (Released September 2021)

1. Sealed Classes (Final)

2. Pattern Matching for switch (Preview)

3. New macOS Rendering Pipeline

4. Removal of Deprecated Features

5. Foreign Function & Memory API (Incubating)

6. New RandomGenerator API

Java 12 to Java 16 features

Java 12 Features (Released March 2019)

Java 13 Features (Released September 2019)

Java 14 Features (Released March 2020)

Java 15 Features (Released September 2020)

Java 16 Features (Released March 2021)

Improvements over `java.util.Random`

3. Pattern Matching for `switch` (Final)

2. Pattern Matching for `switch` (Preview)

6. New `RandomGenerator` API