News
Entertainment
Science & Technology
Life
Culture & Art
Hobbies
News
Entertainment
Science & Technology
Culture & Art
Hobbies
Mutation Testing in Rust
I’ve been a big fan of Mutation Testing since I discovered PIT. As I dive deeper into Rust, I wanted to check the state of mutation testing in Rust. Starting with cargo-mutants I found two crates for mutation testing in Rust: cargo-mutantsand mutagen mutagen hasn’t been maintained for three years, while cargo-mutants is still under active development. I’ve ported the sample code from my previous Java code to Rust: struct LowPassPredicate { threshold: i32, } impl
Clean your Memory: From Finalize to Cleaner
Garbage collection in Java takes care of memory management, but it does not clean up non-memory resources like sockets or file handles. Resource leaks may occur without proper management, leading to performance degradation or crashes. Java’s Cleaner API, introduced in Java 9, provides a modern and efficient mechanism for resource cleanup when objects are no longer reachable. It addresses the shortcomings of the deprecated finalize() method, offering a predictable and efficient way to manage
One giant Kubernetes cluster for everything
The ideal size of your Kubernetes clusters is a day 0 question and demands a definite answer. You find one giant cluster on one end of the spectrum and many small-sized ones on the other, with every combination in between. This decision will impact your organization for years to come. Worse, if you decide to change your topology, you’re in for a time-wasting and expensive ride. I want to list each approach’s pros and cons in this post. Then, I’ll settle the discussion once a
Improving Maven's dependency:analyze... or not
Recently, my good friend Richard Fichtner advised using the mvn dependency:analyze command to get rid of declared but unused dependencies: There is another use case for mvn dependency:analyze It can show you the dependencies you use in your code but have not declared in your pom.xml. This works because you have a transitive dependency on your classpath. Either don't use the dependency or declare it.[image or embed]— Richard Fichtner 💻☕ (@richard.fichtner.dev) December 10, 2024 at 2:
WebAssembly on Kubernetes
Like a couple of innovative technologies, different people have different viewpoints on where WebAssembly fits the technology landscape. WebAssembly (also called Wasm) is certainly the subject of much hype right now. But what is it? Is it the JavaScript Killer? Is it a new programming language for the web? Is it (as we like to say) the next wave of cloud compute? We’ve heard it called many things: a better eBPF, the alternative to RISC V, a competitor to Java (or Flash), a performance booster
Pull request testing on Kubernetes: vCluster for isolation and costs control
This week’s post is the third and final in my series about running tests on Kubernetes for each pull request. In the first post, I described the app and how to test locally using Testcontainers and in a GitHub workflow. The second post focused on setting up the target environment and running end-to-end tests on Kubernetes. I concluded the latter by mentioning a significant quandary. Creating a dedicated cluster for each workflow significantly impacts the time it takes to run. On GKE, it t
Pull request testing on Kubernetes
Imagine an organization with the following practices: Commits code on GitHubRuns its CI/CD pipelines with GitHub ActionsRuns its production workload on KubernetesUses Google Cloud A new engineer manager arrives and asks for the following: On every PR, run integration tests in a Kubernetes cluster similar to the production one. It sounds reasonable. Engineering manager: I want #integrationtests to run on the app deployed on #Cloud infra for each #GitHub PR ✅ Me, thinking it's a no
Pull Request testing on Kubernetes: working with GitHub Actions and GKE
I’m continuing my series on running the test suite for each Pull Request on Kubernetes. In the previous post, I laid the groundwork for our learning journey: I developed a basic JVM-based CRUD app, tested it locally using Testcontainers, and tested it in a GitHub workflow with a GitHub service container. This week, I will raise the ante to run the end-to-end test in the target Kubernetes environment. For this, I’ve identified gaps that I’ll implement in this blog post: Create
Pull request testing on Kubernetes: testing locally and on GitHub workflows
Imagine an organization with the following practices: Commits code on GitHubRuns its CI/CD pipelines with GitHub ActionsRuns its production workload on KubernetesUses Google Cloud A new engineer manager arrives and asks for the following: On every PR, run integration tests in a Kubernetes cluster similar to the production one. It sounds reasonable. Engineering manager: I want #integrationtests to run on the app deployed on #Cloud infra for each #GitHub PR ✅ Me, thinking it's a no
Remote Development made simple with DevPod
I come relatively late to the subject of Remote Development Environments (also known as Cloud Development Environments). The main reason is that I haven’t worked in a development team for over six years. However, I’m now working for Loft Labs, and we have a RDE product: DevPod. I wanted to understand our value proposition as I’ll be at FOSDEM operating the DevPod booth. The problem As a former developer, I vividly remember the pain of setting up each developer’s develo
On inheritance and subtyping
Java is the first language I learned in my career. Its structure is foundational in my early years of understanding programming concepts. After going through several other languages with very different approaches, I’ve widened my point of view. Today, I want to reflect on the idea of inheritance. Inheritance in Java In Java, the idea of inheritance is tightly coupled with the concept of subtyping. Subtyping is the implementation of a IS A relationship. For example, the Rabbit class is a
My first steps with Playwright
In my previous company, I developed a batch job that tracked metrics across social media, such as Twitter, LinkedIn, Mastodon, Bluesky, Reddit, etc. Then I realized I could duplicate it for my own 'persona'. The problem is that some media don’t provide an HTTP API for the metrics I want. Here are the metrics I want on LinkedIn: I searched for a long time but found no API access for the metrics above. I scraped the metrics manually every morning for a long time and finally decided to au
The Home Assistant companion app
Besides a regular webapp and a Mac app, which uses the same endpoints as the webapp, Home Assistant also provides mobile apps. In this post, I want to describe its advantages over the former. I’ll use iOS to do this: Samsung’s French partner to recycle used mobiles tricked me once, and I moved away from Samsung. I decided to buy Apple for better integration since I’ve had Mac computers for the last few years. Installing and configuring The companion app is readily available
2024 in retrospective
For the first post of 2025, I’m continuing my retrospective series. As last year, before diving in into the report proper, I’d like to remind you that Ukraine is still fighting for its survival after nearly 3 years and countless Russian war crimes. The civilized world can’t allow rewarding the invasion of a sovereign country, lest we see more invasions. Remember that in 1938, in Munich, European 'leaders' acknowledged Hitler’s annexation of Czechoslovakia’s Sudeten
An example of HACS: Adaptive Lighting
In the previous post of this focus, we replaced Philips Hue automation with the one from Home Assistant. One significant gap we noticed was that Home Assistant doesn’t automatically adjust the brightness according to the time of the day, a feature Philips Hue offers. In this post, we are going to address this gap. The first step when wanting to add a feature to Home Assistant is to browse through available integrations. While there was no out-of-the-box integration, I discovered an altern
A solution to the problem of cluster-wide CRDs
I’m an average Reddit user, scrolling much more than reading or interacting. Sometimes, however, a post rings a giant red bell. When I stumbled upon If you could add one feature to K8s, what would it be?, I knew the content would be worth it. The most voted answer is: Namespace scoped CRDs A short intro to CRDs Kubernetes comes packed with existing objects, such as Pod, Service, DaemonSet, etc., but you can create your own: the latter are called Custom Resource Definitions. Most o
Replace Philips Hue automation with Home Assistant's
This is the 3rd post in the My journey with Home Assistant focus series. I’m the happy owner of a couple of Philips Hue connected lights for a some years. Some of them are colored, some of them regular. In addition, I bought a sensor to go along with the light I installed in my toilets: it turns on automatically when its detects a movement there. In this post, I want to document how I replaced the proprietary automation with Home Assistant’s.
The Home Assistant model
Home Assistant is a massive beast. It can be overwhelming for a newcomer; it was for me. In this post, I want to describe the underlying model of Home Assistant, which is a good entry point for your home automation journey. The biggest issue in describing the Home Assistant is the number of conflicting sources for this model: The helpers package of the GitHub repositoryThe database; disclaimer: I didn’t find the schema generation in the code, and I wasn’t bold enough to check the d
Why Home Assistant?
This is the 1st post in the My journey with Home Assistant focus series. Last June, I spoke at Berlin Buzzwords. In all honesty, I rarely attend others' talks for a variety of reasons: lack of time, lack of energy, no interest in the proposed subjects, etc. When I do, I go either for subjects I know and want to deepen my understanding of or for subjects I know nothing about to get a foot in the door. This time, I attended Monitoring your home, with DevOps observability tools. I thought it would b
Pseudo-Random Number Generators: From the Origins to Modern Algorithms
How can we generate a uniform sequence of random numbers? The randomness so beautifully and abundantly generated by nature has not always been easy for humans to extract and quantify. Pseudo-Random Number Generators are fundamental tools in many areas of software development: PRNGs do not produce truly random numbers but rather deterministic sequences that simulate randomness. The quality of a PRNG is determined by its ability to produce sequences that are statistically indistinguishable from t
Langchain4J musings
I’m coming relatively late to the LLM party, but I rarely come very early in the hype cycle. For example, I never bought into blockchain, the solution still searching for problems to solve, nor in microservices, the latest in the cargo cult IT trends. Despite my late arrival at the LLM party, I have been a regular user of LLMs. I use OpenAI for non-controversial questions outside my cone of knowledge, e.g., linguistics or legal; I use GitHub Copilot in my IDE to improve my code. Th
DuckDB in Action
The book was sent to me by Michael Simons. He asked for my feedback: I changed my reading schedule, took a few months, and here it is. Facts 10 chapters288 pages$33.59 (eBook) Note that MotherDuck, a company providing an online service that builds upon DuckDB, offers a free PDF copy. Chapters An introduction to DuckDBGetting started with DuckDBExecuting SQL queriesAdvanced aggregation and analysis of dataExploring data without persistenceIntegrating with the Python ecosystemDuckDB in the
Digital Twins: A digital counterpart for a new concept of Product
Digital Twins, are digital replicas of physical assets, processes, or systems used to simulate, monitor, and optimize their real-world counterparts. Through real-time data exchange and advanced analytics, digital twins provide a virtual environment for testing scenarios, predicting outcomes, and enhancing decision-making. This concept, first introduced by Michael Grieves in 2002, has rapidly evolved and now plays a crucial role in various sectors, including manufacturing, healthcare, smart cities
Summary of the AJAX frameworks comparison
In previous weeks, I’ve analyzed several libraries and frameworks that augment the client with AJAX capabilities. Vue.jsAlpine.jsHTMXVaadin In this post, I’ll compare them across several axes. Analysis Frontend skills Remember that I started this series from the point of view of a backend developer. In this section, I grade how much you need to know about client technologies to complete the job. Team organization In the introduction, I hinted that the decoupling of frontend
Vaadin, the battery-included server-side AJAX framework
I’ve written a lot about Vaadin. I was so enthusiastic that I wrote the first book about it (besides the Book of Vaadin), its updated edition for Vaadin 7, and a companion website. Still, I’m amazed that so many people in the JVM world never heard of it. In this post, I’d like to introduce Vaadin in the context of AJAX and SSR. Short introduction to Vaadin The beauty of Vaadin lies in its simplicity - you only write backend code. You read that well. A Vaadin developer only
Augmenting the client with HTMX
This post is part of a series comparing different ways to implement asynchronous requests on the client to augment the latter. So far, I described the process with Vue.js and Alpine.js. Both are similar from the developers' point of view: they involve JavaScript. In this post, I’ll focus on HTMX, whose approach is quite different. Laying out the work I’ll follow the same structure as in the previous posts of the series. Here’s the setup, server- and client-side. Server-s
Augmenting the client with Alpine.js
This post is part of a series comparing different ways to implement asynchronous requests on the client, which is colloquially known as AJAX. I dedicated the previous post to Vue.js; I’ll dedicate this one to Alpine.js - not to be confused with Alpine Linux. I’ll follow the same structure as previously. Laying out the work Here’s the setup, server- and client-side. Server-side Here is how I integrate Thymeleaf and Alpine.js in the POM: pom.xml <dependencies>
Augmenting the client with Vue.js
In my previous post, I laid the ground to build upon; now is the time to start 'for real'. I heard a lot of Vue.js. Additionally, a friend who transitioned from developer to manager told me good things about Vue, which further piqued my interest. I decided to have a look at it: it will be the first 'lightweight' JavaScript framework I’ll study - from the point of view of a newbie, which I am. Laying out the work I explained WebJars and Thymeleaf in the last post. Here’s the setu
Server-Side Rendering with Spring Boot
Understanding the shared steps in the project setup is crucial before delving into the specifics of each client-augmenting technology. My requirements from the last post where quite straightforward: I’ll assume the viewpoint of a backend developerNo front-end build step: no TypeScript, no minification, etc.All dependencies are managed from the backend app, i.e., Maven It’s important to note that the technology I’ll be detailing, except Vaadin, follows a similar approach. V
A short history of AJAX and SSR
My journey in programming began over two decades ago, a time when JavaScript was a far cry from its current state, and developers were primarily focused on Microsoft Internet Explorer. One of my proudest achievements back then was writing a few lines of code that allowed users to add and remove table rows entirely on the client side. We called it DHTML. Many developers today have forgotten about it—or never knew it existed. A few years later, AJAX emerged, revolutionizing the way we approached
DRY your Apache APISIX config
DRY is an important principle in software development. This post will show you how to apply it to Apache APISIX configuration. The DRY principle 'Don’t repeat yourself' (DRY) is a principle of software development aimed at reducing repetition of information which is likely to change, replacing it with abstractions that are less likely to change, or using data normalization which avoids redundancy in the first place. — https://en.wikipedia.org/wiki/Don%27t_repeat_yourself[Wiki
When (not) to write an Apache APISIX plugin
When I introduce Apache APISIX in my talks, I mention the massive number of existing plugins, and that each of them implements a specific feature. One of the key features of Apache APISIX is its flexibility. If a feature is missing, you can create your own plugin in Lua or a language compiled into Wasm, showcasing the platform’s adaptability to your specific needs. In this post, I aim to provide practical alternatives to writing a custom plugin, offering solutions you can quickly implement
Kotlin Coroutines and OpenTelemetry tracing
I recently compared three OpenTelemetry approaches on the JVM: Java Agent v1, v2, and Micrometer. I used Kotlin and coroutines without overthinking. I received interesting feedback on the usage of @WithSpan with coroutines: Nice one..by the way to instrument the coroutine context properly, don't we need "opentelemetry-extension-kotlin" also? Without that, spans are not recorded properly for suspend functions (https://t.co/DSgJklnllD) pic.twitter.com/5wDwhYhoDM— Suresh G (@sur
Default map value
In this post, I’ll explain how to provide a default value when querying an absent key in a hash map in different programming languages. Java Let’s start with Java, my first professional programming language. In older versions, retrieving a value from a map required using the get() method: Map map = new HashMap(); (1) Object value = map.get(new Object()); (2) if (value == null) { value = 'default';
OpenTelemetry Tracing on Spring Boot, Java Agent vs. Micrometer Tracing
My demo of OpenTelemetry Tracing features two Spring Boot components. One uses the Java agent, and I noticed a different behavior when I recently upgraded it from v1.x to v2.x. In the other one, I’m using Micrometer Tracing because I compile to GraalVM native, and it can’t process Java agents. I want to compare these three different ways in this post: Java agent v1, Java agent v2, and Micrometer Tracing. The base application and its infrastructure I’ll use the same base ap
Free tier API with Apache APISIX
Lots of service providers offer a free tier of their service. The idea is to let you kick their service’s tires freely. If you need to go above the free tier at any point, you’ll likely stay on the service and pay. In this day and age, most services are online and accessible via an API. Today, we will implement a free tier with Apache APISIX. A naive approach I implemented a free tier in my post Evolving your RESTful APIs, a step-by-step approach, albeit in a very naive way. I cop
Differentiating rate limits in Apache APISIX
In my talk Evolving your APIs, I mention that an API Gateways is a Reverse Proxy 'on steroids'. One key difference between the former and the latter is that the API Gateway is not unfriendly to business logic. The poster child is rate-limiting. Rate-limiting is an age-old Reverse Proxy feature focused on protecting against DDoS attacks. It treats all clients the same and is purely technical. In this day and age, most API providers offer different subscription tiers; the higher the tier, the hig
Advanced URL rewriting with Apache APISIX
I spoke at Swiss PgDay in Switzerland in late June. The talk was about how to create a no-code API with the famous PostgreSQL database, the related PostgREST, and Apache APISIX, of course. I already wrote about the idea in a previous post. However, I wanted to improve it, if only slightly. PostgREST offers a powerful SELECT mechanism. To list all entities with a column equal to a value, you need the following command: curl /products?id=eq.1 id is the columneq.1 corresponds to the WHERE cla
Dynamic watermarking with imgproxy and Apache APISIX
Last week, I described how to add a dynamic watermark to your images on the JVM. I didn’t find any library, so I had to develop the feature, or, more precisely, an embryo of a feature, by myself. Depending on your tech stack, you must search for an existing library or roll up your sleeves. For example, Rust offers such an out-of-the-box library. Worse, this approach might be impossible to implement if you don’t have access to the source image. Another alternative is to use ready-mad