Optimize Java Collections for Performance

Command-line parser libraries don't have to be big to support everything you need, like subcommands, validators, and Java-agent-style argument parsing: Introducing femtocli, with a 45KB JAR file. Read more at https://lnkd.in/dFkPmweU

🚀 What is a Stateless Bean in Spring? 👉 A stateless bean is a bean that doesn’t remember anything between method calls. No stored data. No previous context. Just pure logic. Every time you call a method: It works only on the input you pass It does not depend on past calls Once the method finishes, that’s it Think of it like this: 🧠 A stateless bean has no memory 📥 Input comes in → ⚙️ logic runs → 📤 output goes out This is why most Service classes in Spring are designed to be stateless: ✅ Better performance ✅ Easier to scale ✅ Thread-safe by default 💡 Big takeaway If your business logic doesn’t need to store user-specific or session-specific data, keeping your beans stateless is a clean and professional design choice. Still learning , and sharing what clicks for me along the way 🚀 If you’re learning or revising core Spring concepts, this one is worth remembering. #SpringFramework #Java #BackendDevelopment #LearningInPublic #JavaDeveloper #SpringBoot #SoftwareEngineering

📌 Spring Boot Annotation Series – Part 5 ✅ @Bean Ever wondered how Spring creates objects that are not annotated with @Component? That’s where @Bean comes in 👇 🔹 Why do we use @Bean? @Bean tells Spring: 👉 “Create an object from this method and manage it as a bean.” It is mainly used when: 1) We want full control over object creation 2) We are using third-party classes 3) We cannot add Spring annotations to a class 🔹 When do we use @Bean? To create beans manually For objects like: - RestTemplate - ObjectMapper - DataSource When configuration logic is required 🔹 Simple example @Configuration public class AppConfig { @Bean public RestTemplate restTemplate() { return new RestTemplate(); } } 🔹 In simple words @Bean is used to tell Spring what object to create and manage when auto-scanning is not enough. ⭐ Important note @Bean is usually used inside a @Configuration class. By default, beans created using @Bean are singleton. 👉 🧠 Quick Understanding @Bean is a spring annotation used to explicitly declare a method as a bean producer. When a method is annotated with @Bean , Spring will execute that method and register its return value as a bean in the Spring application context. #SpringBoot #Java #Bean #BackendDevelopment #LearningInPublic

📌 Spring Boot Annotation Series – Part 13 ✅ @Autowired annotation The @Autowired annotation is used for Dependency Injection in Spring 👇 🔹 What is @Autowired? @Autowired tells Spring: 👉 “Inject the required dependency automatically.” Spring looks for a matching bean in the container and injects it. 🔹 Why do we use @Autowired? To avoid manual object creation (new keyword) To reduce tight coupling To let Spring manage dependencies 🔹 Where can we use @Autowired? On fields On constructors ✅ (recommended) On setter methods 🔹 Simple example @Service public class UserService { } @RestController public class UserController { @Autowired private UserService userService; } Here, Spring automatically injects UserService into UserController. 🔹 In simple words @Autowired allows Spring to automatically inject required objects instead of creating them manually. 👉 🧠 Quick Understanding - Used for dependency injection - Removes need for new keyword - Constructor injection is best practice #SpringBoot #Java #Autowired #DependencyInjection #BackendDevelopment #LearningInPublic

I accidentally found a way to make any LeetCode solution beat 100% of submissions. Not with a better algorithm, but with this hack, literally any solution, even a bad one, can beat 100%. Here’s how it started. I was solving a normal LeetCode problem, and I was wondering even with the best possible algorithm and optimization, I was beating just 86% of solutions. Then I started scrolling through top submissions, and I noticed something weird. A few Java solutions had this tiny block of code sitting quietly at the top. No explanation. No comments. So I dug in. Turns out, this block registers a JVM shutdown hook. When the program finishes executing and the JVM is about to exit, it writes 0 into a file called display_runtime.txt So what happens is: 1. Your solution runs at normal speed 2. LeetCode measures the runtime 3. JVM starts shutting down 4. Shutdown hook runs 5. The runtime value gets overwritten with 0 6. LeetCode proudly displays 0 ms (Beats 100%) That’s it. PS: I do think platforms like LeetCode should patch this kind of thing, not because it’s dangerous, but because it gives people the wrong signal about what "good" code actually means. Still, it's fun to discover. And it's even more fun to understand why it works.

Stop writing 50 lines of code for a simple Data Object! 🛑 Still creating traditional POJOs with endless getters, setters, hashCode(), and toString()? You’re making your codebase heavy for no reason. Enter Java Records (The game changer since Java 14/16) ⚡ The Problem: Earlier, if you wanted a simple User object, you had to write a massive block of code. It was hard to read and even harder to maintain. The Solution: With Records, you define the state, and Java takes care of the rest. Check this out: 👇 // Traditional Way (The Boring Way 😴) public class User { private final Long id; private final String name; public User(Long id, String name) { this.id = id; this.name = name; } // + Getters, hashCode, equals, toString... (40+ lines!) } // The Modern Way (The Pro Way 😎) public record User(Long id, String name) {} Why you should switch TODAY: ✅ Immutability: Fields are final by default. ✅ Conciseness: One line replaces an entire file. ✅ Readability: Focus on the "What" instead of the "How". ✅ Built-in Methods: No more manual equals() or toString() bugs. If you are still using Lombok’s @Data or @Value, give Records a try—they are native, lightweight, and super clean. Are you already using Records in your production code? Or do you prefer the classic Class approach?Let's settle this in the comments! 👇 #Java #BackendDevelopment #CleanCode #Java17 #SoftwareEngineering #CodingTips #Programming #TechCommunity

Spring Boot Pagination & Sorting Made Simple! Working with large datasets? Showing everything at once can kill performance and user experience. That’s where pagination and sorting come in! ✅ Pagination: Breaks data into pages. You define: page → which page you want (0-based) size → how many records per page ✅ Sorting: Controls the order of results: Sort.by("field").ascending() or .descending() Combine with pagination using PageRequest.of(page, size, sort) Pageable pageable = PageRequest.of(0, 5, Sort.by("firstName").ascending()); Page<UserEntity> page = userRepository.findAll(pageable); Pagination + sorting = better performance, faster APIs, and happy users! 😎 #SpringBoot #Java #SpringDataJPA #Pagination #Sorting #BackendDevelopment

🚀 Backend Revision | Day 4 – Spring Beans & Stereotype Annotations Day 4 of my backend revision journey was all about understanding Spring Beans and how the Spring container manages application components efficiently. 🔹 Spring Beans A Spring Bean is simply a Java object that is created, managed, and destroyed by the Spring container. Spring takes full responsibility for: •Object creation •Dependency injection •Lifecycle management •Scope handling (Singleton, Prototype, etc.) Instead of manually creating objects using new, Spring promotes Inversion of Control (IoC), allowing the framework to manage dependencies automatically. 🔹 Stereotype Annotations Spring provides stereotype annotations to clearly define the role of each class in the application architecture: @Component •Generic stereotype •Used for any Spring-managed class •Base annotation for others @Service •Used in the business/service layer •Improves code readability and clarity •Represents business logic @Repository •Used in the data access layer (DAO) •Automatically translates database exceptions into Spring’s DataAccessException hierarchy 🔑 Key Takeaway Stereotype annotations help Spring: •Identify application components •Apply layer-specific behaviors •Maintain clean, readable, and maintainable architecture Each annotation plays a vital role in building scalable and loosely coupled applications. #SpringFramework #SpringBoot #BackendDevelopment #Java #IoC #DependencyInjection #LearningJourney 

A few knobs in ConcurrentHashMap that can save you from a resize storm or from a contention induced long tail latency You know that moment when your app hits load and everything's fighting for the same resource? Here's a quiet lever most of us walk past or forget: new ConcurrentHashMap<>(initialCapacity, loadFactor, concurrencyLevel) That third parameter — concurrencyLevel — is a hint to the JDK: "expect roughly this many threads writing at once." It uses this to size the internal table upfront. More buckets from the start = less contention, fewer resizes under pressure. The default works fine for many cases. But if you know your workload — say, 16 or 32 writer threads hitting it hard at startup — you can give the map a head start. It's one of those small, zero-cost changes that can smooth out your throughput curve when it matters most. Wait! Plot twist: that third parameter — concurrencyLevel — is mostly vestigial since Java 8. Pre-Java 8, it actually created that many Segment locks. Now? It's just a floor for initial capacity. If your initialCapacity is already larger, it's ignored entirely. What actually matters now: Initial capacity — size it right to avoid resize storms under load Hash quality — poor distribution causes bin collisions, which means synchronized blocks on the same head node The map uses CAS for empty bins (fast path) and synchronized per-bin when occupied So if you're tuning for high concurrency, focus on: Pre-sizing capacity based on expected entries Ensuring your keys have good hash distribution

💡 Sometimes the biggest debugging sessions end with the smallest fixes. Recently, a friend reached out saying their Spring Boot API wasn’t returning any data. No errors, No exceptions, Just… empty responses. We assumed it was something serious: - Database issue? - Transaction problem? - Mapping error? - Serialization issue? We checked: ✔ Entity mappings ✔ Repository queries ✔ Logs ✔ API responses ✔ Even database records directly Everything looked correct. After almost an hour of digging… We found the actual issue. 👉 The API request parameter name didn’t match the method parameter name. The controller had: @RequestParam("userId") But the frontend was sending: userid Just a small case mismatch. Spring couldn’t bind the value correctly — so it returned empty results. - One tiny detail. - One simple mismatch. - One hour of overthinking. Big lesson: Before assuming complex failures, always verify the small things. In backend development, sometimes the problem isn’t architecture — it’s a lowercase letter. #Java #SpringBoot #BackendDevelopment #Debugging #ProblemSolving #SoftwareEngineering #Developers #CodingLife #TechCommunity #Programming #Learning