Harshana's blog

G1 Garbage Collector Explained G1 Garbage Collector Explained In G1 GC, the heap is divided into equal-sized regions. Each region can belong to one of the following categories: Eden : Where new objects are allocated. Survivor : Where objects that survive an initial garbage collection are moved. Old : Where objects that have survived multiple garbage collections are promoted. Humongous : Where very large objects that do not fit into a standard region are allocated. Key Concepts 1. Region-Based Memory Management : Each region is typically between 1 MB and 32 MB. The number of regions and their size can be controlled via the -XX:G1HeapRegionSize parameter. 2. Young and Old Generation : Unlike traditional generational collectors that have contiguous spaces for young and old generations, G1 has regions that can dynamically change their role. Young Ge

Software Engineering Principles: DRY, KISS, and YAGNI Software Engineering Principles: DRY, KISS, and YAGNI DRY (Don't Repeat Yourself) Principle: The DRY principle emphasizes the importance of reducing repetition within code. Repetition can lead to more errors, higher maintenance costs, and inconsistency. When the same piece of code or logic appears in multiple places, it should be abstracted out into a single location that can be reused. Example: Without DRY: public class Calculator { public int add(int a, int b) { return a + b; } public int subtract(int a, int b) { return a - b; } public int multiply(int a, int b) { return a * b; } public double divide(int a, int b) { return a / b; } public int addAndSubtract(int a, int b, int c) { return a + b - c; // repeated addition and subtraction logic } } With DRY: public class Ca

Understanding C1 and C2 Compilers in Java Understanding C1 and C2 Compilers in Java In Java, the Just-In-Time (JIT) compiler is a part of the Java Virtual Machine (JVM) that improves the performance of Java applications by compiling bytecode into native machine code at runtime. The JIT compiler includes two different compilers, known as the C1 and C2 compilers, each with distinct optimization strategies and purposes. C1 Compiler (Client Compiler) The C1 compiler, also known as the client compiler, is designed for fast startup times and lower memory consumption. It performs lighter and quicker optimizations, which makes it suitable for applications that require quick startup and responsiveness. Key characteristics of the C1 compiler include: Quick Compilation: Prioritizes fast compilation times over deep optimizations. Low Overhead: Consumes less memory and resources during compilation. Profile-Guided Optimization: Ca

Understanding -XX:+PrintCompilation Output in Java Understanding -XX:+PrintCompilation Output in Java The -XX:+PrintCompilation flag in the Java Virtual Machine (JVM) prints information about the methods being compiled by the Just-In-Time (JIT) compiler. When you enable this flag, the JVM will output a log of compilation events to the standard output. Each line of the output provides information about a specific method being compiled. Here, I'll explain the meaning of the different columns and markers, specifically focusing on the n , s , and % markers as seen in your example. Explanation of Output Columns and Markers Here's a breakdown of what each column and marker means: Timestamp : The time (in milliseconds) since the JVM started when the compilation event occurred. Compilation ID : A unique identifier for each compilation task within the JVM's lifecycle. Optimization Level : The lev

What is and usage of Just-in-time Compilation Just-in-time Compilation Explained Just-in-time (JIT) compilation is a feature of many modern runtime environments, including the Java Virtual Machine (JVM), which improves the performance of interpreted code. Here's an explanation of JIT compilation and its use: What is Just-in-time Compilation? Just-in-time (JIT) compilation is a process where the bytecode of an interpreted language (like Java) is compiled into native machine code at runtime, rather than prior to execution. This compiled code is then executed directly by the CPU, which is much faster than interpreting the bytecode line by line. How JIT Compilation Works Bytecode Interpretation : Initially, the JVM interprets the bytecode. Interpretation involves converting bytecode into machine code instruction by instruction, which is relatively slow. Profiling and Hot Spot Detection :

what is the value of using Iterable over List in java? what is the value of using Iterable over List in java? Using Iterable over List in Java can provide several benefits, particularly in terms of flexibility and abstraction. Here are some key points that highlight the value of using Iterable : 1. Decoupling and Abstraction Flexibility in Implementation Iterable is a more general interface compared to List . While List is a specific type of collection that guarantees ordered elements and allows indexed access, Iterable can be implemented by any collection that can be iterated over, including Set , Queue , Map (for its keySet , values , or entrySet ), and custom collection types. Using Iterable allows your code to be more flexible and work with a broader range of collection types, not just List . Code Reusability Methods that accept Iterable can be reused with different types of collections. This makes your APIs more ver

Are static variables re-initialized and stored multiple times in memory when instance of a class is created? No, static variables are not re-initialized or stored multiple times in memory when instances of a class are created. Here is how static variables work in Java: Characteristics of Static Variables: Single Instance per Class : A static variable is associated with the class itself, rather than with any specific instance of the class. This means that no matter how many instances of the class you create, there will always be only one copy of the static variable. Memory Allocation : Static variables are allocated memory only once, when the class is loaded into memory by the Java Virtual Machine (JVM). This allocation happens in the method area (part of the JVM's memory), which is separate from the memory areas used for instance variables (which are stored in the heap). Initialization : Static variables are initialized once, at th

In Java, incrementing a variable by one can be done in several ways: n++ , n = n + 1 , and n += 1 . While these expressions achieve the same end result, they differ slightly in syntax and use cases. Let's explore each one and discuss their performance. 1. n++ Post-Increment Operator : Increments the value of n by 1 after its current value has been used. Common Usage : Typically used in loops and other contexts where the current value needs to be used before incrementing. int n = 5; n++; // n is now 6 2. n = n + 1 Addition Assignment : Explicitly sets n to its current value plus 1. Readability : Straightforward and clear, though slightly more verbose. int n = 5; n = n + 1; // n is now 6 3. n += 1 Compound Assignment Operator : Equivalent to n = n + 1 , but more concise. Usage : Combines addition and assignment into one step. int n = 5; n += 1; // n is