Forem: German Valencia

Semantic Versioning with Jreleaser and Upcoming4j

German Valencia — Fri, 30 Jan 2026 19:04:17 +0000

While working with semantic-release npm package to fully automate application releases in Nodejs, I got used to an out-of-the-box workflow where conventional commits drive version calculation, git tagging, changelog generation, GitHub releases, and CI-safe publishing.

When I switched to gradle-java projects, I could not find an equivalent solution. After researching the ecosystem, Jreleaser stood out as the most complete tool available for creating Git tags, generating changelogs, and publishing GitHub releases. However, it expects the version to be predefined.

That gap led me to create Upcoming4j, a lightweight gradle plugin focused solely on semantic version calculation, designed to integrate seamlessly with Jreleaser to fully automate software versioning.

In the following step-by-step guide, I will show how to integrate JReleaser and Upcoming4j to automatically increment version numbers, create Git tags, generate changelogs, and publish GitHub releases based on Git commit history using semantic versioning.

Prerequisites

Install Sdkman
Install JDK 21

$ sdk install java 21.0.9-amzn
$ java --version

Install git

$ brew install git
$ git --version

Step 1: Download Playground Gradle-Java Project `u4j-playground`

Download and unzip the playground project into your local file system. This is a gradle-java project that will be used to demonstrate how to integrate JReleaser and Upcoming4j in practice.

Step 2: Install and Configure `Jreleaser` Plugin

JReleaser uses a hosted Git repository to create Git tags and publish releases. Create a new repository on your GitHub account and follow the instructions to link your local playground project to the remote repository.
Download the Jreleaser Configuration file, and place it in the following location: /u4j-playground/gradle/jreleaser.gradle.
Open the /u4j-playground/build.gradle file to install and apply Jreleaser configuration. The file should look like this now:

plugins {
    id 'application'
    // install JReleaser plugin
    id 'org.jreleaser' version '1.22.0'
}

// Apply JReleaser configuration
apply from: 'gradle/jreleaser.gradle'

// Set a harcoded version for now
version = '1.0.0'

repositories {
    mavenCentral()
}

dependencies {
    testImplementation libs.junit.jupiter
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
    implementation libs.guava
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

application {
    mainClass = 'org.example.App'
}

tasks.named('test') {
    useJUnitPlatform()
}

Step 4: Verify `Jreleaser` Configuration

Create a Personal Access Token in Github, and export the token using the following environment variable:

$ export JRELEASER_GITHUB_TOKEN=your_token

Run JReleaser in --dryrun mode to preview the release steps without making any changes:

$ ./gradlew clean jreleaserRelease --no-configuration-cache --stacktrace --dryrun

Check logs to verify outcomes:

Notice that even in --dryrun mode, Jreleaser requires PAT being exported.

Notice that JReleaser is not yet fully compliant with Gradle’s configuration cache. Therefore --no-configuration-cache flag is being used.

Step 5: Install and Apply `Upcoming4j` Plugin

Open /u4j-playground/build.gradle file and install Upcoming4j plugin, the file should look like this now:

plugins {
    id 'application'
    // install JReleaser plugin
    id 'org.jreleaser' version '1.22.0'
    // Install Upcoming4j plugin
    id 'io.github.sttamper.upcoming4j' version '0.0.4'
}

// Apply JReleaser configuration
apply from: 'gradle/jreleaser.gradle'

// Set up next version with Upcoming4j
version = nx()

repositories {
    mavenCentral()
}

dependencies {
    testImplementation libs.junit.jupiter
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
    implementation libs.guava
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

application {
    mainClass = 'org.example.App'
}

tasks.named('test') {
    useJUnitPlatform()
}

Step 5: Verify `Upcoming4j` Configuration

Upcoming4j computes the next semantic version during Gradle’s configuration phase, ensuring that the correct version is always available in the version property of the build.gradle file.

Clean project:

 ./gradlew clean

Check Upcoming4j logs to confirm version calculation:

Final Step: Bump The Next Semantic Version

Now you can run JReleaser to create the next release version calculated by Upcoming4j, based on the analysis of the commit history:

./gradlew clean jreleaserRelease --no-configuration-cache --stacktrace

Customizing MacOS Terminal with Starship Like a Pro

German Valencia — Sun, 18 Jan 2026 04:50:29 +0000

As terminal applications grow more powerful and complex, managing multiple CLIs and their different versions becomes increasingly challenging. Customizing your terminal can make a big difference, helping you handle several tools at once without getting lost in the clutter.

I previously relied on Oh My Zsh for prompt customization, but recently switched to Starship because it provides a simpler declarative approach to customization. So in this post, I will walk through how to build a clean starship prompt, including dynamic context for:

AWS profiles
Java (Gradle)
Node.js

Getting Started

Install Homebrew
Install Iterm2

Step 1: Install Starship

brew install starship

Step 2: Integrate Starship with Zsh

Open .zshrc for edition:

nano ~/.zshrc

Add the following line to load starship on every zsh session:

eval "$(starship init zsh)"

Step 3 (Optional): Install Zsh Plugins

The following plugins are optional, but they enhance your terminal experience by highlighting commands in real time and providing suggestions based on your command history and current input:

brew install zsh-syntax-highlighting
brew install zsh-autosuggestions

Open .zshrc for edition:

nano ~/.zshrc

Add following lines to load plugins on every zsh session:

source $(brew --prefix)/share/zsh-autosuggestions/zsh-autosuggestions.zsh
source $(brew --prefix)/share/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh

Step 4: Install Nerd Fonts

To ensure terminal can correctly render icons and custom glyphs, you need to install a Nerd Font:

brew search font-fira-code-nerd-font
brew install --cask font-fira-code-nerd-font

Step 5: Setting Terminal Font

Update your terminal settings to use a Nerd Font:

Iterm2

Navigate to: Settings > Profiles > Default > General

Option	Value
Terminal Font	FiraCode Nerd Font

Visual Studio Code integrated terminal

Navigate to: Settings > User

Option	Value
terminal.integrated.fontFamily	FiraCode Nerd Font
editor.fontFamily	Menlo, Monaco, 'Courier New', monospace, 'FiraCode Nerd Font’

MacOS native terminal

Navigate to: Settings > Profiles > Text

Option	Value
Font	FiraCode Nerd Font

Step 6: Customize Starship Theme

Create and open the starship.toml configuration file for edition:

mkdir -p ~/.config && nano ~/.config/starship.toml

Next, download the Starship configuration from the following GitHub Gist:

Starship Configuration GitHub Gist

Replace the contents of starship.toml file with the configuration from the gist, then save the file and restart the terminal.

Last Step: Play With The New Prompt

AWS profiles

In the example below, after running export AWS_PROFILE=root, Starship reflects the currently active AWS account directly in the prompt:

Starship displays the active AWS profile: root
The terminal prompt also shows the active AWS region: us-east-1 (Virginia)

NodeJS projects

The following example shows how changing the Node.js version using NVM (nvm use) is reflected in Starship:

Starship automatically updates the prompt to display the active Node.js version.
Starship also shows useful Git repository information, such as the current branch and an icon indicating modified files.

Java and Gradle projects

In the following example, observe how Starship displays information about the current environment in a Java application directory:

The active Java version currently in use.
The active Gradle version.
Additional contextual information, such as the active AWS profile and region, when those tools are enabled.

Enjoy it!

Pod and ReplicaSet Explained

German Valencia — Fri, 13 Jan 2023 01:42:19 +0000

Kubernetes is a technology plenty of features to manage containers. In this series of posts we will explore which I consider the 4 key concepts to understand whenever we want to deploy a simple application.

Source code of examples on GitHub

Brief Architectural Overview

Kubernetes is based on a master-worker architecture to make sure high availability of the applications deployed in a cluster, where workers are the servers or nodes (physical machines) where applications run, and master is a node responsible for monitoring and updating the status of workers, so in case a worker gets down the master is able to start a new one.

The Control Plane: This is the controller node (master) which provides a set of functionalities to manage the Kubernetes cluster.
API Server: This is a super set of REST API's which allow to perform CRUD operations to resources in the cluster.
Nodes: Physical machines (servers) where applications run and scale.
Kubelet: This is an agent (endless process) that runs in every node, being responsible for registering a node in the control plane so it can monitor it, and given a pod specification, kubelet starts the containers making sure they keep running until the control plane decides to stop, recreate or delete them.
Container runtime: Kubernetes is agnostic of the technology to create containers, so it can be docker, container.d or whatever.
kubectl: This is a command line application we can use to perform actions into the cluster. This is just a wrapper of the REST APIs provided by the API server.

Objects Versioning

Resources exposed by the REST APIs are called objects which are under version control. A complete list of objects we can manage in a cluster can be found here.

Objects can be described with .yaml files, and we can instruct the control plane to create or update them by running:

$ kubectl apply -f object-descriptor.yaml

Let's review now how to describe Pods, ReplicaSet, Deployments and Services which is the purpose of this post.

Getting Started with a Pod

This is the basic unit of deployment in Kubernetes, a pod is deployed into a node and can start from 1 to many containers, along with other objects like volumes.

Pods are assigned a static IP address for internal communication, it means that we cannot ping pods from outside the cluster.

Describing a Pod

pod-nginx.yaml

1. apiVersion: v1
2. kind: Pod
3. metadata:
4.   name: nginx-yaml
5. spec:
6.   containers:
7.     - image: nginx
8.       name: nginx
9.       ports:
10.        - containerPort: 80
11.          name: http

Line 1: The version of the object we want to describe.
Line 7: Create a nginex container.
Line 10: Starts the container in the port 80.

Let's create and inspect the Pod

$ kubectl apply -f pod-nginx.yaml
$ kubectl describe pods nginx-yaml

Port Forwarding

There are many ways we can see containers from outside the cluster (we will talk about services further). By the moment, we can use port forwarding to see the nginx container running by:

$ kubectl port-forward --address 0.0.0.0 nginx-yaml 80:80

So if we go to the browser on http://localhost:80, we should see:

Scaling With A ReplicaSet

Whenever a pod gets down, the ReplicaSet object will start up a new one making sure always a fixed number of available pods. Have a look at the following descriptor, where we have told the ReplicaSet to keep 3 pods running:

replica-set-nginx.yaml

1. apiVersion: apps/v1
2. kind: ReplicaSet
3. metadata:
4.   name: nginx-replica-yaml
5.   labels:
6.     color: blue
7.     version: "1"
8. spec:
9.   replicas: 3
10.  selector:
11.    matchLabels:
12.      color: blue      
13.  template:
14.    metadata:
15.      labels:
16.        color: blue
17.    spec:
18.      containers:
19.        - image: nginx
20.          name: nginx
21.          ports:
22.            - containerPort: 80
23.              name: http

Line 9: The number of pods to keep alive.

Let's create and inspect the ReplicaSet

$ kubectl apply -f replica-set-nginx.yaml
$ kubectl describe  nginx-replica.yaml

Colorize zsh Mac Terminal

German Valencia — Fri, 06 Jan 2023 04:49:38 +0000

1. Install iTerm2

I recommend the use of iTerm over the native mac terminal, since it has additional cool features. However, you can use the native one.

2. Check if Zsh is configured in your mac

Latest versions of macOS already come with zsh as default shell. However, you can check if zsh is configured going to the native terminal settings general tab:

It your configuration does not look like the image, you need to install zsh before going to any other step in this post:

Installing Zsh

Install Homebrew
Check Homebrew installation

$ brew doctor
╰─ Your system is ready to brew.

Install Zsh

$ brew install zsh

3. Install Oh My Zshell

Oh My Zshell is a powerful framework for zsh plenty of plugins that enhances the terminal experience.

zsh theme: https://github.com/ohmyzsh/ohmyzsh/wiki/Themes#amuse

4. Install Powerlevel10k

There are many ways to install Powerlevel10k, but I recommend to install it as Oh My Zshell plugin.

Once you restart iTerm, Powerlevel10k will ask you to install Meslo Nerd Fonts, I highly recommend to let Powerlevel10k to install the fonts, otherwise you will have to do it by yourself

Now, follow the wizard which will guide you to customize the theme, finally you should have to get the following screen where you can either restart from the beginning or apply changes to .zshrc file.

5. Cool Plugins

Oh My Zshell is plenty of plugins, you can find the full list of plugins developed by the community. Lets customize two basic ones:

zsh-syntax-highlighting

This is a plugin to highlight commands of any CLI application you have installed in your mac.

$ git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

zsh-autosuggestions

This is a plugin suggest autocomplete commands you have typed before.

$ git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

Activate Plugins

It is just a matter of modify the following in your .zshrc file

plugins=( git )

plugins=( git zsh-syntax-highlighting zsh-autosuggestions )

Callback and Microtask Queues Explained

German Valencia — Tue, 03 Jan 2023 06:16:55 +0000

Javascript is a non-blocking single threaded programming language, which means that all functions we write in a .js file are executed into the JS engine in one thread at runtime.

But, what does non-blocking mean?

Whenever a javascript program needs to execute an async process provided by a browser web api, this can use a strategy to avoid blocking the main thread, thus getting async responses from web apis further on. Have a look at the following analogy with a calling to a help desk (you may want to read this too):

In general terms, the goal is to receive responses from async processes by using callback functions, meanwhile the program continues its execution in the main thread (going to cinema :P )

What are Web API's?

Web API's are a bunch of built in functions which come with the browser and enable web sites written with javascript to access common functionalities such as:

Timeout API: To delay the execution of a function.
DOM API: To manipulate parts of the DOM at runtime.
Fetch API: To send http requests to servers.
LocalStorage API: To save information in the browser.
Console API:: To print out to the web console.
Location API: To get access to geo location services.

In other words, web apis are whatever we can do with the global scope window:

window.setTimeout(() => {console.log('text')}, 3600);
window.console.log(window.document.title);
window.fetch('www.google.com')
.then(r => {
  console.log(r);
})
window.localStorage.setItem('tales', 'tales');
console.log(window.location.href);

The Callback Queue

Whenever we use a web API from our javascript code, the program needs to register a callback function which will be executed once the web API ends with its internal stuff.

Now, callback functions don't get the call stack directly, so web API's push them to an alternative channel known as the callback queue waiting for the call stack to be ready to stack them for the program to execute them. Have a look at the following snippet:

window.setTimeout(() => {console.log('end')}, 1000)

In the images below we can see that as soon as the setTimeout() function gets into the call stack its callback is registered, and when the timeout has elapsed (1 second) the callback function gets into the callback queue.

The Event Loop

The event loop is an endless built in process provided by the browser which checks the callback queue looking for functions to execute once the call stack is ready.

And When is the call stack ready? it is ready when the Global Execution Context has been removed, then the event loop takes the next function from the callback queue and pushes it to the call stack.

The Microtask Queue

There are some web API's which use promises to provide async computation, this is the case of fetch web API. Have a look at the following snippet:

window.fetch('www.google.com')
.then(r => {
  console.log(r);
})

Callback functions of web API's based on promises don't get the callback queue after the promise is resolved but a different one called The Microtask Queue. Even though this queue is also checked by the event loop looking for functions to push to the call stack, this has a higher priority than the callback queue, it means that all callback functions in the Microtask Queue will be executed first than the next function available in the Callback Queue.

Javascript Engine and Call Stack explained

German Valencia — Mon, 02 Jan 2023 19:45:15 +0000

You can use playground.js to execute the code snippets.

The Javascript Engine

The main responsibility of any web browser is to serve static content (HTML and CSS) from the WWW, it means that a browser is just an interpreter of markup language and for being able to execute Javascript code, all browsers need to use an internal component called Javascript Engine which is developed by the browser's vendor.

Here is a list of JavaScript Engines for major Internet browsers:

V8: JavaScript Engine developed by Google for Chrome
SpiderMonkey: – The JavaScript Engine used by Mozilla Firefox
JavaScriptCore: – Developed by Apple for Safari
Rhino: – Managed by Mozilla Foundation for Firefox
Chakra: – A JavaScript Engine for Microsoft Edge

The Call Stack

Javascript is a non-blocking single threaded programming language, which means that all functions we write in a program (.js file) are executed by the engine in one thread at runtime, where the engine keeps the order the functions are executed by using a LIFO (Last in First Out) data structure, and this data structure is what we call as the call stack.

Along with the call stack the engine comes with a memory heap, this is just a storage of variables, objects, constants and function definitions, being functions the ones which will get into the stack during the program execution.

The Global Execution Context GCE

Just for academic purposes, think about the global execution context like a main function which wraps all code we want to execute in a single .js file. We cannot control the GCE, all we need to know is that this is always the first function which gets into the stack once the engine reads the code to run.

With all basic concepts in place, let's analyze the execution flow of the following program, keep in mind that the execution order does not rely on the order the functions are defined but the order they are invoked:

1.  function a(){
2.    console.log("A");
3.  }
4.  function b(callback){
5.    console.log("B");
6.    callback();
7.  }
8.  function end(){
9.    console.log("End");
10. }
11. b(a);
12. end();

The engine reads the .js file to run and then the GEC gets into the stack.
(Line 11) function b(callback) gets into the stack.
(Line 5) console.log function gets into the stack and prints out B in the web console.
console.log function is removed from the call stack after it is executed.

(line 6) function a() gets into the stack. Notice that this is the same callback function.
(line 2) console.log function gets into the stack and prints out A in the web console.
console.log function is removed from the stack after it is executed.
function a() is removed from the call stack since its execution has ended.
function b(callback) is removed from the call stack since its execution has ended.

(line 12) function end() gets into the stack.
(Line 5) console.log function gets into the stack and prints out End in the web console.
console.log function is removed from the stack after it is executed.
function end() function is removed from the stack since its execution has ended.
The global execution context is removed from the stack and the program ends.

Final Outcome

B
A
End

Brief Intro to Reactive Streams with Project Reactor

German Valencia — Mon, 02 Jan 2023 05:20:29 +0000

Source code of the examples on Github

Traditional client–server communication is request-based: the server allocates a thread to handle each request, and the client waits until the server completes the execution, before getting either a success or failure response. This model is known as synchronous, blocking communication.

Regardless of the scalability strategy used by the server (horizontal or vertical), this synchronous blocking approach can become a performance bottleneck. To address this, we can use reactive programming, which enables more efficient thread and resource management.

To illustrate this, we’ll explore four communication scenarios using a call center as a study-case.

Synchronous and Blocking

As we saw above this is the traditional way, where the client will be blocked until getting a response from the server.

Asynchronous

The client will delegate the communication to the server to another thread, thus the client is released to execute other tasks while the server responses.

Non-Blocking

The client does not delegate the communication to a new thread, but registers a callback function where will receive the response after the server processes the request. This scenario also releases the client (main thread) to perform other tasks.

Non-Blocking Async

the client delegates the communication to a new thread, so the new thread registers the callback function where will receive the response once the server processes the request. This scenario also releases the client (main thread) to perform other tasks.

Publisher Subscriber Pattern

Reactive programming relies on the Publisher and Subscriber pattern, where the communication between components that emit messages (publishers) and the ones which consume them (subscribers) relies on an external component called broker.

Publishers and subscribers are agnostic each other. More about this pattern in further posts about Apache Kafka.

The Reactive Streams API

The reactive streams API provides the specification for non-blocking async streams processing with back pressure mechanism, and Project Reactor is an implementation written in java.

What is Back Pressure?

Having a look at the pub-sub pattern diagram, back pressure is a strategy the reactive streams provide to control the number of messages (items) a subscriber is able to consume from a publisher.

Let's review the 4th interfaces provided by the API, and keep in mind the difference between these 2 concepts:

item: this is the element or message sent by a publisher and consumed by a subscriber.
signal: a flag emitted by the publisher after an item or a set of items are sent.

Publisher Interface

Responsible for emitting items along with a success or failure signals.
It also provides a method for the subscribers to register a subscription.

Subscription Interface

This is a channel where the subscriber is able to request more items to the publisher (back pressure mechanism).
The subscriber can also cancel the subscription using the same channel.

Subscriber Interface

A subscriber reacts to the items and signals emitted by the publisher by the implementation of the following methods:

onComplete() The publisher notifies the subscriber that there are no more items to emit, then the publisher is closed.
onError(Throwable) The publisher notifies the subscriber that there was an error when emitting the item, then the publisher is closed.
onNext() The publisher notifies the subscriber that a next item was just emitted.
onSubscribe() This is the initial state, where the publisher notifies the subscriber that the subscription was accepted.

Processor Interface

This is an intermediary stage, a processor can consume an item and emit a new one.

The Project Reactor

As implementation of reactive streams API, reactor is based on two types of publishers: Mono and Flux. Be aware that reactive streams are lazy evaluated, it means that nothing happens until a subscription is created.

Mono

A Mono is a publisher able to emit from zero to 1 items. followed by an onComplete() or onError() signals. Let's explore some basic functions to get started.

Emit And Subscribe

1. public static void emitAndSubscribe(){
2.   var mono = Mono.just("A");
3.   mono.subscribe(
4.     item -> System.out.println(item),
5.     error -> System.out.println(error.getMessage()),
6.     () -> System.out.println("Completed!")
7.   );
8. }

line 2: We create mono publisher which emits 1 item.
line 3: We create a subscription which receives 3 functions: 2 Consumer and 1 Runnable
line 4: the consumer that accepts the item just emitted.
line 5: the consumer that accepts an exception in case it is thrown by the publisher.
line 6: the runnable which reacts to onComplete() signal.

Outcome:

A
Completed!

Flux

A Flux is a publisher able to emit from zero to many items, followed by an onComplete() or onError() signals. Let's explore some basic functions to get started:

Emit And Subscribe

1. public static void emitAndSubscribe(){
2.   var flux = Flux.fromArray(new String[]{"A", "B", "C"});
3.   flux.subscribe(
4.     item -> System.out.println(item),
5.     error -> System.out.println(error.getMessage()),
6.     () -> System.out.println("Completed!")
7.   );
8. }

line 2: We create flux publisher which emits 3 item.
line 3: We create a subscription which receives 3 functions: 2 Consumer and 1 Runnable
line 4: the consumer that accepts the item just emitted.
line 5: the consumer that accepts an exception in case it is thrown by the publisher.
line 6: the runnable which reacts to onComplete() signal.

Outcome:

A
B
C
Completed!

Conclusion

The reactor java doc is plenty of methods to work with Monos and Fluxes, we have just covered some basic ones to understand the concepts of publishing and subscribe to get started.

Binary Search Tree Vol. 2

German Valencia — Sun, 01 Jan 2023 20:48:05 +0000

Source code of the examples on Github

Sorting a Binary Search Tree (ASC and DESC)

A binary tree is an unordered data structure, which implies that elements (nodes) are not associated to a consecutive index when they are inserted (unlike lists). However a binary tree can be sorted, it means that its elements can follow a logic sorting criteria.

Then, lets explore a pair of algorithms to sort a BST ascending and descending:

ASCending Sorting

Given the nature of a BST where nodes whose values are less than the root node go to the left, for ascending sorting it is just a matter to print out nodes starting by the leftmost node in the tree onwards. In other words we need to use the inorder traversal algorithm.

If the parent node is null then just break the recursion.
Look for the leftmost node of the tree in the parent left subtree.
You have found the node, then just print out its value.
Look for the leftmost node of the BST in the parent right subtree.

public void printAscending(Node parent){
  if (parent == null){
    return;
  } else {
    this.printAscending(parent.left);
    System.out.print(parent.value);
    this.printAscending(parent.right);
  }
}

DESCending Sorting

Now, given that nodes whose values are greater than the root node in a BST go to the right, for descending sorting it is just a matter to print out nodes starting by the rightmost node in the tree onwards. In other words we need to use the inorder traversal algorithm.

If the parent node is null then just break the recursion.
Look for the rightmost node of the tree in the parent right subtree.
You have found the node, then just print out its value.
Look for the rightmost node of the BST in the parent left subtree.

public void printDescending(Node parent){
  if (parent == null){
    return;
  } else {
    this.printDescending(parent.right);
    System.out.print(parent.value);
    this.printDescending(parent.left);
  }
}

Lowest Common Ancestor

By definition the lowest common ancestor of 2 nodes x and y is the lowest node which has both as descendants, be aware that a node itself is considered its own descendant.

If the parent value is less than x value and y value, it means that we have to look for the LCA in the parent right subtree.
If the parent value is greater than x value and y value, it means that we have to look for the LCA in the parent left subtree.
Otherwise we have found the LCA then just returns it.

public Node lca(Node parent, Node x, Node y) {
  if(parent.value < x.value && parent.value < y.value) {
    return lca(parent.right, x, y);
  }
  if(parent.value > x.value && parent.value > y.value) {
    return lca(parent.left, x, y);
  }
  return parent;
}

Binary Search Tree Vol. 1

German Valencia — Sat, 31 Dec 2022 19:15:33 +0000

Source code of the examples on Github

What is a Binary Search Tree (BST)?

BST stands for Binary Search Tree; this is a special type of a tree which must be compliant with the following conditions:

The left subtree of the root node must contain values which are less than the root node value.
The right subtree of the root node must contain values which are greater than the root node value.
In lights of the above, a BST does not contain duplicate values.
Every left or right subtree of any node must also be a BST.

Searching for a key in a BST

We may guess that searching keys in a binary tree it is just a matter of using one of the traversing algorithms we've seen on this post, but given the fact that a BST is a sorted data structure, traversing all the nodes searching for a key could represent an unnecessary overhead, thus a better algorithm should look like this:

Check if the key to search equals null or the parent node value, then just returns the node.
Else, compare the key with the parent node value.
So, if the key to search is less than the parent node value, then look for the key in the left subtree, otherwise look for the key in the right subtree.

public Node search(Node parent, int key){
  if (parent == null || key == parent.value) {
    return parent;
  } else if (key < parent.value){
    return search(parent.left, key);
  } else {
    return search(parent.right, key);
  }
}

Inserting a new key in a BST

As we already understood that keys less than the root node value go to the left subtree and the greater ones to the right, implementing an algorithm to insert keys in a BST should look like this:

Check if the parent node is null, then create a new node with the key and just returns it.
Else, compare the key with the parent value.
So, if the key to insert is less than the parent value, then insert the key in the left subtree, otherwise insert the key in the right subtree.

1.  public static void main(String[] args) {
2.    var bts = new BinarySearchTree();
3.    bts.root = bts.insert(bts.root, 9);
4.    bts.insert(bts.root, 10);
5.    bts.insert(bts.root, 11);
6.  }
7.  public Node insert(Node parent, int key){
8.    if (parent == null){
9.      return new Node(key);
10.   } else if (key < parent.value) {
11.     parent.left = insert(parent.left, key);
12.   } else {
13.     parent.right = insert(parent.right, key);
14.   }
15.   return parent;
16. }

Have a look at the main method (line 3) where we start the recursive function to insert keys in the tree.

Deleting a key from a BST

Deleting a key means deleting the node itself. Whenever we need to delete a node from a BST, we have to always make sure that none of the 4th conditions of a BST break after deletion, specially the one which says that keys less than the parent value go to the left and the greater ones go the the right, thus we need to analyze the following 3 scenarios to implement a free bugs algorithm:

Node to be deleted is a leaf

This is the simplest scenario where the parent node must address to null after the child is deleted.

Node to be deleted has 1 child

In this case the parent node of the child to delete, must now address to the child's child.

Node to be deleted has 2 children

This is the complex case but it can be solved easily, we just need to replace the node to be deleted by its inorder predecessor, and why by the inorder predecessor? because this will be the largest node of the left subtree after the deletion happens.

Now, the algorithm:

Check the parent, if it is null then return it (this is a leaf).
Else, if the key to delete is less than parent value then delete the key from the parent left subtree
Else, if the key to delete is greater than parent value then delete the key from the parent right subtree.
Finally, if the key equals the parent value, it means we have found the node to delete.
Find and replace the parent value with its inorder predecessor.
Then, delete the predecessor from the parent left subtree.
Finally return the parent which will represent the new state of the entire tree after deletion.

1. public Node delete(Node parent, int key){
2.    if(parent == null){
3.      return parent;
4.    } else if (key < parent.value){
5.      parent.left = this.delete(parent.left, key);
6.    } else if (key > parent.value){
7.      parent.right = this.delete(parent.right, key);
8.    } else {
9.      var predecessor = this.inOrderPredecessor(parent);
10.     parent.value = predecessor.value;
11.     parent.left = this.delete(parent.left, key);
12.   }
13.   return parent;
14. }

Finding the Inorder predecessor of a Node

Lets explore line 9 of the above code snippet where we need to find the Inorder predecessor of the node to delete:

The algorithm needs to find the rightmost node of the parent left subtree, since this is the place where we can find the largest node of the left subtree.

public Node inOrderPredecessor(Node parent) {
  var tempNode = parent.left;
  while(tempNode.right != null){
    tempNode = tempNode.right;
  }
  return tempNode;
}

Binary Tree Data Structure Vol 2.

German Valencia — Sat, 31 Dec 2022 16:16:36 +0000

Let's review some problems we can solve by using the traversal algorithms we learnt in previous posts.

Source code of the examples on Github

Inorder Predecesor

We can use the traversing algorithms to perform some operations in a binary tree, for example we may want to replace every node by its inorder predecessor, being this the previous node when traversing the binary tree (inorder).

A recursive algorithm should look like this:

Define an scoped variable to keep track the predecessors while traversing the binary tree.
If the parent node is null, then just return the node.
Otherwise, perform predecessor swapping to the parent left subtree, swap the values, and then perform predecessor swapping to the parent right subtree.

int predecessor = -1;
private void inOrderPredecessorSwap(Node parent){
  if(parent == null){
    return;
  } else {
    this.inOrderPredecessorSwap(parent.left);
    this.swap(parent);
    this.inOrderPredecessorSwap(parent.right);
  }
}
private void swap(Node parent) {
  var temp = parent.value;
  parent.value = predecessor;
  predecessor = temp;
}

Inorder traversal outcome: 6,5,8,7
After swapping outcome: -1,6,5,8

Highest Level of a Binary Tree

The highest level of a tree is represented by the number of edges between the root node and the deepest leaf, then we have:

Check if the parent node is null, then return -1.
Now, calculates the highest level of the left subtree and the right subtree.
If the highest level of the left subtree is greater than the right subtree, then return the left one plus 1, otherwise return the right one plus 1.

private int highestLevel(Node parent){
  if(parent == null){
    return -1;
  }
  var hLeft = this.highestLevel(parent.left);
  var hRight = this.highestLevel(parent.right);
  if(hLeft > hRight){
    return hLeft + 1;
  } else {
    return hRight + 1;
  }
}

Copy a Binary Tree

Another application of the preorder traversal algorithm is when we need to create a new binary tree by copying all nodes from another one.

Check if the parent is null, then just returns it.
Else, create a new instance of a node from the parent node.
Now, copy the parent left subtree to the recently created node, and do the same with the parent right subtree.
Just return the node created.

public Node copy(Node parent){
  if(parent == null){
    return parent;
  } else {
    var newParent = parent;
    newParent.left = this.copy(parent.left);
    newParent.right = this.copy(parent.right);
    return newParent;
  }
}

Deleting a Binary Tree

We can use the Postorder traversal algorithm to delete all nodes of a binary tree.

Check if the parent is null, then just returns it.
Else, delete the parent left subtree and the parent right subtree.
Then, just returns null.

public Node delete(Node parent){
  if(parent == null){
    return parent;
  } else {
    this.delete(parent.left);
    this.delete(parent.right);
    return null;
  }
}

Conclusion

There are many other operations we need to perform when working with binary trees, but most of them can be implemented just by applying a variation of the 3 traversal algorithms we have reviewed in this series of posts.

Binary Tree Data Structure Vol. 1

German Valencia — Fri, 30 Dec 2022 16:57:52 +0000

Source code of the examples on Github.

What is a Tree?

A tree is a non-linear data structure composed of nodes and edges without cycles. It means that every node in a tree has one and only one edge connecting two nodes:

Node: it is an element that contains a particular information plus the addresses to downward nodes also called children.
Edge: it just connects 2 nodes.

What is a Binary Tree?

A binary tree is the simplest type of a tree, where nodes can have from zero to 2 children at most.

Key Concepts

Root: this is the node at the top of the tree.
Path: refers to a sequence of nodes along with the edges.
Parent: every node except for the root node has one edge connecting to an upward node, this one is called parent.
Child: a node below another node connected by one edge is referred as child.
Leaf: a node which does not have any children.
Subtree: all descendants of a node below the root node.
Level: number of edges between the root node and the deepest leaf.
Value: the content of the node also referred as info.

A Brief Intro to Recursiveness

Traversing a binary tree is usually a recursive process, and I say usually because of there are other alternatives to implement traversing algorithms with stacks or queues. However, I consider is better to analyze binary trees from a recursive perspective for academic purposes.

Recursive Function

A recursive function is no more than a function which calls itself until a condition is meet. Have a look at the following example:

1.  public static void main(String[] args) {
2.    var r = Tales.sillySum(0);
3.    System.out.println(r);
4.  }
5.
6.  public static int sillySum(int acc){
7.    if(acc == 10){
8.      return acc;
9.    } else {
10.     acc++;
11.     return sillySum(acc);
12.   }
13. }

Where we can identify 2 key parts of a recursive function:

halting condition: the condition that stops the recursive process (line 7), this is also called the base case.
recursive statement: when the function is called itself (line 11).

Traversing a Binary Tree

Traversing means to pass through all nodes of a binary tree just one time in a specific order, therefore we can say that every node is a potential subtree to be traversed, even if it is a leaf.

Now, lets explore the 3 flavors we have to traverse the binary tree of the chart, and refer to visit as the action of printing out the value of a node, please keep in mind the 2 key concepts of a recursive function, so you can identify where the recursiveness happens:

Inorder traversal

Traverse all nodes of the left subtree (inorder).
Visit the node itself.
Traverse all nodes of the right subtree (inorder).

public void inOrderTraversal(Node parent) {
  if (parent == null){
    return;
  } else {
    inOrderTraversal(parent.left);
    System.out.print(parent.value);
    inOrderTraversal(parent.right);
  }
}

Outcome: [4,2,6,5,7,8,1,3]

Preorder traversal

Visit the node itself.
Traverse all nodes of the left subtree (preorder).
Traverse all nodes of the right subtree (preorder).

public void preOrderTraversal(Node parent) {
  if (parent == null){
    return;
  } else {
    System.out.print(parent.value);
    preOrderTraversal(parent.left);
    preOrderTraversal(parent.right);
  }
}

Outcome: [1,2,4,5,6,7,8,3]

Postorder traversal

Traverse all nodes of the left subtree (postorder).
Traverse all nodes of the right subtree (postorder).
Visit the node itself.

public void postOrderTraversal(Node parent) {
  if (parent == null){
    return;
  } else {
    postOrderTraversal(parent.left);
    postOrderTraversal(parent.right);
    System.out.print(parent.value);
  }
}

Outcome: [4,6,8,7,5,2,3,1]

Forem: German Valencia

Semantic Versioning with Jreleaser and Upcoming4j

Prerequisites

Step 1: Download Playground Gradle-Java Project u4j-playground

Step 2: Install and Configure Jreleaser Plugin

Step 4: Verify Jreleaser Configuration

Step 5: Install and Apply Upcoming4j Plugin

Step 5: Verify Upcoming4j Configuration

Final Step: Bump The Next Semantic Version

Customizing MacOS Terminal with Starship Like a Pro

Getting Started

Step 1: Install Starship

Step 2: Integrate Starship with Zsh

Step 3 (Optional): Install Zsh Plugins

Step 4: Install Nerd Fonts

Step 5: Setting Terminal Font

Iterm2

Visual Studio Code integrated terminal

MacOS native terminal

Step 6: Customize Starship Theme

Last Step: Play With The New Prompt

AWS profiles

NodeJS projects

Java and Gradle projects

Pod and ReplicaSet Explained

Brief Architectural Overview

Objects Versioning

Getting Started with a Pod

Describing a Pod

Port Forwarding

Scaling With A ReplicaSet

Colorize zsh Mac Terminal

1. Install iTerm2

2. Check if Zsh is configured in your mac

Installing Zsh

3. Install Oh My Zshell

4. Install Powerlevel10k

5. Cool Plugins

zsh-syntax-highlighting

zsh-autosuggestions

Activate Plugins

Callback and Microtask Queues Explained

But, what does non-blocking mean?

What are Web API's?

The Callback Queue

The Event Loop

The Microtask Queue

Javascript Engine and Call Stack explained

The Javascript Engine

The Call Stack

The Global Execution Context GCE

Brief Intro to Reactive Streams with Project Reactor

Synchronous and Blocking

Asynchronous

Non-Blocking

Non-Blocking Async

Publisher Subscriber Pattern

The Reactive Streams API

What is Back Pressure?

Publisher Interface

Subscription Interface

Subscriber Interface

Processor Interface

The Project Reactor

Mono

Flux

Conclusion

Binary Search Tree Vol. 2

Sorting a Binary Search Tree (ASC and DESC)

ASCending Sorting

DESCending Sorting

Lowest Common Ancestor

Binary Search Tree Vol. 1

What is a Binary Search Tree (BST)?

Searching for a key in a BST

Inserting a new key in a BST

Deleting a key from a BST

Node to be deleted is a leaf

Node to be deleted has 1 child

Node to be deleted has 2 children

Step 1: Download Playground Gradle-Java Project `u4j-playground`

Step 2: Install and Configure `Jreleaser` Plugin

Step 4: Verify `Jreleaser` Configuration

Step 5: Install and Apply `Upcoming4j` Plugin

Step 5: Verify `Upcoming4j` Configuration