Author: Sergio Lema
-
Spring Security 6 OAuth 2.1: Replacing Implicit Grant and ROPC with PKCE
If your Spring Security config still uses the Implicit Grant or Resource Owner Password flow, you’re running on borrowed time. This post breaks down why OAuth 2.1 makes PKCE mandatory, kills legacy flows, and shows the exact config difference between a legacy setup and a production-hardened one.
-
Why JavaScript Floating Point Math Breaks Your App (And How to Fix It)
JavaScript’s IEEE 754 floating point format means 0.1 + 0.2 !== 0.3 — and that’s just the obvious case. This post covers why it happens, where it silently breaks production code, and four concrete strategies: toFixed for display, integer arithmetic for money, a scale-round-ceil pattern for computed floats, and decimal.js for complex chains.
-
Fullstack 2026: Building the Modern Spring Boot 3.4 and React 19 Architecture
After 15 years in the industry, the author emphasizes the need for simplicity in development. The post discusses using Spring Boot 3.4 and React 19 to streamline setups by eliminating boilerplate, automating infrastructure, and enhancing developer experience. Key strategies include Docker integration, virtual threads, and proxy configurations for efficient development.
-
The JVM Stack: A Developer’s Quick Guide
This content explains the difference between stack and heap memory in Java, highlighting their roles in memory allocation. The stack is thread-specific, efficient, and short-lived, while the heap is shared across threads and managed by the Garbage Collector. Understanding these concepts helps prevent common errors like StackOverflowError and OutOfMemoryError.
-
Choosing a Deployment Strategy: A Developer’s Guide to Canary, Blue-Green, and Rolling Updates
Effective deployment strategies are crucial for developers post-code commit. Blue-Green, Canary, and Rolling Updates cater to different needs, balancing factors like cost, risk, and release frequency. Understanding these strategies helps ensure smooth transitions without downtime, optimizing user experience while managing potential issues and resource allocation.
-
Google Sign-In for React Native: The Complete Setup Guide That Actually Works
Integrating Google Sign-In in a React Native app involves configuring Firebase and Google Cloud Console, managing SHA-1 fingerprints, and using the @react-native-google-signin library. Common issues arise post-deployment due to silent failures linked to mismatched fingerprints, emphasizing the need for accurate configuration across environments. Proper setup is crucial for a smooth user experience.
-
Spring @Transactional is Not Magic: The Proxy Trap and Why Your Data Isn’t Safe
**Most developers treat @Transactional like a magic wand, but it is actually a proxy-based abstraction that is remarkably easy to break.** If you do not understand Java AOP, you are likely creating “zombie data” and performance bottlenecks without even knowing it. This post deconstructs the **self-invocation trap**, the **rollback myth of checked exceptions**, and why…
-
The Microservices Tax: Why Your Distributed Architecture is Failing You
Stop treating microservices like a trophy and start treating them like a tax. While we are told they decouple teams and improve scale, most developers are simply trading code complexity for unreliable network calls and distributed data corruption. If you can’t maintain clean boundaries in a monolith, moving to microservices will only result in a…
-
The Singleton Delusion: Why Your Implementation is Probably Broken
Most developers treat the Singleton pattern like a relic from 2010—something they “know” but haven’t actually audited in years. We’ve been conditioned to believe Singletons are “evil” or “hard to test,” leading to a trend of pulling in massive Dependency Injection frameworks just to manage a single Logger instance. This resume-driven development adds unnecessary bloat…
-
How to Use System Design in Your React Project
As React projects evolve, maintaining a clean structure becomes crucial. Implementing a system design, particularly a feature-based folder structure, enhances organization. Utilizing the principles of Atomic Design helps create reusable UI components. Building foundational components ensures consistency, improving scalability, and navigation, ultimately leading to more maintainable applications over time.
The Dev World - Sergio Lema 