Thiago Souza’s Post

One of the key lessons I've learned as a developer is that you can’t rely solely on reading articles or documentation to truly grasp concepts or techniques. To really understand, you have to face real-world problems and work through them to come up with a solution. Here's a story from today: I’ve been working on my Course Management Project and building an API to fetch a user by their ID. In my code, I declared the return type of the method as ResponseEntity<UserDTO>. However, inside the method, I was returning a ResponseEntity<ApiResponseDTO<UserDTO>> instead. Strangely, I wasn’t seeing any compile-time errors in my IDE. After hours of debugging, I discovered the issue wasn’t with my IDE—it was actually a Java concept called type erasure. For those unfamiliar, type erasure in Java means that generic type information (like UserDTO, ApiResponseDTO<UserDTO>, etc.) is erased at runtime. So, at runtime, the ResponseEntity only holds a reference to Object, and the specific types like UserDTO or ApiResponseDTO<UserDTO> are lost. This is why even though my method signature specified ResponseEntity<UserDTO>, passing an ApiResponseDTO<UserDTO> didn’t cause a compile-time error. However, this can lead to logical errors. At runtime, I was expecting a UserDTO as the response body, but was instead returning an ApiResponseDTO<UserDTO>. Lesson learned: understanding concepts like type erasure is crucial when working with Java generics, as it can prevent subtle bugs from creeping into your code. #Java #TypeErasure #Generics #APIDevelopment #BackendDevelopment #CourseManagement #Debugging #SoftwareEngineering #LearningByDoing #ProgrammingTips #FullStackDeveloper #CodeJourney #ProblemSolving

🌟 𝐔𝐧𝐝𝐞𝐫𝐬𝐭𝐚𝐧𝐝𝐢𝐧𝐠 𝐉𝐚𝐯𝐚 𝐌𝐞𝐦𝐨𝐫𝐲 𝐌𝐚𝐧𝐚𝐠𝐞𝐦𝐞𝐧𝐭: 𝐀 𝐃𝐞𝐞𝐩 𝐃𝐢𝐯𝐞 𝐢𝐧𝐭𝐨 𝐆𝐚𝐫𝐛𝐚𝐠𝐞 𝐂𝐨𝐥𝐥𝐞𝐜𝐭𝐢𝐨𝐧 🌟 Java memory management is a crucial concept for any developer, but it often poses challenges. One tricky aspect is 𝐆𝐚𝐫𝐛𝐚𝐠𝐞 𝐂𝐨𝐥𝐥𝐞𝐜𝐭𝐢𝐨𝐧 (𝐆𝐂), which ensures efficient memory use by reclaiming unused objects. Here's a quick overview: 𝟏. 𝐆𝐞𝐧𝐞𝐫𝐚𝐭𝐢𝐨𝐧𝐚𝐥 𝐆𝐚𝐫𝐛𝐚𝐠𝐞 𝐂𝐨𝐥𝐥𝐞𝐜𝐭𝐢𝐨𝐧: • 𝐘𝐨𝐮𝐧𝐠 𝐆𝐞𝐧𝐞𝐫𝐚𝐭𝐢𝐨𝐧: Short-lived objects are stored here. The Minor GC quickly removes objects that are no longer in use. • 𝐎𝐥𝐝 𝐆𝐞𝐧𝐞𝐫𝐚𝐭𝐢𝐨𝐧: Long-lived objects that survived multiple Minor GCs. The Major GC or Full GC cleans this space. 𝟐. 𝐆𝐂 𝐀𝐥𝐠𝐨𝐫𝐢𝐭𝐡𝐦𝐬: • 𝐒𝐞𝐫𝐢𝐚𝐥 𝐆𝐂: Single-threaded, suitable for small applications. • 𝐏𝐚𝐫𝐚𝐥𝐥𝐞𝐥 𝐆𝐂: Multi-threaded, for high throughput applications. • 𝐂𝐌𝐒 (𝐂𝐨𝐧𝐜𝐮𝐫𝐫𝐞𝐧𝐭 𝐌𝐚𝐫𝐤-𝐒𝐰𝐞𝐞𝐩) 𝐆𝐂: Low pause time, suitable for applications needing quick response times. • 𝐆𝟏 (𝐆𝐚𝐫𝐛𝐚𝐠𝐞 𝐅𝐢𝐫𝐬𝐭) 𝐆𝐂: Balances throughput and pause time, ideal for large heaps. 𝟑. 𝐓𝐮𝐧𝐢𝐧𝐠 𝐆𝐂: • Proper GC tuning can significantly enhance performance. Key parameters include heap size (-Xms, -Xmx), and GC algorithm flags (-XX:+UseG1GC). 𝟒. 𝐂𝐨𝐦𝐦𝐨𝐧 𝐏𝐢𝐭𝐟𝐚𝐥𝐥𝐬: • 𝐌𝐞𝐦𝐨𝐫𝐲 𝐋𝐞𝐚𝐤𝐬: Ensure references are cleared when objects are no longer needed. • 𝐇𝐢𝐠𝐡 𝐆𝐂 𝐎𝐯𝐞𝐫𝐡𝐞𝐚𝐝: Monitor GC logs to avoid excessive GC cycles. Understanding and tuning Java's GC can lead to significant performance improvements, making it a vital skill for any Java developer. 🛠️ Let's connect and share insights on mastering Java and backend development! 🚀 #Java #SpringBoot #BackendDevelopment #GarbageCollection #MemoryManagement #Programming #TechTips

𝗨𝗻𝗹𝗼𝗰𝗸 𝘁𝗵𝗲 𝗣𝗼𝘄𝗲𝗿 𝗼𝗳 𝗝𝗮𝘃𝗮 𝗦𝘁𝗿𝗲𝗮𝗺𝘀 𝗶𝗻 𝗬𝗼𝘂𝗿 𝗖𝗼𝗱𝗲! Java Streams are a game-changer for modern developers, offering a functional and declarative approach to process data efficiently. Introduced in Java 8, the Stream API empowers you to write concise, readable, and maintainable code while boosting performance. Whether you're filtering, mapping, or aggregating data, Streams simplify complex operations and make your code shine. 𝗪𝗵𝘆 𝗨𝘀𝗲 𝗝𝗮𝘃𝗮 𝗦𝘁𝗿𝗲𝗮𝗺𝘀? - 𝗖𝗹𝗲𝗮𝗻𝗲𝗿 𝗖𝗼𝗱𝗲: Say goodbye to bulky for-loops. Streams let you focus on 𝘄𝗵𝗮𝘁 you want to achieve, not 𝗵𝗼𝘄 to do it. - 𝗟𝗮𝘇𝘆 𝗘𝘃𝗮𝗹𝘂𝗮𝘁𝗶𝗼𝗻: Operations are executed only when needed, saving time and memory. - 𝗣𝗮𝗿𝗮𝗹𝗹𝗲𝗹 𝗣𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴: Effortlessly process large datasets in parallel with `.parallelStream()`. - 𝗜𝗺𝗺𝘂𝘁𝗮𝗯𝗶𝗹𝗶𝘁𝘆: Streams don't modify the original data source, promoting safer programming practices. - 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝗦𝘁𝘆𝗹𝗲: Embrace a modern programming paradigm with operations like `map`, `filter`, and `reduce`. 𝗞𝗲𝘆 𝗙𝗲𝗮𝘁𝘂𝗿𝗲𝘀 𝗼𝗳 𝗝𝗮𝘃𝗮 𝗦𝘁𝗿𝗲𝗮𝗺𝘀 1. 𝗣𝗶𝗽𝗲𝗹𝗶𝗻𝗲 𝗣𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴: Combine multiple operations (filter → map → reduce) into a single pipeline. 2. 𝗜𝗻𝘁𝗲𝗿𝗺𝗲𝗱𝗶𝗮𝘁𝗲 & 𝗧𝗲𝗿𝗺𝗶𝗻𝗮𝗹 𝗢𝗽𝗲𝗿𝗮𝘁𝗶𝗼𝗻𝘀: Transform data step-by-step and produce final results. 3. 𝗗𝗶𝘃𝗲𝗿𝘀𝗲 𝗦𝗼𝘂𝗿𝗰𝗲𝘀: Create streams from collections, arrays, files, or even infinite generators. 𝗪𝗵𝗲𝗻 𝘁𝗼 𝗨𝘀𝗲 𝗦𝘁𝗿𝗲𝗮𝗺𝘀? - Transforming collections into new formats. - Filtering data based on conditions. - Aggregating results (sum, average). - Handling large datasets with parallelism. But here's the real question for you: How have Java Streams transformed your coding experience? Do you prefer their functional elegance over traditional loops? Share your thoughts in the comments below! Let's spark a conversation about how we can leverage this powerful tool in our daily development. #Java #Streams #FunctionalProgramming #BackendDevelopment #CodingTips

🚀 Day 17 of 100: Harnessing the Power of Stream API 🚀 Today, let's dive into the world of Stream API in Java! Stream API, introduced in Java 8, revolutionized the way we work with collections and process data. It provides a declarative approach to perform operations on collections, making code more concise, readable, and expressive. Here's why Stream API is a game-changer: 1. 𝙁𝙪𝙣𝙘𝙩𝙞𝙤𝙣𝙖𝙡 𝙋𝙧𝙤𝙜𝙧𝙖𝙢𝙢𝙞𝙣𝙜: Stream API embraces functional programming principles, allowing developers to write code in a more declarative style. With operations like map, filter, and reduce, developers can express complex data processing logic in a concise and intuitive manner. 2. 𝙇𝙖𝙯𝙮 𝙀𝙫𝙖𝙡𝙪𝙖𝙩𝙞𝙤𝙣: Stream API uses lazy evaluation, meaning operations are only performed when needed. This leads to more efficient memory usage and improved performance, especially when working with large datasets. 3. 𝙋𝙖𝙧𝙖𝙡𝙡𝙚𝙡𝙞𝙨𝙢: Stream API seamlessly integrates with parallel processing, enabling developers to leverage multi-core processors for concurrent execution of stream operations. This can significantly speed up computation-intensive tasks. 4. 𝙋𝙞𝙥𝙚𝙡𝙞𝙣𝙚 𝙊𝙥𝙚𝙧𝙖𝙩𝙞𝙤𝙣𝙨: Stream API supports method chaining, allowing developers to create pipelines of operations to process data sequentially. This enables a fluent and composable programming style, where each operation builds upon the previous one. 5. 𝙄𝙣𝙩𝙚𝙧𝙤𝙥𝙚𝙧𝙖𝙗𝙞𝙡𝙞𝙩𝙮: Stream API is designed to work seamlessly with existing collection classes in Java, making it easy to integrate into existing codebases. It also integrates well with other features introduced in Java 8, such as lambda expressions and method references. Whether you're performing data manipulation, filtering, or aggregation, Stream API offers a powerful and elegant solution for processing collections in Java. Stay tuned for more insights and discoveries as we continue our journey through Java and beyond! 💻☁️ #StreamAPI #Java #FunctionalProgramming #100DaysOfCode Let's unlock the full potential of Stream API and streamline our data processing workflows! 🌟✨

As developers, we are always striving for cleaner, more efficient code. Today, I wanted to highlight two annotations in Spring Boot that are incredibly powerful yet often underutilized: @PrePersist and @PreUpdate. These annotations, part of the Java Persistence API (JPA), offer a way to execute logic right before an entity is persisted or updated in the database, respectively. In practice, they can simplify the management of entity states and ensure that important computations or validations happen automatically. Take a look at the Cart entity below from my project, which leverages both @PrePersist and @PreUpdate annotations and why I use them here: #Consistency: Every time a Cart entity is created or updated, the totalAmount is automatically calculated based on the items in the cart, ensuring the value is always up to date. #Simplified_Logic: Instead of manually recalculating the total every time a cart item is added or removed, I let the lifecycle callback take care of it automatically before persisting or updating the entity. #Cleaner_Code: By using these annotations, I keep the logic within the entity itself rather than cluttering the service layer with additional calculations. These two annotations are invaluable tools in making your codebase more efficient and maintainable. When used wisely, @PrePersist and @PreUpdate can eliminate repetitive tasks and reduce the likelihood of errors. #SpringBoot #JPA #PrePersist #PreUpdate #Java #Persistence #CleanCode #DevLife #BackendDevelopment

In today's blog post, we dive into custom Spliterators in Java, which are powerful tools for enhancing stream operations. But implementing them requires careful consideration of performance implications. Improper use can lead to increased complexity and potential performance bottlenecks, especially in data-intensive applications. We'll explore how to create a custom Spliterator that implements shifting, sliding, zipping, and folding operations on streams. We'll see why these operations are useful and how they can optimize data processing in various scenarios. #100DaysOfJava Day 81: Did you know that custom Spliterators can supercharge your Java streams? 🚀💻Creating custom stream operations ex: Slide, Shift, Zip and Fold using Spliterator https://lnkd.in/gMB5-U_a #100daysofcode #softwareengineering #java #programming #100daysofjava

#SpringBootCode 𝗖𝗼𝗱𝗲 𝗦𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 𝗗𝗲𝗯𝗮𝘁𝗲 1. Writing code in a single file. 2. Writing code across different files and connecting them. 𝐖𝐡𝐢𝐜𝐡 𝐚𝐩𝐩𝐫𝐨𝐚𝐜𝐡 𝐝𝐨 𝐲𝐨𝐮 𝐭𝐡𝐢𝐧𝐤 𝐢𝐬 𝐛𝐞𝐭𝐭𝐞𝐫? 𝗥𝗲𝘃𝗲𝗮𝗹𝗶𝗻𝗴 𝘁𝗵𝗲 𝗦𝗲𝗰𝗿𝗲𝘁: A new programmer joined a company. On his first day , his boss assigned him a project, and his task was to debug the code. 𝑻𝒉𝒆 𝒑𝒓𝒐𝒃𝒍𝒆𝒎?The entire code was written in a single file, making it messy and time-consuming to debug. In contrast, another programmer chose a different approach by creating a 𝒍𝒂𝒚𝒆𝒓𝒆𝒅 𝒂𝒑𝒑𝒍𝒊𝒄𝒂𝒕𝒊𝒐𝒏 using Spring Boot. She separated the code into different files and layers: 1. 𝗖𝗼𝗻𝘁𝗿𝗼𝗹𝗹𝗲𝗿 𝗟𝗮𝘆𝗲𝗿- annotated with @Controller. 2. 𝗦𝗲𝗿𝘃𝗶𝗰𝗲 𝗟𝗮𝘆𝗲𝗿- annotated with @Service. 3. 𝗥𝗲𝗽𝗼𝘀𝗶𝘁𝗼𝗿𝘆 𝗟𝗮𝘆𝗲𝗿 - annotated with @Repository. Each layer has a distinct purpose: 1. 𝗧𝗵𝗲 𝗥𝗲𝗽𝗼𝘀𝗶𝘁𝗼𝗿𝘆 𝗟𝗮𝘆𝗲𝗿(𝗗𝗔𝗢 𝗰𝗹𝗮𝘀𝘀)- handles data storage logic, and the DataSource object is injected into the DAO class. 2. 𝗧𝗵𝗲 𝗦𝗲𝗿𝘃𝗶𝗰𝗲 𝗟𝗮𝘆𝗲𝗿 contains business logic, with the DAO object injected into the service class. 3. 𝗧𝗵𝗲 𝗖𝗼𝗻𝘁𝗿𝗼𝗹𝗹𝗲𝗿 𝗟𝗮𝘆𝗲𝗿 connects with the client application , with the service object injected into the controller class. Dependency injection is handled using @Autowired, making each layer independent and easily manageable. 𝑺𝒕𝒂𝒚 𝒕𝒖𝒏𝒆𝒅 𝒂𝒔 𝑰 𝒔𝒉𝒂𝒓𝒆 𝒎𝒚 𝒎𝒊𝒏𝒊-𝒑𝒓𝒐𝒋𝒆𝒄𝒕 𝒕𝒐 𝒓𝒆𝒕𝒓𝒊𝒆𝒗𝒆 𝒆𝒎𝒑𝒍𝒐𝒚𝒆𝒆 𝒅𝒆𝒕𝒂𝒊𝒍𝒔 𝒇𝒓𝒐𝒎 𝒂𝒏 𝑶𝒓𝒂𝒄𝒍𝒆-𝒃𝒂𝒔𝒆𝒅 𝑬𝑴𝑷 𝒕𝒂𝒃𝒍𝒆! Follow me for dev tech knowledge! #Java #SpringBootMicroservices #SoftwareDeveloper

🌟 Elevate Your Java Game with Immutable DTOs Using Records 🌟 Are you tired of writing endless boilerplate code for Data Transfer Objects (DTOs) as a Java developer? Say hello to Java Records, a more elegant and efficient solution that streamlines your code and enhances maintainability. 💡 What Are Java Records? Java Records, introduced in Java 14, revolutionize clean, concise, and immutable code creation. They simplify the process of building classes focused on data storage by automating constructors, getters, equals(), hashCode(), and toString() methods—no extra lines needed. Why Should You Care? 🔒 Immutability: Ensure data consistency and security from the get-go with Records' immutable nature. ✂️ Less Boilerplate, More Focus: Trim down repetitive code to concentrate on essential logic. Cleaner code translates to fewer bugs and faster development. 🚀 Clarity and Intent: Instantly recognize Records as straightforward data carriers, boosting team collaboration and code review efficiency. Spring Boot Compatibility For Spring Boot users (especially from version 2.4 onwards), Records seamlessly integrate, particularly with libraries like Jackson, making them ideal for REST APIs and data-centric applications. Why Now? As microservices and APIs take center stage, the need for manageable, immutable DTOs grows. Java Records provide a modern, best-practice-aligned approach to software design, ensuring your code stays relevant in today's dynamic landscape. #java #springboot #spring #programming

🌱 Today, I dived into key Spring Core concepts! 🚀 Here’s what I learned: 1. Inversion of Control (IoC) 🔄: Delegating object creation and management to the Spring framework instead of doing it manually.     Example: Spring container 🧰 creates objects and injects dependencies. 2. Dependency Injection (DI) 💉: Providing dependencies from an external source rather than creating them inside the class.     Example: Injecting a `Service` class into a `Controller` 🎯. 3. Constructor Injection 🏗️: Dependencies are injected via the constructor.     Example:     ```java   public class MyService {       private final MyRepository repo;       public MyService(MyRepository repo) { this.repo = repo; }   }   ``` 4. Setter Injection 🛠️: Dependencies are injected through public setter methods.     Example:     ```java   public void setRepo(MyRepository repo) { this.repo = repo; }   ``` 5. Field Injection 📥: Dependencies are injected directly into fields.     *Example*:     ``java   @Autowired private MyRepository repo;   ``` 6. Component Scanning 🔍: Automatically detects and registers beans 🌱 in the Spring container.     Example: `@Component` with `@ComponentScan` annotation. 7. @Qualifier 🎯: Specifies which bean to inject when multiple beans of the same type exist.     Example: `@Qualifier("specificBean")` 8. @Primary ⭐: Marks a bean as the default choice when multiple beans of the same type are available.     Example: `@Primary` on a bean. 9. Lazy Initialization 💤: Delays the creation of beans until they are needed.     Example: `@Lazy` on a bean class. Loving the journey with Spring so far! 🌟💻 #SpringBoot #Java #DependencyInjection #InversionOfControl #BackendDevelopment #Learning #Tech #DeveloperJourney 💡

🌟 Master Core #Java with #OOPs Concepts! 🚀 🌟 🔑 Core Principles of OOP 1️⃣ Encapsulation 🔹 Wrap data and code together into a single unit—the class. 🔹 Think of it as a protective shield for your data! 2️⃣ Inheritance 🔹 Reuse and extend existing functionality by creating new classes based on old ones. 🔹 Why reinvent the wheel? 🚗 3️⃣ Polymorphism 🔹 A single interface, multiple implementations. 🔹 Achieved via method overloading and overriding. 4️⃣ Abstraction 🔹 Hide complex details and show only the essentials—the what, not the how. 🔹 Achieved with abstract classes and interfaces. 🔑 Key Features Every Java Programmer Should Know 🔹 Classes & Objects: Classes are blueprints, objects are their real-world representations. 🔹 Constructors: Special methods to initialize objects, giving them life! 🔹 Access Modifiers: Control who sees what—private, protected, public, default. 🔑 Advanced OOP Concepts to Shine Bright ✨ Static vs. Non-Static: Master class-level vs. instance-level methods and variables. ✨ Final Keyword: Protect classes, methods, or variables from unwanted changes. ✨ Abstract Classes vs. Interfaces: Know when to use each to keep your design clean. ✨ Object Class: The parent of all Java classes—learn its superpowers like toString() and hashCode(). 💡 OOP in Real Life From banking systems to e-commerce platforms and games, OOP is everywhere! Its principles make code reusable, modular, and easier to debug—a must-have skill for any developer! 📚 Ready to dive deeper into Java OOPs? This is your gateway to mastering frameworks like Spring and Hibernate. Start building, innovating, and coding like a pro today! 🌐 #JavaProgramming #OOPsConcepts #LearnJava #Code #ProgrammingTips #JavaDeveloper #CoreJava #TechSkills #CodingJourney #Java #SoftwareDevelopment #OOPs