DEV Community: Akam Chidi

YAML Guide For Beginners: Learn YAML In 10 Minutes

Akam Chidi — Tue, 15 Jul 2025 15:42:08 +0000

As a Software Engineer, Cloud Engineer, SRE, or DevOps engineer, YAML is one language you must understand well. Most of the configuration files you will read or write will be in YAML.

That is why it is important that you know how to not just read YAML as a language but also understand how to create files in YAML too.

This article will take you through all you need to know about the YAML. You will also learn how to read and write YAML files, including their format and syntax.

Before reading this post, you need to have a basic understanding of programming. Most importantly, you need to know about data and objects in programming.

What Is YAML

YAML, also known as “YAML A’int No Markup Language” is a human readable data serialization language. It is a data format that is used to store and exchange data.

As the name implies, YAML is not like any other Markup language like HTML. It is more like a language, used to represent serialized data in a text format.

To understand YAML better, you first need to understand the concept of serialization and deserialization of data. The next session will explain this in detail.

Understanding Serialization and Deserialization

Serialization is the process of converting data objects or complex data structures into small, manageable chunks of data, also known as a stream of bytes.

In other words, serialization converts complex data objects to a form that is easily transmitted and read on different systems. The serialization process ensures that the state of the data is preserved during the transmission process.

The stream of bytes can be transferred in a YAML file format, a database, or memory. This way, the data can be read by different systems or programming languages.

Deserialization on the other hand, is the process of converting a stream of bytes to a data object or complex data structure.

"It is good to mention at this point that YAML is not a programming language and cannot be used to add commands. You only use it to store data."

Why Use YAML?

As you may know, there are other serialization languages out there, like JSON and XML. YAML seems to be the most popular and preferred option.

Here are some of the reasons why YAML is preferred over other serialization languages:

Readable: YAML is simple to read and write. It is easier for non-programmers to read and understand YAML than JSON.
Popularity: YAML is very popular and is used in most programming languages.
Easy To Convert To Other Serialization Languages: It is easy to convert an input in YAML to JSON and XML. You write the input in YAML and get the output in JSON or XML.
Additional Tools: YAML has various tools available to enhance its functionality. Example of these are Passers and Lens IDE.
Functionalities: The language has additional functionalities that other alternatives do not accommodate. For instance, comments. You can write comments in YAML which comes in handy for future reference.

Use Cases Of YAML

The main use case of YAML is to create configuration files for Kubernetes, Docker containers, Ansible, GitHub Actions, and many more. Also, it is used for logs and cache in networking.

Create a YAML File

To create a YAML file, add a “.yaml” or “.yml” extension to the file. This indicates that the file is written in YAML.

Data Types In YAML

YAML has the same data types and data structures as most programming languages out there. It has

integers
strings
Booleans
floats
null
lists
dictionaries.

---

#Integer in YAML
password: 010

#String in YAML
password: Hello
password2: "Hello World"
password: 010

#Boolean in YAML
test: false
deploy: true

#Float in YAML
product_price: 37.89

#Null in YAML
user_name: null

#List in YAML
states:
    - new york
    - florida
    - texas
    - ohio

#Dictionary In YAML
product:
  product_name: mobile phone
  brand: samsung
  price: 230
  color: black

Also, you can specify the data type in YAML by adding two exclamation marks, then the data type.

nomba: !!int 10
float: !!float 27.5
boolean: !!bool true
string: !!str jay 
null: !!null Null

Rules For Writing In YAML

YAML has a strict syntax format. These are some of the rules to bear in mind when writing in YAML:

Indentation is essential. Preferably two space indentations.
Keys in dictionaries are case sensitive.
Always maintain a space after the colon.
Start your list with a dash “-“and no space.
Include --- at the start of any YAML file.

YAML Writing Format and Syntax

Understanding the format and syntax of YAML will help you write and read any file in YAML Language.

a. Key Value:

This contains one key and one value.

---
password: 0000

b. List:

A List is used when an object has multiple values. It is similar to an array in some programming languages.

You can create a list using the inline or block format. The inline format is more readable and is most commonly used. A list can contain a single data type or a mixed data type.

---

# Inline List:

user_detail:
  - username
  - email
  - password

#Block List: 

user_detail: [username, email, password]

i. Mixed List: contains a mixture of different data types
single data list: similar data types.

---
# Mixed List: 

user_detail:
  - jay
  - 2020
  - active
  - 73.9

ii. Nested List: As the name implies, a nested list contains multiple lists with. One or more lists are nested in a parent list.

---
# Nested List in YAML: 

product:
  - product_name: phone
    brands:
      - apple
      - samsung
      - redmi
      - zero
  - colors: mobile
    os:
      - android
      - ios
      - windows mobile

c. Dictionary:

is an object with one or multiple key-value pairs.

---
# Dictionary In YAML: 

user:
  name: obi
  age: 32
  city: manchester

i. Mixed Dictionary: Is made of multiple data types. It is mostly a combination of key-value pairs, single values and lists.

---
# Mixed Dictionary:

user: 
  name: obi
  age: 32
  city: lagos
  products: 
    - phone
    - glasses
    - shoes
  user_login: 
    username: jay
    email: j@gmail.com
    password: 1009

ii. Nested Dictionary: Is made up of more than one dictionaries. Here, two or more dictionaries is nested inside a parent dictionary.

---
# Nested Dictionaries in YAML:

product:
  name: mobile
  description:
    brand: samsung
    os: android
  price:
    pro: 700
    promax: 950

d. Anchor and Alias

This is similar to a function or method in most programming languages. It is used to create a piece of reusable “code” in YAML.

You create an anchor to define the content of the object and use alias to refer to the anchor. You write an anchor with “&” and alias with “*”.

---
# Anchor and Alias in YAML

user_details: &user1
  username: jay
  age: 32
  password: 0001
  email: j@gmail.com

  adduser: 
    <<: *user1
    add: true

e. Document

This is used to create multiple documents in a single YAML file. Use “---” to separate the documents.

---
# Document in YAML

username: jay
  age: 32
  password: 0001
  email: j@gmail.com

---

username: chidi
  age: 30
  password: 0002
  email: c@gmail.com

f. Comments in YAML

It was mentioned earlier that YAML allows comments. Comments notify the compiler or interpreter to ignore a line or block of code. You write a comment by add “#” to the beginning of the line of code.

YAML does not support multiple lines of comments. To include a comment in a block of code, adding “#” at the beginning of each line of code.

# ignore this line of code.

Validate YAML

There are ways to validate the accuracy of YAML as you write. One way to do that is to use the YAML validator site. Paste your YAML code in the file and click on YAML-Validator to check the accuracy of your YAML write-up.

Final Thoughts

So far, this article has covered the basics of YAML. That includes data types, use cases for YAML, writing format, and writing rules. At this point, you should be able to write and understand the format of any YAML file you read.

Exception Handling In Java

Akam Chidi — Fri, 11 Jul 2025 13:48:07 +0000

When you run a Java code or program, it will either compile and execute or throw an error. When a code throws an, it’s a result of either an error or an exception.

An error is more critical. It occurs outside the scope of the code but within the environment in which the application is running. The program is not expected to catch and handle an error.

Some examples of errors are

OutOfMemoryError
VirtualMachineError
StackOverFlowError

Exceptions occur within the scope of the code. It is also known as execution error which means that it occurs during the execution of the code. The programmer is expected to catch and handle exceptions in a program.

This post will focus more on exceptions and runtime errors specifically. You will learn all about exceptions and how to handle exception errors in your Java program.

Types of Execution Errors In Java

There are three types of execution errors in Java. Here is a breakdown of each of them

. Compile-Time Error

This type of error is known as compilation error or checked error. A Java program throws this code during the compilation stage.

In other words, this error occurs when the Javac code is being compiled to bytecode. The compile-time error is usually caused by an error in the code syntax.

For instance, when the programmer fails to add a semicolon at the end of a statement or fails to initialize a variable before printing.


public class JavaExceptionCodes {
    public static void main (String []args){
        int y = 10      //no semicolon
        System.out.println(y);
    }

}

. Run-Time Error

The run-time error is also known as the exception error or unchecked error. It occurs as the program is being executed. The code will compile but will throw an error during runtime.

The runtime error can be further classified into built-in exceptions or user-defined exceptions. Examples of built-in exceptions include:

ArrayIndexOutOfBoundsException
ArithmeticException
FileNotFoundException
NullPointerException

For instance if a user inputs an int instead of a string or inserts values bigger than the size of an array.

public class JavaExceptionCodes {
    public static void main (String []args) {
        int nombas[] = {1, 2, 3, 4, 5};
        System.out.println(nombas[6]); 

    }
}
//ArrayIndexOutOfBoundsException

. Logical Error

Also known as semantic error, it occurs if there is an error in a program’s logical output. For instance, 3 + 3 shows an output of 7, or when you log into your account and land on another profile.

The compile-time error is the easiest to catch because your IDE will always point out this error to the programmer. Logical error most times is the hardest error to see because the code will throw no compile time or runtime error.

Concept of Exception Handling

Exception handling is used to catch errors in a program and maintain the normal flow of the execution of a program. Usually, once a program throws an error, the code will stop executing.

Catching and handling errors beforehand will enable the program to skip the block of code with errors and continue executing the rest of the program.

Exception Handling Methods:

Try – Catch – Finally – Throw – Throws are the list of methods for exception handling in Java. Let’s break each of them in detail with examples:

. Try

Try is used to enclose a line or blocks of code that may throw an exception. There is also a nested try which is a try with an inner try block (s). They serve the same purpose.

Syntax

try{

}

. Catch

The catch is a block of code used to catch errors thrown in the try block.

Syntax

try{

}
catch (Exception e){

}

multiple catch blocks

public class JavaExceptionCodes {
    public static void main (String []args) {
        int x = 10;
        int y = 0;
        int z ;
        int nombas [] = {5, 6, 7, 8, 9};
        try {
            System.out.println(z = x / y);
            System.out.println(nombas[6]);
        }
        catch (ArithmeticException e){
            System.out.println("Can't divide by 0. Choose another number" + e);
        }
        catch(ArrayIndexOutOfBoundsException e){
            System.out.println("Array Out Of Bound" + e);
        }
        System.out.println("End");
    }
}

. Finally

Finally, is an optional block of code, that is usually placed after the try and catch code blocks. It is used to execute important codes. The finally block is always executed whether the program throws an error or not.

Syntax

try{

}
catch (Exception e){

}
finally{

}

. Throw

Throw is a keyword used to throw an exception inside a method or block of code.

Syntax


public class JavaExceptionCodes {
    public static void main (String []args) {

           try { throw new ArithmeticException("Try Run");
           }
           catch (ArithmeticException e){
               System.out.println("Catch Exception Error");
           }

    }
}

. Throws

Unlike the throw keyword, the throws keyword is not used to throw an exception. However, it specifies that there may be an exception in the method. The Throws is used in the method signature and not inside the method.

Best Practices For Handling Exceptions

A try block can have several statements (lines of code). It is best to create multiple catch blocks to catch the error in each statement.
Always specify the type of exception if you are working with multiple catch blocks.
If there are multiple statements in a try block and you don’t know the statement with the error, create a final general exception at the end of other exceptions to catch unknown errors.
Always place the general exception catch block at the end of the other custom exception catch blocks.

Authentication Vs Authorization In Backend Systems

Akam Chidi — Thu, 30 Jan 2025 11:36:08 +0000

The backend system of any application handles sensitive data. That includes operations to create, modify, store, retrieve, and delete data when needed.

It is important to know who can access and modify these data, so security checks and systems are put in place to limit who can access them.

Authentication and authorization are part of the security systems that are put in place to secure sensitive data in backend systems.

Understanding Authentication In Backend Systems

Authentication involves checking the identity of a user or users before providing access to the system or app. It is used to verify user credentials before granting access to an entire system or specific functionality.

Understanding Authorization In Backend Systems

Authorization checks if a user(s) has the authority(ies) to access a resource in an application. In other words, authorization confirms if a user is authorized or has the authorization to access a specific functionality in an app or not.

Importance Of Authentication and Authorization In A Backend System

As mentioned, authentication and authorization are both security systems that help secure sensitive data in any backend system. Each of them has a distinct role in securing the APIs and data in the backend system of any application.

Difference Between Authentication and Authorization

Let’s explore the differences between authentication and authorization and the role each plays in backend system security.

	Authentication	Authorization
Use Case	Checks User ID or log in details. Verifies log in details and provide access.	Checks for User authorization to access a resource or functionality.
When Invoked	Authentication is done before authorization.	Authorization is done after authentication.
Requirement	Requires User ID or Login Details.	Requires User Role or Privileges.
Error Response	Returns a 401 Error Response if authentication fails.	Returns a 403 Error Response if authorization fails.
Summary	Authentication verifies a User's Identity.	Authorization checkmates what a User is allowed to do after the User's identity has been verified.

Real Case Scenario Of Concepts

If you’re still finding it hard to differentiate between these concepts, here is a real case scenario to help you understand better.

For instance, a bank application. A customer and bank employee can access the bank application. Both are considered as users. The customer or bank employee trying to access the bank app has to input a valid email address and password into the bank application.

The function of the authentication system is to ensure that the username and password entered by either the customer or the employee are valid. After verifying these details, both the customer and employee can access the bank app.

Authorization on the other hand will be used to determine the roles and authorities of the user to checkmate the functionality the user can access on the app. In this instance, the bank employee will have access to the database of customers, which the customer can’t access.

In Summary

So far, this post has explained authentication and authorization in detail and the roles both concepts play in securing the backend system of an application. This is an introductory post. Subsequent posts will handle security architecture and more complex details.

Exception Handling In Java

Akam Chidi — Tue, 23 Jul 2024 17:56:16 +0000

When you run a Java code or program, it will either compile and execute or throw an error. When a code throws an, it’s a result of either an error or an exception.

An error is more critical. It occurs outside the scope of the code but within the environment in which the application is running. The program is not expected to catch and handle an error.

Some examples of errors are

OutOfMemoryError
VirtualMachineError
StackOverFlowError

This post will focus more on exceptions and runtime errors specifically. You will learn all about exceptions and how to handle exception errors in your Java program.

Types of Execution Errors In Java

There are three types of execution errors in Java. Here is a breakdown of each of them

. Compile-Time Error

This type of error is known as compilation error or checked error. A Java program throws this code during the compilation stage.

In other words, this error occurs when the Javac code is being compiled to bytecode. The compile-time error is usually caused by an error in the code syntax.

For instance, when the programmer fails to add a semicolon at the end of a statement or fails to initialize a variable before printing.


public class JavaExceptionCodes {
    public static void main (String []args){
        int y = 10      //no semicolon
        System.out.println(y);
    }

}

. Run-Time Error

The run-time error is also known as the exception error or unchecked error. It occurs as the program is being executed. The code will compile but will throw an error during runtime.

The runtime error can be further classified into built-in exceptions or user-defined exceptions. Examples of built-in exceptions include:

ArrayIndexOutOfBoundsException
ArithmeticException
FileNotFoundException
NullPointerException

For instance if a user inputs an int instead of a string or inserts values bigger than the size of an array.

public class JavaExceptionCodes {
    public static void main (String []args) {
        int nombas[] = {1, 2, 3, 4, 5};
        System.out.println(nombas[6]); 

    }
}
//ArrayIndexOutOfBoundsException

. Logical Error

Also known as semantic error, it occurs if there is an error in a program’s logical output. For instance, 3 + 3 shows an output of 7, or when you log into your account and land on another profile.

Concept of Exception Handling

Exception handling is used to catch errors in a program and maintain the normal flow of the execution of a program. Usually, once a program throws an error, the code will stop executing.

Catching and handling errors beforehand will enable the program to skip the block of code with errors and continue executing the rest of the program.

Exception Handling Methods:

Try – Catch – Finally – Throw – Throws are the list of methods for exception handling in Java. Let’s break each of them in detail with examples:

. Try

Try is used to enclose a line or blocks of code that may throw an exception. There is also a nested try which is a try with an inner try block (s). They serve the same purpose.

Syntax

try{

}

. Catch

The catch is a block of code used to catch errors thrown in the try block.

Syntax

try{

}
catch (Exception e){

}

multiple catch blocks

public class JavaExceptionCodes {
    public static void main (String []args) {
        int x = 10;
        int y = 0;
        int z ;
        int nombas [] = {5, 6, 7, 8, 9};
        try {
            System.out.println(z = x / y);
            System.out.println(nombas[6]);
        }
        catch (ArithmeticException e){
            System.out.println("Can't divide by 0. Choose another number" + e);
        }
        catch(ArrayIndexOutOfBoundsException e){
            System.out.println("Array Out Of Bound" + e);
        }
        System.out.println("End");
    }
}

. Finally

Syntax

try{

}
catch (Exception e){

}
finally{

}

. Throw

Throw is a keyword used to throw an exception inside a method or block of code.

Syntax


public class JavaExceptionCodes {
    public static void main (String []args) {

           try { throw new ArithmeticException("Try Run");
           }
           catch (ArithmeticException e){
               System.out.println("Catch Exception Error");
           }

    }
}

. Throws

Best Practices For Handling Exceptions

A try block can have several statements (lines of code). It is best to create multiple catch blocks to catch the error in each statement.
Always specify the type of exception if you are working with multiple catch blocks.
If there are multiple statements in a try block and you don’t know the statement with the error, create a final general exception at the end of other exceptions to catch unknown errors.
Always place the general exception catch block at the end of the other custom exception catch blocks.

Memory Management and Garbage Collection In Java

Akam Chidi — Tue, 28 May 2024 13:58:06 +0000

As a Java developer, memory management and garbage collection is one topic you need to understand well. If you are having issues understanding these concepts, no need to worry.

This post will explain the entire concepts in details while giving examples. At the end of this post, you should understand the following concepts well:

Memory Management in Java
Garbage Collection in Java
Types of Memory in Java
Garbage Collection Process
Types of Garbage Collectors in Java

Introduction To Concepts

There are some basic concepts you need to know that will help you understand this topic better.

. Memory In Java:

This refers to the allocated space where objects, variables and data are stored in the process of executing a java application. In other words, every variable, object or other data types the developer inputs in the process of creating a java program is stored in memory.

. Memory management:

Memory Management is the process of allocation and deallocation of memory space for objects during the exaction of an application. This process takes place in the Java Virtual Machine JVM.

. Garbage Collection:

This, on the other hand is the process of cleaning up the memory space. How it works is that the garbage collector identifies and removes objects that are no longer referenced in the heap memory.

In some programming languages like C and C++, it's the work of the programmer to manually handle the memory management process. The programmer is expected to manually allocate and deallocate memory space while creating the application.

Thankfully, Java handles the process automatically via garbage collection. The garbage collection process is better than manual because it helps to prevent the issue of dangling reference. You will understand how the garbage collection process works later in this post.

. Dangling Reference:

This error occurs when a reference or pointer still points to a memory location in the heap memory that has been reallocated or removed.

Types Of Memory In Java

As mentioned earlier, memory in Java is the space where data is stored during the process of executing a program. There are three types of memory spaces in Java. They include:

Stack Memory
Heap Memory
MetaSpace Memory

Let’s explain each of the memory types in details now.

. Stack Memory:

The stack memory is the section of the memory where method invocation takes place. Method invocation happens when a new method is created, a scope is created in the stack memory to store the data in the method. That includes, local variables and parameters.

The stack memory is always smaller than the heap memory. Also, during the garbage collection process, the stack memory gets cleaned up first. The process happens automatically when a method is done executing.

The types of data that is stored in the Stack memory includes:

Primitive Values/ Temporary Variables.
Memory block for methods (Scope).
Reference of an object. Note that the object itself is stored in the heap memory while the reference is stored in the stack memory.
Thread. Each thread has its own stack memory while all threads share a common heap memory.

Finally, the stack memory throws the ‘stackoverflow’ error when it is full.

. Heap Memory

The heap memory is the section of the memory where objects are stored. It is larger than the stack memory. The heap memory is divided into two main sessions, the young generation and the old generation.

The young generation is further divided into Eden Space and Survivor Space. The Survivor space is further divided into S0 and S1 spaces. You will understand the types of the heap memory and their functions later in this post.

. MetaSpace Memory

The metaspace was previously known as the Permanent Generation before the Java 7 version, and was a part of the heap memory. The Permanent Generation was not expandable and throws a heap error once the memory is full.

Now, it has evolved to metaspace memory, which is a stand-alone memory space from the heap memory. The metaspace stores class variables, constants, annotations, and class metadata.

In other words, information about the class from which objects are created including constants (static and final) are stored in the metaspace memory.

The JVM loads the class if it needs it and removes if from the metaspace when it has no need for it. One good thing about the metaspace is that it is expandable.

Picture To Explain Data Storage In Java Memory.

public class Main {
    public static void main(String[] a) {
        int seat = 4; //primitive data
        String str1 = "30"; //string literal
        String str2 = new String ("30") //String Object
        Car newCar = new Car(); //object

    }

    public void method2(){
      String str3 = "30"; //string literal
      Car newCar2 = new Car(); //object

    }
}

How Memory Management Works In Java

The memory management process frees up space in memory for incoming data. Here is how the process work; when a method is done executing, the JVM cleans up the stack memory automatically. The values and variables in the method are forgotten.

The JVM does not clean up the heap memory automatically when a method is done executing because the object on the heap may be needed by another method which is still in the stack memory.

An object becomes eligible for garbage collection when it no longer has a reference in the stack memory.

Java Virtual Machine JVM initiates the garbage collection process automatically. The developer can suggest to the JVM to start the garbage collection process by executing ‘System.gc( )’ code, but it doesn’t guarantee that it will start the process.

How Garbage Collection Works In Java

The space that a method occupies in the stack memory is known as a scope. The closing bracket in a method marks the end of a scope and the cleanup process starts. All variables and references in the method are removed.

The JVM deletes the scope starting from the latest scope. It applies the last in, first out cleanup process. After the variables and object references in the stack memory is removed, the garbage collection process starts in the heap memory. The garbage collector deletes the unreferenced objects in the heap memory.

The first garbage collection process is called the mark and sweep algorithm process. The garbage collector checks for and marks dead objects (objects without reference) and separates them from live objects (objects with reference). Objects with no references are moved to the Eden space.

The surviving objects is swept to either the S0 or S1 which is known as the survivor space. The survivor space has a threshold as new objects are created and the garbage collection process continues.

Once the survivor space gets to its threshold, it is promoted to old generation space in the heap memory.

The garbage collection process runs more frequently in the new generation than in the old generation. This is because objects moved to the old generation are used frequently and may have several references pointing to them indirectly.

Note that the garbage collection process that takes place in the young generation is known as the minor garbage collection while that of the old generation is known as major garbage collection.

Knowledge of when to promote an object from young to old generation is vital in the garbage collection process.

The garbage collector uses different collection strategies or algorithms for each generation. For instance, it can use the mark - sweep strategy for the

Types Of Garbage Collection Process In Java

There are three main collection process the garbage collector applies to clean up memory space. They include the following:

. Normal Mark Sweep:

The process here involves two processes. The mark and the sweep process. First, go through the heap memory to identify and mark live objects from dead objects. After that, the garbage collector initiates the sweep process.

That is sweeping or removing dead objects to the next memory space. It starts from the Eden space and the remaining objects are moved to the Survivor space.

After the removal of the dead objects remaining objects remains or maintains initial spaces. This method is not ideal especially if the incoming objects are bigger and can’t fit in the between the space.
Note: that the Garbage Collection Cycle is the amount of time it takes the garbage collector to complete a full garbage collection round.

. Mark Sweep With Compact:

After the garbage collector complete the collection cycle, it compacts the remaining objects to free up space for new objects. This way, there is enough space for incoming objects.

. Mark Sweep Copy:

Here, the garbage collector marks objects from the ‘from space’ region and moves them to the ‘to space’ region. After that, it compacts the remaining objects to free space for new objects.

Types of Garbage Collection Algorithms

There are five garbage collection algorithms in java. Here is a breakdown of each collection algorithm, features and where it applies:

. Serial Garbage Collector:

This garbage collector algorithm is good for a single core machine. It uses the mark- sweep for young generation and mark sweep compact for the old generation.

The serial garbage collector runs on a single thread. This means that other threads in the program will pause (Stop-The-World) during the garbage collection process.

Pros:

Suitable for programs with small data sets where the pause time does not matter.

Cons:

Slow because it runs on a single thread.
More expensive.

. Parallel Garbage Collector:

This collector works as the default garbage collector in java. The Parallel collector uses the mark sweep copy for young generation and mark sweep compact for old generation.

It uses multiple threads to perform garbage collection. The program gets pause time during the garbage collection process but for a shorter amount of time. It runs well on a multi core machine.

Pros:

Faster than the serial collector

Cons:

Slower than other garbage collector algorithms below.

. Concurrent Mark Sweep Garbage Collector:

This is an upgrade from the previous parallel collector. It uses the mark sweep copy for young generation and concurrent mark sweep for the old generation and uses multiple threads to perform garbage collection.

This collection method does not require the program to stop. The garbage collection process runs concurrently with execution of the program. Mostly, it uses the concurrent collection method, but will revert back to stop-the-world if there is need for it.

. Garbage First (G1) Garbage Collector:

This was first introduced in Java 7 and uses multiple threads to perform garbage collection. It divides the heap memory into small regions. It applies the parallel, concurrent, and incrementally compacting collection methods.

The G1 collector has the shortest pause time because of the division of the heap memory to small regions (memory segments). It keeps track of live and dead objects in each memory segment. The segment with the greatest number of objects is collected first. Stop-the-world (pause time) happens but for a shorter time period.

This collector algorithm is best for machines with large memory space and high performance.

. Z Garbage Collector:

This was first introduced in Java 11. Also, uses multiple threads to perform garbage collection. Here, the garbage collection method is completed while the program is running concurrently with less than 10 milliseconds of pause time.

The garbage collection process starts with marking live objects with reference coloring and not with maps as with other collectors. The reference states are stored in bytes of the reference.

The Z garbage collector works well on 64 bits machines as the references does not have enough bits to execute on a 32 bit system. Also, it applies fragmented memory as a result of the garbage collection process. These entire process runs concurrently with the program hence the 10 milliseconds pause time.

Conclusion

So far, this post has all you need to know about memory management in java. Finally, if you are wondering which garbage collection algorithm is best for your program. The answer is, it depends. It depends on the program in question, and the system. For example, the serial collector method is best for a small program with minor data sets.