Introduction A few days ago, someone asked me has Java 8 reached the end of its life, and should we upgrade to Java 11 or Java 17. If you have the same question, let’s try to understand the situation, and do you need an upgrade or you can wait? You should consider upgrading to a newer version of Java to ensure security, performance, and ongoing support, but Java 8 has a complex End-of-Life (EOL) situation. ...

Introduction In the world of software development, frameworks like Spring have streamlined the process of building complex applications. Spring’s fundamental pillar is its Inversion of Control (IoC) container. This container masterfully manages the lifecycles of your application components known as beans. A vital aspect of this management is understanding bean scopes. What Exactly are Bean Scopes? Bean scopes are blueprints that dictate how the Spring container creates and manages bean instances within your application. Let’s break it down: ...

Introduction In the realm of networking, Anycast IP addresses represent a fascinating concept that has become increasingly popular due to its ability to enhance performance, scalability, and reliability of services across distributed networks. This blog post aims to delve into the intricacies of Anycast, exploring its underlying principles, mechanics, use cases, and considerations for implementation. What is Anycast? Anycast is a networking technique that allows multiple servers to advertise the same IP address. When a client sends a request to this shared IP address, the routing infrastructure directs the request to the nearest or best-performing server based on network conditions such as proximity, latency, or routing metrics. ...

Introduction Embeddings are numerical representations of concepts converted to number sequences, which make it easy for computers to understand the relationships between those concepts. Whether it’s natural language processing, computer vision, recommender systems, or other applications, embeddings play a crucial role in enhancing model performance and scalability. Text embeddings measure the relatedness of text strings. Embeddings are commonly used for: Search (where results are ranked by relevance to a query string) Clustering (where text strings are grouped by similarity) Recommendations (where items with related text strings are recommended) Anomaly detection (where outliers with little relatedness are identified) Diversity measurement (where similarity distributions are analyzed) Classification (where text strings are classified by their most similar label) Embedding vector from a string ...

Introduction In the realm of distributed systems, robust communication between microservices is paramount. Kafka, with its high throughput and fault-tolerant design, has become a go-to solution for building scalable messaging systems. However, ensuring message reliability in asynchronous communication can be challenging, especially when dealing with failures and errors. One approach to handle such scenarios is the use of a Dead Letter Queue (DLQ), which acts as a safety net for messages that couldn’t be processed successfully on their initial attempt. ...

SOLID is an acronym that represents a set of five design principles in object-oriented programming and software design. These principles aim to create more maintainable, flexible, and scalable software by promoting a modular and clean code structure. The SOLID principles were introduced by Robert C. Martin and have become widely adopted in the software development industry. Here’s a brief overview of each principle: Single Responsibility Principle (SRP): A class should have only one reason to change, meaning that it should have only one responsibility or job. This principle encourages the separation of concerns and helps to ensure that a class is focused on doing one thing well. // Before SRP class Report { public void generateReport() { // code for generating the report } public void saveToFile() { // code for saving the report to a file } } // After SRP class Report { public void generateReport() { // code for generating the report } } class ReportSaver { public void saveToFile(Report report) { // code for saving the report to a file } } Open/Closed Principle (OCP): Software entities (classes, modules, functions, etc.) should be open for extension but closed for modification. This encourages developers to add new functionality through the creation of new classes or modules rather than altering existing ones. // Before OCP class Rectangle { public double width; public double height; } class AreaCalculator { public double calculateArea(Rectangle rectangle) { return rectangle.width * rectangle.height; } } // After OCP interface Shape { double calculateArea(); } class Rectangle implements Shape { private double width; private double height; // constructor and other methods @Override public double calculateArea() { return width * height; } } class Circle implements Shape { private double radius; // constructor and other methods @Override public double calculateArea() { return Math.PI * radius * radius; } } Liskov Substitution Principle (LSP): Subtypes should be substitutable for their base types without altering the correctness of the program. This principle ensures that objects of a derived class can be used in place of objects of the base class without affecting the program’s functionality. // Before LSP class Bird { public void fly() { // code for flying } } class Ostrich extends Bird { // Ostrich is a bird, but it can't fly } // After LSP interface FlyingBird { void fly(); } class Sparrow implements FlyingBird { @Override public void fly() { // code for flying } } class Ostrich { // Ostrich doesn't implement FlyingBird, as it can't fly } Interface Segregation Principle (ISP): Clients should not be forced to depend on interfaces they do not use. It advocates for the creation of small, specific interfaces rather than large, general-purpose ones, to avoid clients being forced to implement methods they don’t need. // Before ISP interface Worker { void work(); void eat(); void sleep(); } class Engineer implements Worker { @Override public void work() { // code for working } @Override public void eat() { // code for eating } @Override public void sleep() { // code for sleeping } } // After ISP interface Workable { void work(); } interface Eatable { void eat(); } interface Sleepable { void sleep(); } class Engineer implements Workable, Eatable, Sleepable { @Override public void work() { // code for working } @Override public void eat() { // code for eating } @Override public void sleep() { // code for sleeping } } Dependency Inversion Principle (DIP): High-level modules should not depend on low-level modules. Both should depend on abstractions. Abstractions should not depend on details; details should depend on abstractions. This principle promotes the use of abstractions (like interfaces or abstract classes) to decouple high-level and low-level modules, making the system more flexible and easier to change. // Before DIP class LightBulb { public void turnOn() { // code for turning on the light bulb } public void turnOff() { // code for turning off the light bulb } } class Switch { private LightBulb bulb; public Switch(LightBulb bulb) { this.bulb = bulb; } public void operate() { // code for operating the switch if (/* some condition */) { bulb.turnOn(); } else { bulb.turnOff(); } } } // After DIP interface Switchable { void turnOn(); void turnOff(); } class LightBulb implements Switchable { @Override public void turnOn() { // code for turning on the light bulb } @Override public void turnOff() { // code for turning off the light bulb } } class Switch { private Switchable device; public Switch(Switchable device) { this.device = device; } public void operate() { // code for operating the switch if (/* some condition */) { device.turnOn(); } else { device.turnOff(); } } } Adhering to SOLID principles can result in code that is easier to understand, maintain, and extend. These principles contribute to the overall goal of creating robust and scalable software systems.

Introduction Logging is an essential aspect of software development, aiding in debugging, monitoring, and analyzing application behavior. In Spring applications, Aspect-Oriented Programming (AOP) offers a powerful mechanism to separate cross-cutting concerns like logging from the business logic. By employing AOP, developers can modularize logging code and apply it uniformly across multiple components, enhancing maintainability and readability. Understanding AOP in Spring Aspect-Oriented Programming enables the modularization of cross-cutting concerns by allowing developers to define aspects, which encapsulate certain behavior. In Spring, AOP is typically implemented using proxies and advice. Proxies intercept method invocations and execute advice either before, after, or around the method call. ...

jps (Java Process Status) Usage: Sample Usage: Understanding the Output: jstat (JVM Statistics Monitoring Tool) Usage: Sample Usage: Understanding the Output: jcmd (JVM Diagnostic Command) Usage: Sample Usage: Understanding the Output: jmap (Memory Map for Java) Usage: Sample Usage: Understanding the Output: Conclusion Java applications often run in complex and dynamic environments, making it essential to monitor their performance and diagnose issues efficiently. Fortunately, the Java Development Kit (JDK) comes with a set of powerful tools for this purpose. In this guide, we will explore four essential tools: jps, jstat, jcmd, and jmap. We’ll discuss their functionalities, sample usage, and how to interpret their output effectively. ...

Let’s Learn Javascript. Embark on an exciting journey into the world of web development as we unravel the mysteries of JavaScript, the backbone of interactive and dynamic web experiences. Let’s start with some questions Where does JavaScript code run? Originally designed to run exclusively in browsers, JavaScript has undergone a transformation with the advent of Node.js. Created by Ryan Dahl in 2009, Node.js allows JavaScript code to run outside the browser environment. This means developers can use JavaScript to build the backend for web and mobile applications. Each browser has its JavaScript engine, like SpiderMonkey in Firefox and V8 in Chrome. Node.js incorporates Google’s V8 JavaScript engine into a C++ program, providing a runtime environment for executing JavaScript code outside the browser. In summary, JavaScript code can run both in a browser and in Node.js, broadening its application possibilities ...

Introduction In distributed systems, maintaining data consistency across multiple systems is a challenging task. One common problem that arises is the dual write problem, where updates to multiple data stores must be performed atomically to prevent data inconsistencies. In this blog post, we’ll explore how to tackle the dual write problem using the outbox pattern in conjunction with Apache Kafka. Understanding the Dual Write Problem The dual write problem occurs when data needs to be written to multiple systems, and ensuring consistency between them becomes crucial. For instance, imagine an e-commerce application where an order is placed and data must be simultaneously written to a database and a messaging system like Kafka for further processing. If one write succeeds but the other fails, data inconsistency arises. ...