DEV Community: Ritabrata Das

Quarkus - Java for Kubernetes

Ritabrata Das — Mon, 02 Jun 2025 21:52:53 +0000

🚀 Getting Back in the Game with Quarkus – Supersonic Java for the Cloud

Hey devs! After a bit of a blogging hiatus (four years, to be exact!), I'm back—and what better way to return than with something that redefines Java for the modern cloud: Quarkus.

In this post, I’ll walk you through what Quarkus is, why it matters, and how you can get started fast—even if you're still nursing a hangover from heavyweight Java EE setups. 😅

🔍 What is Quarkus?

Quarkus is a Kubernetes-native Java framework tailored for GraalVM and HotSpot, crafted to make Java a top-tier citizen in the world of containers and serverless. Developed by Red Hat, it’s built on proven libraries like Hibernate, RESTEasy (JAX-RS), Vert.x, and Eclipse MicroProfile.

💡 Why Quarkus Exists:

Java is awesome, but its traditional frameworks are not cloud-native.
Cold start times, memory bloat, and long build cycles have made Java fall behind newer languages in the microservices world.
Quarkus fixes that.

⚡ Key Features That Got Me Hooked

Feature	Why It Rocks
Fast Boot Time	Quarkus boots in milliseconds, making it suitable for serverless.
Low Memory Usage	Native builds use less RAM than traditional JVMs.
Live Coding	Real-time reload without restarting the server.
Kubernetes Native	Built for containers and Kubernetes out-of-the-box.
Developer Joy	Simple configuration, dev UI, and zero-config REST endpoints.

🔧 Getting Started in 3 Commands

Here’s how to scaffold a Quarkus project in seconds:

# 1. Generate the project
mvn io.quarkus.platform:quarkus-maven-plugin:3.10.1:create \
    -DprojectGroupId=org.acme \
    -DprojectArtifactId=my-quarkus-app \
    -DclassName="org.acme.GreetingResource" \
    -Dpath="/hello"

# 2. Enter the project
cd my-quarkus-app

# 3. Start in dev mode (hot reload FTW!)
./mvnw quarkus:dev

You’ll get a simple REST endpoint at http://localhost:8080/hello returning a friendly greeting.

📦 Native Compilation with GraalVM

Native compilation is where Quarkus shines.

./mvnw package -Pnative
./target/my-quarkus-app-1.0.0-runner

You get a tiny binary, fast startup, and lower resource consumption—perfect for cloud deployments.

✅ Advantages of Using Quarkus

⚡ Blazing Fast Startup Time – Critical for serverless and autoscaling environments.
🧠 Developer Productivity – Live reload, dev UI, and easy-to-add extensions speed up development.
🐳 Cloud-Native by Design – Built for Docker/Kubernetes with out-of-the-box support.
🛠️ Modern Tech Stack – Supports imperative and reactive programming models.
🧬 Native Compilation – Thanks to GraalVM, apps can compile to small, fast executables.
💼 Enterprise-Ready – Supported by Red Hat and built on top of mature libraries.

⚠️ Disadvantages / Limitations

🧊 Cold Start for Native Builds – Native compilation times can be long and require GraalVM setup.
🧩 Immature Ecosystem (compared to Spring) – Fewer integrations and community plugins.
🧪 Learning Curve – Concepts like reactive programming or Panache might take getting used to.
🔍 Debugging Native Binaries – Debugging GraalVM-compiled apps can be more complex.
📦 Not a Drop-in Spring Replacement – Some Spring features may not work out-of-the-box.

🧩 Extension Ecosystem

Quarkus offers a wide range of extensions. Just run:

./mvnw quarkus:list-extensions

Need Kafka? Redis? Panache for ORM? Just add the extension and you’re good to go.

🔗 Cloud-Ready by Default

Deploying to Kubernetes or OpenShift? Quarkus simplifies it with built-in configurations and Kubernetes descriptors generation.

./mvnw clean package -Dquarkus.kubernetes.deploy=true

Boom—your app is on Kubernetes.

🧠 Final Thoughts

If you’ve been avoiding Java for greenfield cloud-native projects, Quarkus might change your mind. It brings performance, simplicity, and joy back to Java development in a way that’s actually fun again.

This is just the beginning—next up, I’ll explore reactive programming with Quarkus and integrating it with Kafka and PostgreSQL.

Stay tuned—and happy coding! 👨‍💻🔥

Have questions, thoughts, or suggestions? Drop a comment below or hit me up on Instagram / GitHub!

NB - I am coming back to writing articles after 4 years. Support me at:

Control Google Meet With Expressions/Gestures

Ritabrata Das — Thu, 26 Aug 2021 09:41:15 +0000

With the advancements made in the field of modern day machine-learning technologies, it has become quite easy and flexible to develop models and applications based on this domain. So, you might have a perception that the realm of Machine Learning requires complex algorithms and huge expert knowledge for it's projects.

However, in the recent times, it has been quite easy to develop them as most of the standard algorithms and models are made available on the Internet in the form of web-applications. In this project, we will be using Teachable Machine, along with Tensorflow.js to control the basic actions in Google Meet such as muting, switching off your video and a special action, which will be revealed in the later course of the article.

Teachable-Machine

Teachable Machine is an online web-application, created by Google Creative Labs that facilitates easy and fast creation of machine learning models that is accessible to everyone on the net. It is flexible as it makes use of pre-existing files or even capture live examples, which will be recorded as instances, on the basis of which references will be made. You can even make a choice to use your models entirely on-device, without any webcam or microphone data being conveyed outside your system.
The advantage is that you train your computer to recognize your images, sounds, and poses of your personal choice, without writing any complicated and long machine learning code. Then, you can use your model in your own projects, applications, websites and even more. It is powered by Tensorflow.js, which is an open-source library, created by Google for the purpose of Machine-Learning.

Prerequisites

Well, at the most, what you require is the basic knowledge of Vanilla JavaScript, a webcam, an Internet connection and the passion to learn something new. Then, follow the below steps and get your own functional model developed in front of your eyes.

The Project

The project is in the form of a chrome browser-extension, which basically controls all the actions on Google Meet. The article has been divided into the following subtopics to facilitate your understanding:

Step 1: Training your Model

The first step involves creating the basic models on Teachable Machine. The model can be either any image, body pose or sound of your choice. In this project, we have decided to utilize the basic image model for training our computer. However, you can also use body poses and speech to train your model otherwise. Make sure the images, poses or sounds that you wish to implement are quite unnatural and can be performed accurately.

Now, to start with, head over to the Teachable Machine site and click on Get Started. You can further access it from the hamburger menu at the top-left corner of the homepage. You will get the following page:

You will now get the options for creating your model online to train your machine. There are three different projects namely Image Project, Audio Project and Pose Project. For our model, we have used the Pose Project for it's implementation. You can also import your previously saved models from your Google Drive or local file system if you want to use a model which was created beforehand and you wish to reuse and modify it. If you want a new model, just click on Pose Project. Then, the site will redirect you to your project destination:

First, you have to record your images in the form of "classes". The images can be captured live via webcam, or can be uploaded from the local file system as well. The image samples of a particular class should be same and repetitive in nature, while the image samples used in various classes should be different so that the class can be defined more accurately and can be recognized with ease.

It is advisable to record at least 50 to 60 images for increasing the accuracy threshold of the recorded class. In order to record live instances, grant permission to your webcam and press the Hold to Record button to capture your live images.

If you want a free tutorial on how to record your model in the form of images, you can head over to the Teachable Machine Tutorial and click on "Let's Go" for a live demo practice.

You can change the labels of the classes according to your wish. In this project, we have made use of three classes namely: Audio,Video and Escape, which are recorded live via webcam. The images in these classes can be specific hand gestures ,facial expressions or particular objects, which can be identified and recognized by the machine easily.
In order to add more than two classes, click on Add Class. After recording the image samples for the respective classes, it is time to train and export your model.

Step 2: Exporting your Model

After, you have created your respective classes, click on Train Model, which will train your machine to recognize the content of the images, which will be used in our upcoming projects. Teachable Machine mainly uses pattern recognition algorithms and involves the usage of:

Statistical Techniques
Structural Techniques
Template Matching
Neural Network Approach
Fuzzy Model
Hybrid Models

After your model has been trained, you can preview your model before exporting it. This helps you to test the model before implementing it in your projects. Just perform the poses according to the images set by you and check whether the machine can identify them or not.

When your model has been prepared, click on Export Model and export the model in the form of Tensorflow.js. Click on Upload my model, which will publish your model online and it will generate an URL , where your model will be hosted by Teachable Machine for free. You can also download it in the form of Tensorflow or Tensorflow Lite for local uses.

The model used in the project is live at: Project Model

Step 3: Preparing the Manifest.json

The next step involves creating a Chrome browser extension to render the following model to the Google Meet URL. So, we have to create the manifest.json file in the browser directory which will be loaded in the browser. So let's have a look at the json file:

{
    "name": "Gmeet_Controller",
    "description": "An extension to control Google Meet Actions using hand/facial gestures.",
    "permissions": ["activeTab", "storage", "tabs", "notifications"],
    "version": "1.0",
    "manifest_version": 3,
    "content_scripts": [{
        "matches": [
            "https://meet.google.com/*"
        ],
        "js": [
            "src/tf.min.js",
            "src/teachablemachine-pose.min.js",
            "src/background.js"
        ]
    }]
}

You can set the name, description and version according to your choice, which is basically the information which will be displayed when you will load the extension on to the browser. You can also store icons in a separate directory in your extension directory and render them on to the browser. The URL needs to be specified in "matches" under content scripts. You can set permissions as well, if you do not want the extension to have unnecessary access to your system storage, notifications etc.

Step 4: Linking your models to Google Meet

Now create a separate directory to store the javascript files (here src), which will render the functionality of the extension. Download the latest and updated version of tf.min.js and teachablemachine-pose.min.js, and place them in the directory.

Note: This project can also be accomplished using npm and yarn packages such as "@teachablemachine/pose" and "@tensorflow/tfjs" or using their CDNs. However, we have used Vanilla JS to make the project simple and beginner-friendly.

After importing, it is now time to frame the background.js. First, declare a constant variable named URL which will contain the model URL that was generated by Teachable Machine.

 const URL = "https://teachablemachine.withgoogle.com/models/<MODEL_ID>/";
// Use your own personalized model here

Then you have to write the basic Javascript to adjust the frame height and width of the webcam, request access from the webcam and keep on updating the webcam frame.

let model, webcam, ctx, labelContainer, maxPredictions;

async function init() {
    const modelURL = URL + "model.json";
    const metadataURL = URL + "metadata.json";

    model = await tmPose.load(modelURL, metadataURL);
    maxPredictions = model.getTotalClasses();

    const size = 200;
    const flip = true; 
    webcam = new tmPose.Webcam(size, size, flip); 
    await webcam.setup(); 
    await webcam.play();
    window.requestAnimationFrame(loop);

    document.getElementById("webcam-container").appendChild(webcam.canvas);
}

async function loop(timestamp) {
    webcam.update();
    await predict();
    window.requestAnimationFrame(loop);
}

Now we have to write the functions to identify the event on the webcam, compare it with the classes of the models and if the event's probability is more than the threshold probability then the function gets executed.


function Audio(probability) {
    if (probability >= 1) {
        const audioButton = document.querySelectorAll(".VfPpkd-Bz112c-LgbsSe.yHy1rc.eT1oJ.tWDL4c.uaILN")[0];
        if (audioButton.classList.contains("HNeRed")) {
            audioButton.click();
        }
    }
}

function Video(probability) {
    if (probability >= 1) {
        const videoButton = document.querySelectorAll(".VfPpkd-Bz112c-LgbsSe.yHy1rc.eT1oJ.tWDL4c.uaILN")[1];
        if (videoButton.classList.contains("HNeRed")) {
            videoButton.click();
        }
    }
}

function Escape(probability) {
    if (probability >= 1) {
        const Button0 = document.querySelectorAll(".VfPpkd-Bz112c-LgbsSe.yHy1rc.eT1oJ.tWDL4c.uaILN")[0];
        const Button1 = document.querySelectorAll(".VfPpkd-Bz112c-LgbsSe.yHy1rc.eT1oJ.tWDL4c.uaILN")[1];
        if (Button0.classList.contains("HNeRed")) {
            Button0.click();
        }
        if (Button1.classList.contains("HNeRed")) {
            Button1.click();
        }
    }
}

async function predict() {
    const { pose, posenetOutput } = await model.estimatePose(webcam.canvas);
    const prediction = await model.predict(posenetOutput);
    var predictionsArray = prediction.map(function (o, i) {
        return { probability: o.probability.toFixed(2), event: o.className }
    })

    var i;
    var min = predictionsArray[0].probability
    var max = predictionsArray[0].probability
    var event = predictionsArray[0].className;
    var value;
    for (i = 1; i < predictionsArray.length; i++) {
        value = predictionsArray[i].probability
        if (value < min) min = value;
        if (value > max) max = value;
    }
    const index = predictionsArray.findIndex((list) => {
        return list.probability == max;
    })
    event = predictionsArray[index].event;

    if (event === "Audio") {
        Audio(max);
    } else if (event === "Video") {
        Video(max);
    } else if (event === "Escape"){
        Escape(max);
    }
}


const webcamContainer = document.createElement("div");
webcamContainer.id = "webcam-container";
document.body.appendChild(webcamContainer);

init();

Open Google Chrome, and type "chrome://extensions", to navigate to the Extensions window. Now toggle on the Developer mode, and click on Load unpacked. Then open the file directory where your manifest.json is stored. The extension is now ready to work.

Now you can have your own personalized model working on your system!

Demo

Here you can have a short look at the working model of the project:

Resources

You can further refer to the following documentation and tutorials to know more about the libraries and technologies:

Credits: Arju S. Moon

You can find the github repository for the above project here:

RitabrataDas343 / GMeet_Controller

This is a browser extension used for controlling Google Meet using hand/facial expressions.

This article has been written and established by:

Ritabrata DasFollow

Open-Source Fanatic || Full-Stack Developer || Graphic Designer || C.P. Enthusiast || CTF Player

and

Shubham Shantam RajuFollow

Open Source Enthusiast | Sophomore of NIT Durgapur | Member of GNU Linux Users' Group | Full Stack Devleoper (MERN) | Blockchain Enthusiast

Hope you have found this article resourceful.

Have a go through the following links to know more about us and keep yourself updated with the latest stuff:

Do drop a like to the post and comment down below if you have liked the idea and are interested in exploring the domain of Machine-Learning along with us. Any kind of suggestions and propositions are appreciated.

May The Source Be With You! 🐧❤️

Adding port "8080/tcp" using UFW

Ritabrata Das — Mon, 10 May 2021 11:10:35 +0000

Hello there!!1
I have recently done a research on how to add the port 8080/tcp in my system and list all the active ports in a text file called "zones.txt". I use a Linux Mint 20.1 XFCE system and I came across the apt-package named Uncomplicated Firewall. This package allows you to open ports on your system and makes them ready for use using ssh.
Here is a screenshot on how to progress with the procedures.

I am also attaching my GitHub gist which provides an detailed explanation on how to implement this in your system.

Best of Luck and May the Source be with You 🐧💗.

i3 Ricing

Ritabrata Das — Sun, 09 May 2021 14:12:25 +0000

Hello guys!!!
Recently I have riced my entire Linux Mint 20.1 XFCE using the i3-window manager. Developers mostly use upgraded ricing tools like the Awesome window manager for their ricing models. Ricing in Arch-based systems is comparatively easier than in Ubuntu-based systems. Although, I preferred i3-window manager as it is good for beginners and we get to build the ricing model from scratch.

My Ricing model is uploaded on YouTube on my friend's channel:
i3-riced model

The configuration file for the ricing model is uploaded on GitHub:
i3-config-files

RitabrataDas343 / i3_Ricing

This is the repository containing the ricing configuration of the system. Please follow the steps of the README.md file in the repository to get the desired effect of ricing.

i3_Ricing

This is the repository containig the ricing configuration of the system. Please follow the steps of the README.md file in the repository to get the desired effect of ricing.

i3 is one of the most popular open source software that is used for ricing. 'Ricing' basically represents customizing desktop and enables multi-tasking tiling features and so on.

To install

$ sudo apt install i3
$ sudo apt install feh thunar rofi pavucontrol arandr i3blocks compton lxappearance

Logout of the window and on the login screen, you will get a white icon depicting the i3 window manager, select that and login.

On login, you will get to choose Win or Alt keys to be your Mod key. It is preferable to use the Win key but you can use the Alt key as well.

Now, you are good to go.

Patch the i3 folder from the repository and place it

…

View on GitHub

I hope you can try it and publish your ricing models too.

Other references:

Happy Ricing!!!
May the Source be with you 🐧💗.