jvmaware

Remote Ollama setup running CodeLlama and Web UI

sumit@dsadaily.com (sumit) — Fri, 02 May 2025 08:50:42 +0530

Ollma is an powerful open source tool for running LLMs locally. It can be used to run various models and comes handy when you are looking for a local solution to run LLMs.

Open WebUI is a self hosted solution to front Ollama with a user interface that allows you to interact with the models. It provides a simple and intuitive interface for running LLMs, making it easy to test and experiment with different models.

Asking relevant questions - a template

sumit@dsadaily.com (sumit) — Sat, 22 Mar 2025 11:02:00 +0530

Having joined a large retail organization six months ago as a senior engineer, I frequently found myself invited to brainstorming sessions and discussions without much prior context or background. This often involved topics outside my immediate area of expertise.

Initially, this posed a challenge in contributing effectively. However, adopting a structured approach of asking relevant, strategic questions helped me to clarify objectives, explore alternative viewpoints, and validate assumptions.

Following is a template I use to guide my questioning strategy in an unfamiliar discussions:

SpringBoot application on AWS ECS - #2

sumit@dsadaily.com (sumit) — Wed, 28 Feb 2024 21:18:00 +0530

This is the second installment of our series on deploying a Spring Boot application on AWS Elastic Container Service (ECS) using the AWS Cloud Development Kit (CDK) and Gitlab CI/CD. In the previous post, we created an ECS infrastructure using the AWS CLI and AWS CDK capable of hosting our application.

In this post, we will automate the deployment step using a GitLab pipeline for continuous deployment.

Maven Build

Assuming all code quality, unit tests, and vulnerability scan jobs are configured as required, the following job will run a Maven build using a Java 17 image.

SpringBoot application on AWS ECS - #1

sumit@dsadaily.com (sumit) — Thu, 22 Feb 2024 21:18:00 +0530

Welcome to the first installment in a series on deploying a SpringBoot application on AWS Elastic Container Service (ECS) using the AWS Cloud Development Kit (CDK) and GitLab CI/CD. In this article, we’ll walk through the necessary steps to set up the underlying infrastructure to run our SpringBoot application efficiently.

This includes:

Setup Fargate backed ECS cluster.
VPC Setup.
Task Definition.
Setup ECS Service.

We will be using AWS CDK for Java to automate the platform setup process so that we can re-create exact same setup every single time without having to manually repeat all the required steps.

Exploring Java Class Loaders

sumit@dsadaily.com (sumit) — Sat, 09 Sep 2023 23:00:00 +0530

Class Loaders play a pivotal role in dynamically loading Java classes into the JVM (Java Virtual Machine) during application execution. Instead of loading all Java classes into memory at once, class loaders fetch classes only when they are requested by the application, which reduces the startup time.

The ClassLoader fetches binary data from the .class files (from local or remote locations) and loads it into the JVM method area. For a given class, this class loading process occurs just once, during the initial reference of a class within the active Java application. Subsequent references reuse the data stored in the method area unless the class has been UNLOADED.

OpenGrok setup for code analysis

sumit@dsadaily.com (sumit) — Sat, 02 Sep 2023 23:18:00 +0530

When GrepCode went out of service a couple of years back, there were not many options available at the time. But things have changed for the better, and various alternatives (both freeware and paid) are available now, like krugle, sourcegraph, TextSherlock, to name a few. However, most available tools are either too basic or expensive for individual use.

OpenGrok is one such option. I started using OpenGrok sometime back to browse through JDK code. It provides a similar experience of “reading” the code in an IDE but does not require the hassle of running the build pipelines to resolve all the dependency issues - to get the linking working. The time saved can be crucial if one quickly wants to understand the context (for any project) amidst some production issue.

Beyond Java-8: new features and other changes

sumit@dsadaily.com (sumit) — Sat, 26 Aug 2023 20:27:00 +0530

The following is a WIP presentation to document changes and feature additions to the Java programming language. The list is intended to cover developer-centered changes and may not cover everything.

I’ll try to keep it up to date with the six-month release cadence.

Optimizing SpringBoot container images

sumit@dsadaily.com (sumit) — Wed, 16 Aug 2023 19:00:00 +0530

While SpringBoot provides a quick and battle-tested way to create a standalone web application(s), the final packaging may be overwhelming for certain scenarios as everything is bundled in a single artifact.

This structure becomes a significant challenge when working with containerized applications. One of the fundamental principles while working with containerized applications is - always keep the frequently changed parts of the application on the top of the image layer stack. It is because any changes in the lower level layers also require rebuilding all the images on top.

Supercharging Spring Boot Development with TestContainers

sumit@dsadaily.com (sumit) — Sat, 29 Jul 2023 23:10:00 +0530

As a developer, I frequently test Spring Boot applications against various dependencies, such as databases, messaging queues, or other services. This process can become complex and cumbersome, especially when dealing with integration tests, as those dependencies have to be externally managed.

Enter TestContainers, a powerful Java library that allows us to spin up disposable containers for testing.

In this blog post, we’ll explore the seamless integration of TestContainers with SpringBoot, create custom container examples, and demonstrate how to leverage docker-compose.yaml for orchestrating multiple containers.

Using github actions for maven builds

sumit@dsadaily.com (sumit) — Thu, 22 Jun 2023 18:40:00 +0530

While GitHub has been the primary choice for an SCM tool for many of us, with the integration of various CI tools and ready-made actions, it is growing as an end-to-end solution for complete DevOps practices.

At my workplace, we are now using GitLab for various purposes(migrated from Bitbucket and TeamCity), and it has been a smooth migration so far. But I wanted to explore similar features in GitHub as I was already familiar with the interface and hosting almost all of my side projects there.

Amazon EC2 and Route53 - one click setup

sumit@dsadaily.com (sumit) — Wed, 07 Jun 2023 08:33:42 +0530

I have been using AWS services at my workplace and on my side projects for several years. While the AWS console provides a quick way to jumpstart, it does not entirely integrate with the typical software development lifecycle.

At my workplace, we have been using Terraform to provision the infrastructure, but for a side project or working on a proof of concept, I am usually looking for a quicker solution without much overhead. AWS provides a fully functional command line toolset that is easy to configure and integerates well with AWS APIs.

Using instancio to populate test data

sumit@dsadaily.com (sumit) — Mon, 05 Jun 2023 13:40:42 +0530

Writing exhaustive, maintainable, and relevant unit tests are essential to the software delivery lifecycle. But it can quickly become a tedious task, especially while working with large message payloads with a significant number of attributes. Moreover, the relevant test data is governed by many factors, like patterns, mandatory or optional attributes, and value ranges, to name a few.

One option is to source this data directly from production or a production-like environment, but depending on the application you are working on, using actual production-like data for testing may not be the best option always due to various data governance rules.

SSL Offloading and Let's Encrypt Certificate Integration

sumit@dsadaily.com (sumit) — Tue, 30 May 2023 21:12:00 +0530

Securing web communications with SSL/TLS certificates is crucial for protecting sensitive data. But depending on the inbound traffic volume, you can delegate the encryption-decryption task to a dedicated web server allowing your application server to focus on serving the business functionality only.

Let’s Encrypt, a free and open certificate authority, provides an accessible way to obtain and manage SSL certificates. This blog post will explore leveraging Let’s Encrypt certificates for SSL offloading using the Apache HTTP Server as a reverse proxy on an Ubuntu 22.10 machine.

Scaling infrastructure horizontally

sumit@dsadaily.com (sumit) — Tue, 16 May 2023 20:12:00 +0530

Vertical and Horizontal scaling are two approaches to deal with increased load on the system. While Vertical scaling involves adding more resources such as CPU, RAM, or storage to an existing machine, horizontal scaling involves adding more devices to the overall platform.

While both approaches have their advantages, there are situations where vertical scaling is not a suitable option. In the last couple of years, I had this discussion multiple times with my colleagues and clients where they are not in favor of increasing infrastructure footprint and are more inclined towards expanding the overall system capacity by adding more resources like CPU, memory, etc.

Using gitlab CI_JOB_TOKEN for including remote projects

sumit@dsadaily.com (sumit) — Sat, 13 May 2023 01:10:00 +0530

At my workplace, we recently migrated all our repositories to GitLab as part of the DevOps rationalizing program. The idea was to adopt uniform tools and practices across the organization, as previously, different teams were using various tools for SCM and build/deployment pipelines.

The migration had a couple of challenges due to missing features like group-level merge permissions and code quality gates (similar to Sonarway). Also, as we had some custom solutions running for many years, finding an alternative for those in the new world was additional overhead.

The curious case of Bloom Filters

sumit@dsadaily.com (sumit) — Thu, 26 Jan 2023 04:58:00 +0530

A Bloom Filter is a probabilistic data structure used to check the presence of an element in a large dataset.

Unlike traditional collections like a HashSet, a Bloom Filter is NOT used to store the data itself but is only used to check its absence with surety (or its presence with an accepted tolerance level). This makes it space efficient as the presence or absence can be denoted by a single bit, whereas the records in the data set can be of any size.

Garbage Collectors

sumit@dsadaily.com (sumit) — Mon, 25 Oct 2021 05:01:53 +0000

Garbage Collection is one of the most appreciated features of the Java programming language, making it suitable for all kinds of applications. The ability to automatically recover the previously allocated memory, which is no longer in use, allows the Java programmers to focus on the core business logic - a big selling point compared to other object-oriented languages like C++, where the programmer must manually manage the memory.

In most cases, the GC process can be categorized into the following:

Lambda Expressions and Exception Handling

sumit@dsadaily.com (sumit) — Fri, 01 Oct 2021 00:30:00 +0000

With the introduction of lambda expressions in Java8, significant support was added for functional-style programming, thus promoting a more concise coding style.

But even then, the lambda expressions lag basic exception handling features and at times lead to more verbose code on the contrary.

This short article will explore a few options to wrap lambda expressions inside exception handlers for checked and unchecked exceptions.

Exception Prone Action

The first task for us is to define an exception-prone action that can terminate abruptly due to a checked or unchecked exception. As we anyways have to devise a solution for lambda expressions, this action has to be a FunctionalInterface that we can use to map lambda expressions.

Streams and Iterables

sumit@dsadaily.com (sumit) — Wed, 08 Sep 2021 15:27:19 +0000

Quoting Wikipedia, the iterator design pattern is used to traverse a container for accessing its elements. But with the introduction of streams in java8, we now can leverage parallel processing utilizing the underlying hardware to its maximum potential.

In this post, we’ll explore the StreamSupport class and its various methods that help us to wrap an iterable instance as a stream of elements.

Iterables and stream operations

The Iterable interface does not have any stream() method, so while the overall purpose at a high level remains the same, i.e., to traverse the elements, we cannot directly use an iterator to generate a stream for our custom use-cases.

JDK - oracle build alternatives

sumit@dsadaily.com (sumit) — Sat, 21 Aug 2021 18:30:00 +0000

Java language ecosystem can be viewed as a collection of Specifications, Specification requests, and Enhancement proposals. The specifications, when implemented, result in JDK, which is at the core of application development in the Java ecosystem.

Together with JVM and JRE, it allows end-to-end development ranging from small applications to large-scale enterprise applications. A standalone JDK setup includes a private JRE - a collection of JVM and other runtime libraries which allows us to compile, run and debug Java code.

Implementing a Custom Thread Pool

sumit@dsadaily.com (sumit) — Mon, 16 Aug 2021 16:19:41 +0000

When working with multithreaded code, the availability of multi-core systems increases the overall application throughput quite significantly as long as the tasks and the available threads are managed effectively. However, as soon as things go out of control, the associated overhead outweighs the benefits achieved.

In this article, we’ll explore some multithreading concepts by writing our very own custom thread pool to manage several tasks and threads. You can visit this link for more details about thread pool data structure.

Suppressed Exceptions

sumit@dsadaily.com (sumit) — Tue, 13 Jul 2021 17:24:37 +0000

Java provides a robust and efficient exception handling framework used in all sorts of applications irrespective of their size. Moreover, it allows us to create custom exceptions and handlers to better drive the application flow.

If something goes wrong during the execution of a method, the method creates an instance of an Exception class that contains all the relevant details in the form of the stack trace and hands it over to the runtime, i.e., JVM. This process is known as throwing an exception.

Checked Collection - stronger type safety

sumit@dsadaily.com (sumit) — Sun, 20 Jun 2021 07:23:27 +0000

With the introduction of generics in java5, strong type-safety was built right-in when working with collections. Generics allows us to ensure that only valid data is inserted into a list or any other collection.

From a developer standpoint, these checks are quite important as they allows us to identify any erroneous scenarios at the compile time itself instead of the runtime. But the only way to reap its full benefit is by always using generic code.

Maintaining equals and compareTo contract

sumit@dsadaily.com (sumit) — Mon, 14 Jun 2021 16:01:33 +0000

As a java developer, you must have been already following a famous principle to maintain the contract between the hashCode and equals methods.

But we often ignore another equally important principle: to maintain the contract between equals and compareTo methods.

Consider the following example and try to identify the output ( JDK-6394757):

public static void main(String[] args) {
    test("A");
    test("A", "C");
}

private static void test(String... args) {
    var caseInsensitiveSet = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
    caseInsensitiveSet.addAll(List.of("a", "b"));
    caseInsensitiveSet.removeAll(List.of(args));
    System.out.println(caseInsensitiveSet);
}

The sample code, when tested on openjdk@1.16.0 produces the unexpected output:

Logging - information vs noise

sumit@dsadaily.com (sumit) — Fri, 11 Jun 2021 10:03:29 +0000

A log file is logically equivalent to a flight recorder in an aircraft. It keeps track of everything happening inside the application context (and sometimes system or external environment-related information). Thus, whenever we need any insight into the application (be it any functional scenario investigation or troubleshooting any technical issue), the log file is our door to the mystery land.

But for a moment, let’s try to visualize the situation that we might end up in if we do not pay attention to any logging best practices or follow any templates.

About

sumit@dsadaily.com (sumit) — Mon, 07 Jun 2021 10:17:21 +0000

Hello, my name is Sumit Gaur.

This is my corner of the internet where I write about software design and implementation using java as the primary programming language.

I mostly write about the language features and implementation techniques that I find helpful in my day-to-day life as a developer, hoping that you too will find those helpful.

The best way to contact me is via email: sumit at jvmaware dot com. If you have any suggestions regarding the posts or any specific topic you want me to cover, please drop a one-liner to start the conversation.

Container Aware - running java applications inside containers

sumit@dsadaily.com (sumit) — Sat, 10 Apr 2021 18:30:00 +0000

With more and more organizations adopting containers as their preferred mode of deploying packages, it is essential than ever to understand the inner workings of containerized execution environments, especially how policing is done for resources like memory, CPU in a container.

As we know, a container is an isolated process running on a host machine. We can set the amount of resources available to it using host operating system features like namespace isolation and control groups (also known as cGroups). For example:

Some important java projects - April 2021 edition

sumit@dsadaily.com (sumit) — Thu, 01 Apr 2021 18:30:00 +0000

We see new features being added to the java programming language faster than ever with the six-monthly release cycle. This article will explore some of the important projects currently in the development (incubation, preview, early access) stage. We will not be exploring the topics in detail, but this will be a curated list of the official documents for easy reference.

Also, we can’t say for sure when these will be released to the general users, but it is something that will keep us motivated to continue using java at least for the foreseeable future:

Streaming large dataset over Rest

sumit@dsadaily.com (sumit) — Wed, 17 Mar 2021 18:30:00 +0000

Java8 streams provide a convenient way to process large amounts of data leveraging the underlying multi-core hardware capabilities (in most cases). But is it possible to extend these features to our DAO layer as well? We’ll try to explore the options in this post.

Please note that we’ll not be focusing on the reactive streams implementations like WebFlux, RSocket, etc., in this post. We will focus on the native streaming capabilities provided by SpringMVC out of the box.

How to manage multiple Java versions on Windows PC?

sumit@dsadaily.com (sumit) — Sun, 14 Feb 2021 18:30:00 +0000

When Oracle decided to go with the six-month release cycle for new Java versions, many developers started to work with more than one Java version at a time. It is relatively easy to switch between different versions on a Mac or Linux-based system, thanks to utilities like Jabba and jEnv; But on Windows, this is not as straightforward.

Jabba can install multiple Java versions on a Windows PC machine, but it does not set the corresponding persistentJAVA_HOME or Path variables for the current user. jEnv, on the other hand, does not work at all on Windows PC machine and can only be used for Mac or Linux based setups.

LRU Cache

sumit@dsadaily.com (sumit) — Fri, 15 Jan 2021 18:30:00 +0000

Caching in computer science represents a technique to keep frequently used items in low latency memory compared to high latency disks or databases. This allows us to retrieve those items quickly when required and thus improve the application’s overall performance.

But due to the limited resources available, we can only keep a finite number of elements in memory at any given point in time. This requires us to decide on an eviction policy, which will remove the cached items when there is no more space left to add new items.

Optimistic vs Pessimistic Locking

sumit@dsadaily.com (sumit) — Mon, 04 Jan 2021 18:30:00 +0000

Before we dive deep into the details of the two lock types, let’s first try to understand the need for locking and how it is actually implemented.

As we know every time there are more tasks(threads) spawned by a process than the available number of CPU cores, the operating system mimics parallelism by concurrency management. The same is achieved via context switching. In other words, the operating system creates an illusion of parallel execution of these threads by rapidly allocating underlying resources (CPU core(s) in this case) in addition to making sure that the tasks do not conflict with each other.

Using enum as a Simple Factory

sumit@dsadaily.com (sumit) — Fri, 18 Dec 2020 18:30:00 +0000

The factory design pattern is one of the most commonly used design pattern. Its various variants like simple factory, factory method and abstract factory helps you write code that follows high level of abstraction, keeping the low level details (like instantiation, object reuse, etc.) hidden from the client code.

When implementing simple factory, the idea is to provide details of the required class to be instantiated and the factory class will take care of the rest. The input details should be sufficient for the factory class to uniquely identify the class type to be instantiated.

JGit - manage git workflow programmatically

sumit@dsadaily.com (sumit) — Sat, 12 Dec 2020 18:30:00 +0000

JGit developed by the Eclipse Foundation is a java implementation of the git workflow. When included as a maven or gradle dependency, it allows you to execute most of the git cli commands programmatically, removing the dependency triggering external commands from a java program.

As part of this post, we’ll explore the usage of JGit for some commonly used commands:

init

The init command is used by git to initialize a blank repository on a local system which can then be linked to a remote repository. A hidden .git directory is created inside the working directory which holds all the configuration files corresponding to the remote repository.

Remote Proxy Pattern

sumit@dsadaily.com (sumit) — Sun, 29 Nov 2020 18:30:00 +0000

The proxy design pattern helps us in scenarios where we want to substitute actual instance with a placeholder. Assuming the actual instance to be a remote service instance, we can use the design pattern to implement a client-server model allowing us to segregate the complex business logic as a separate layer.

Another advantage of this implementation is the minimal footprint of code (mostly boilerplate), required to manage request-response, in case there are multiple services with more than 1 method.

Prioritize tasks in a Thread Pool Executor

sumit@dsadaily.com (sumit) — Sat, 21 Nov 2020 06:04:42 +0530

While java.util.concurrent.Executors provides a lot of factory and utility methods to create ThreadPoolExecutor with various combinations of underlying resources (threadFactory, poolSize etc), the default configurations might not be sufficient for every use-case.

Consider the use-case where you want to prioritize the tasks submitted so that they are executed based on their priority and not the order of their submission. But as the default configuration uses a LinkedBlockingQueue (as mentioned below), this will not serve the purpose.

HashCode Calculation

sumit@dsadaily.com (sumit) — Mon, 02 Sep 2019 06:04:42 +0530

Assuming that you are already aware of the concept of hashing and hash functions in general, this post is an attempt to highlight the details of how the hash function is implemented in java8

Let’s take a quick look at the below-mentioned snippet from java8 (1.8.0_221) - HashMap class:

// Computes key.hashCode() and spreads (XORs) higher bits of hash
// to lower.  Because the table uses power-of-two masking, sets of
// hashes that vary only in bits above the current mask will
// always collide. 
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

From the above-mentioned code, we can see that the hash method:

Bitwise Operators

sumit@dsadaily.com (sumit) — Fri, 17 May 2019 06:04:42 +0530

Bitwise operators are used in a class of algorithms where instead of performing common operations like addition, comparisons, etc on the decimal numbers, those are performed on the individual bits that comprise those numbers. The bitwise operations are considered very efficient as compared to their decimal counterparts.

Following is the list of bitwise operators:

Bitwise AND (&): Performs bitwise AND on the individual bits of the two operands. The result of this operation results in a set bit if the two operands were also set (1)and unset (0) otherwise.