Mike my bytes

Great engineers keep asking "Why?"

Wed, 10 Dec 2025 06:50:12 +0000

I’ve had some health issues in the last few months. Moving from one doctor to another made me realise something important. Great engineers, just like great doctors, keep asking “why?”.

This question is not only about curiosity. It’s a tool. When we go to a doctor, we expect a diagnosis, not stating the obvious. Cough, fever, stomach pain - these are not much different from timeouts, noisy logs, or odd metrics. In fact, naming observed symptoms is usually easy enough, to be done by the patient alone.

Java 24 - Thread pinning revisited

Wed, 09 Apr 2025 05:12:42 +0000

Back in 2023, I got extremely excited about the release of Java 21. It felt like a significant breakthrough, similar to Java 8. I was also one of the early adopters of virtual threads in my production code. Back then, thread pinning was the main limitation of this promising solution.

The negative impact of thread pinning was initially exaggerated. Shortly after the Java 21 release, many popular frameworks and libraries were updated to become more virtual-threads-friendly. For many standard web apps, updating dependencies was enough to enjoy great scalability and simplicity that virtual threads bring. Yet, I still found it reasonable to keep an eye on thread pinning using Java Flight Recorder (JFR), as I suggested in one of my articles.

A year of scaling myself

Wed, 05 Feb 2025 06:41:11 +0000

2024 was eventful, but professionally quiet. I didn’t speak at major tech conferences, write as many blog posts, or spend as much time on technical deep dives. Still, it was one of the most important years in my almost 12-year career. It was just a bit different.

2024 was a year of scaling myself. Instead of working more, I’ve been exploring ways of making an impact differently. I encouraged people to act, sponsored others’ ideas, and even tried a bit of coaching. Working this way was rather new to me. While I’ve been learning from my mistakes, I’m pretty satisfied with the results.

Continuous monitoring of pinned threads with Spring Boot and JFR

Wed, 17 Apr 2024 09:07:39 +0000

In my previous article about Java Virtual Threads I focused on different pinning cases caused by the synchronized construct. Some of the presented cases were far from being evident just by looking at the code. That’s why I believe that actively monitoring our apps for pinning is a must.

We don’t know if the pinning happens in our app if we’re not monitoring it. We don’t know how frequently it occurs. We don’t know for how long our treads are pinned. Without monitoring, we can only speculate about how pinning affects our application’s performance. I prefer measuring than guessing.

Curiosities of Java Virtual Threads pinning with synchronized

Wed, 28 Feb 2024 06:59:56 +0000

If you heard about Java Virtual Threads, you also heard about the pinning phenomenon. Yet, many articles I found online stop at “replace synchronized with ReentrantLock and don’t use native methods or foreign functions”. While I don’t want to discuss the second part here, I think good-old synchronized deserves a bit more attention.

Note: If you are not familiar with Virtual Threads pinning, I suggest starting with the official Virtual Threads documentation.

The trap of testing simple orchestration

Wed, 17 Jan 2024 06:38:32 +0000

Orchestration code organizes calls to other components (dependencies) into a certain process. Such pieces of code are sometimes called coordinators or controllers. Orchestration code is usually simple. There’s no (or almost no) conditional logic, or algorithmic complexity. Its main job is to delegate the work to appropriate dependencies in a specific order. Separating orchestration from the actual “heavy” work is a good thing. This way they can be tested independently. Theresulting code units are smaller and thus more testable. Yet, orchestration code itself rarely benefits from unit testing.

Spoiled but enlightened

Thu, 07 Dec 2023 06:33:11 +0000

Everybody knows that programmers are spoiled. When not enjoying free fruits in their fancy offices, they probably work from the end of the world that looks like a paradise. Even during challenging economic conditions, the market still tries to exceed their expectations… A comfortable life and great earnings - who wouldn’t want that?

In fact, there’s much more to appreciate. Most developers experience levels of organizational maturity that other industries have never dreamed of. The work culture that has developed over the years really stands out. Yet, we programmers rarely notice that.

Kotlin 'equals ignoring fields' using data classes

Tue, 28 Nov 2023 06:07:47 +0000

Equals ignoring fields is a pretty common operation. While often used within the test code to exclude selected fields from equality assertions, it can also be handy in our domain code.

With Kotlin data classes, we can implement equals ignoring fields without using reflection or extra libraries. This solution feels almost too simple to describe, but it’s interesting to compare it with the available alternatives.

Status quo

Let’s take a simple blog post representation as an example:

Is 21 the new Java 8?

Tue, 03 Oct 2023 06:25:48 +0000

Not all Java releases receive the same attention from the community. The ones marked as “LTS” have a much higher chance of broad adoption (even if many of us don’t fully understand what the “LTS” means). This alone makes the recently released Java 21 a serious contender.

I believe it’s the most influential Java release since Java 8. Just not all of its groundbreaking aspects are already evident to everybody…

Let me explain what makes this release so promising.

Centralizing the decision-making

Thu, 24 Aug 2023 07:15:37 +0000

Imagine we’re building yet another e-commerce platform. One of its crucial business processes is, of course, processing an order. After a successful payment, the Orders module (domain) has to call Warehouse asynchronously to prepare purchased goods. Yet, they may not be there. Usually, it’s not a big deal, since we can get them from our suppliers. But what if any of the items are not available anymore? The order has been already placed! Money has changed hands. Our customer is already waiting for delivery. We have no choice - the order has to be canceled.

Content is king, I'm still Mike - blog revamp

Wed, 16 Aug 2023 06:41:12 +0000

I launched my own brand “Mike my bytes” in November 2020 as an experiment. Rebooting my existing blog (dated back to 2015!) along with becoming active on Twitter really paid off. Apart from joy, it also brought thousands of people interacting with my content every month. Today, it’s high time to make some adjustments. Refreshed mikemybytes.com design is just the beginning.

Content is king

The Twitter I discovered in 2020 is no longer there. X feels like a never-ending experiment with a rather uncertain future. Its competition is segmented more than Android versions, without any clear successor (at least in the EU). Yet, some tech people already gave up and moved somewhere else. It’s hard to blame them - the overall experience is much worse now. At least without a paid subscription…

10 years of software development

Wed, 12 Jul 2023 07:00:41 +0000

The calendar doesn’t lie. A decade of my professional career in software development has just passed. 10 years of experience always felt like a magical and very distant boundary. Am I a better engineer now? Am I a different person? Absolutely! Yet, it didn’t happen overnight.

Reviewing these changes is a fascinating exercise. Sometimes I struggle to remember what I had for lunch the day before… But 10 years?! That’s really a lot of time! Yet, I feel it was really worth the effort.

Introducing JUnit 5 FormattedSource

Wed, 03 May 2023 09:48:06 +0000

Quite some time ago, JUnit’s @CsvAnnotation caught my attention. It turned out so interesting, that I dedicated it a separate blog post and a significant part of a conference talk. It also inspired me to create a new way of writing parameterized tests with JUnit 5.

The JUnit 5 FormattedSource library allows defining test case arguments in a human-readable way, following a user-defined format. As a result, it can be used to improve tests readability. Let’s have a look at an example:

A simple pattern to keep your business logic together

Thu, 30 Mar 2023 07:01:15 +0000

Keeping our domain (business) logic together is usually a really good idea. It not only makes it easier to reason about the most important part of our code but also increases its cohesion. Yet, decoupling the domain code from all the rest (orchestration, persistence, etc.) can be tricky.

In this post, I’d like to share a simple pattern that helps me with that. The amazing Unit Testing Principles, Practices, and Patterns book calls it the CanExecute/Execute pattern.

Squashing DB migrations using Testcontainers

Wed, 01 Feb 2023 08:07:00 +0000

Database migrations are a standard way of dealing with database schema changes, especially in the relational world. No matter which solution we choose (e.g. Flyway or Liquibase in the Java ecosystem), the number of migrations usually grows together with the project itself. An unfortunate side effect is that the test execution time grows as well.

An effective way of speeding up our test execution in such cases is to squash (compact) all the existing migrations into a single file. This allows one to set up everything in one take and avoids performing unnecessary operations like creating and updating a table that has been removed completely later.

Gazing into a crystal ball - my predictions for 2023

Fri, 30 Dec 2022 09:32:58 +0000

The very last days of the old year are probably a good time to think about the next one. Although we already learned how inaccurate any predictions can be, it still feels like an interesting exercise to me. Let’s try to predict the tech future just a little bit… 🔮

I have to warn you, that everything you’ll read here is just a reflection of my own gut feeling. It’s a bunch of guesses based on news, observations, and discussions with my colleagues (👋). It comes with ABSOLUTELY NO WARRANTY, just like a lot of software we’re using every day. Of course, these predictions are also biased by my experience and area of interest, which clearly has a lot to do with Java and JVM.

What happens when you only limit the maximum heap size?

Tue, 15 Nov 2022 06:50:00 +0000

The JVM has spoiled us with its cleverness. It makes so many decisions behind the scenes, that lots of us gave up on looking at what’s inside. Memory-related discussions are probably more likely to appear at a conference or during a job interview than at “real” work. Of course, depending on what you work on.

Java apps are often run in containers these days. Built-in container awareness makes the JVM respect various container-specific limits (e.g. CPU, memory). This means, that even when running an app with a dummy java -jar app.jar (which is usually not the best idea), everything should just work. That’s probably why the only memory-related option provided is often the -Xmx flag (or any of its equivalents). In other words, we tend to only limit the maximum heap size, like this:

JSON, Kafka, and the need for schema

Mon, 11 Jul 2022 05:35:00 +0000

When I started my journey with Apache Kafka, JSON was already everywhere. From Javascript UIs, through API calls, and even databases - it became a lingua franca of data exchange. For many organizations adopting Kafka I worked with, the decision to combine it with JSON was a no-brainer.

Yet, this post is not really about Kafka itself. It’s not another how-to guide either. Using Kafka made me less enthusiastic about JSON and more focused on data evolution aspects. Here, I’d like to share some of my observations with you.

The API should guide you

Wed, 23 Mar 2022 06:15:00 +0000

We create APIs all the time - and I don’t have only libraries and frameworks in mind. Every piece of code that’s intended to be called by another piece of code is an API, in some sense. It’s our job to define an interface, which will be used to achieve whatever is expected.

While discussing various API designs, we often focus on “how it’s gonna look” first. Does it allow fluent calls? Does it rely on annotations? Is the naming accurate? Don’t get me wrong - these are all valid questions. Yet, these “visuals” often distract us from the actual usability.

Java records & compact constructors

Wed, 16 Feb 2022 06:47:00 +0000

Java records should be no longer considered as a “new concept”. Introduced in early 2020 (with version 14) have already been adopted in many projects and organizations. Yet, while we all know that they provide getters, equals, hashCode, and toString for free, there is one feature that still feels a bit unknown. Let’s see how compact constructors can help us write more idiomatic code.

Record construction

Recent versions of Java come with concise syntax for declaring records:

Go-live is a test of flexibility

Tue, 25 Jan 2022 06:59:31 +0000

We want our applications to be maintainable, reliable, resilient, and scalable. All these features seem to share the same idea: being flexible. This flexibility is often manifested in the early design documents close to the buzzwords and technology names. But that’s only the marketing. The true test of flexibility comes with the first go-live. “Production will verify” as my former colleagues used to say.

Flexibility is usually a good thing. It means being able to adapt. Bending without breaking. Flexibility gives us a margin of error when something unexpected happens. Just like it was “made” with production in mind.

Pragmatic tests parallelization with JUnit 5

Wed, 24 Nov 2021 06:12:00 +0000

Running tests sequentially seems to be the current status quo in the Java community, despite the number of CPU cores our computers have these days. On the other hand, executing all of them in parallel may look great on paper, but it’s often easier said than done, especially in the already existing projects.

With version 5.3, the JUnit framework has introduced experimental support for the parallel test execution, which can allow selective test parallelization driven by the code. Instead of an exhaustive overview of this feature (the official User Guide does a great job here), I’d like to propose a pragmatic solution, that should be applicable to many types of projects. You can think of it as a low-hanging fruit of test parallelization.

Parameterize like a pro with JUnit 5 @CsvSource

Tue, 19 Oct 2021 05:32:00 +0000

Parameterized tests are definitely my favorite feature of JUnit 5. Defining multiple sets of arguments for the same test can significantly reduce the amount of the test code. Recent additions to the JUnit 5 enable us to write such tests in a whole different way, improving both readability and expressiveness.

This article won’t be yet another primer/overview (like this great introduction from @nipafx). Instead, I’d like to show some not-so-obvious ways of defining test inputs in an elegant, tabular way with JUnit 5. Probably, the fans of the Spock framework (and its Data Tables) would already have an idea of how it could look like, but it’s a non-goal to compare these two frameworks here.

No need to hate Java default methods

Thu, 05 Aug 2021 05:44:00 +0000

While browsing Twitter a few days ago, I’ve been reminded about a quite controversial topic in the Java community, which (apparently) still is using interface default methods. To be honest, I’ve been a bit skeptical as well when I’ve first seen them coming as a part of Java 8. However, today I’ll write a few words in defense of default methods, as when used carefully, they can turn out to be extremely handy.

SLA is the new CAP

Tue, 20 Jul 2021 06:04:38 +0000

The world has changed quite a lot since 1999 when Eric Brewer formulated his famous conjecture, known as the CAP Theorem today. Back then, the systems were running mostly on a self-hosted and rather expensive infrastructure, often related to the software components in use (due to licensing, etc.). A proper understanding of availability & consistency trade-offs in the presence of network partitions was simply yet another responsibility on the list.

Today, SaaS/PaaS/IaaS products have distracted us from many of those problems, while leaving promises of a carefree life focused on our business instead. After more than 20 years, SLA (Service-Level Agreement) became the new CAP, defining the limits of the distributed systems we are building.

How startup time affects reliability

Tue, 13 Apr 2021 06:27:49 +0000

There seems to be a lot of interest in improving application startup time these days, driven by the discussions on languages and technologies (like Go, Node, or GraalVM), that provide almost instant startup for serverless functions (a.k.a. lambdas) being run in the cloud. However, such a speedup brings benefits to other types of processing as well.

In this post, I’d like to present a different perspective on the topic of application startup time. Instead of focusing on serverless functions, I will show how faster startups can improve the reliability of a more “traditional” distributed system.

You can't afford to run Java 8

Tue, 16 Mar 2021 06:28:56 +0000

Syntactic sugar (like the introduction of var) is often not enough to convince somebody (especially non-developer) to move forward. This is one of the reasons why Java 8, almost 7 years after its first release, is still widely used. However, many things have improved apart from the syntax. When taking all of them into account, it may turn out that you can’t afford to run Java 8 anymore. And no, I don’t mean migrating the code, but simply updating the JVM used as a runtime!

Closing Java Streams with AutoCloseable

Tue, 26 Jan 2021 23:31:40 +0000

What could be kind of surprise even for some experienced Java programmers, the java.util.Stream interface extends java.lang.AutoCloseable. This (in theory) puts it on par with files, DB connections, and other resources requiring manual closing. Should we close all our Streams in the same way as any other resources?

In this post, I’d like to explain which Streams have to be closed and how the closing actually works. We will also go through some of the interesting under-documented properties of this feature.

Single-partition Kafka topics

Mon, 11 Jan 2021 10:14:00 +0000

Apache Kafka has been designed with scalability and high-performance in mind. Thanks to its architecture and unique ordering guarantees (only within the topic’s partition), it is able to easily scale to millions of messages. However, there are some specific situations when using a topic with just one partition (despite being against mentioned features) might be a valid and simple solution to some complex problems of the distributed world.

In this post, I’d like to describe the so-called single-partition topic pattern and to list some valid use cases for it.

Technical interview tips for valuing candidates' time even more

Thu, 10 Dec 2020 06:42:13 +0000

The end of the year is an especially intensive recruitment season for many IT companies & software houses. This does not mean that only HR departments have their hands (and calendars) full. As one of the last steps before offering (or not) a job, a technical interview has to take place. Selected engineers, previously busy with technical stuff, have to now become recruiters, verifying people’s skills and experience. And that’s quite of a challenge!

Isolation issues with Helm umbrella charts

Wed, 25 Nov 2020 07:33:35 +0000

In this post, I’d like to describe the issue I’ve recently encountered when using Helm umbrella charts. Long story short, it turned out that subcharts are not completely isolated from each other, contrary to what we probably would expect. This feature has also some important consequences for building umbrella charts and combining different dependencies into one parent chart, which I want to outline as well.

Umbrella charts basics

Helm umbrella charts are an easy and powerful way of installing multiple components as a single one. They allow us to set up pretty complex configurations like Kafka cluster or Elastic stack with minimal effort - by installing just a single chart (one helm install call).

Introducing Mike my bytes

Tue, 10 Nov 2020 06:40:33 +0000

People are using all their senses for recognition. Just think about how many jingles, slogans, images, or even actor faces unequivocally remind us of something. They are consistently building what we call a brand. It’s not a coincidence by the way - it’s called multisensory marketing.

Software engineering loves consistency too - not only when ACID comes to play, but also in terms of technical content. Interestingly, only some of the tech companies I know managed to build a consistent, nice to look at visual identification or technical brand (surprisingly, the budget often seems not to be a reason for that). I and many of the technical people I know actually care about those things. One could say, the content is more important than its wrapping - sure! However, mediocrity is what we feel right at first look. And in terms of marketing, nobody wants the first impression to be the last one…

DYI security audits - half a year later

Sun, 02 Jun 2019 22:07:54 +0000

At the end of 2018, I had a pleasure to give a talk at Testwarez - the oldest testing-oriented conference organized in Poland. The recording recently appeared on YouTube, so I decided to take this opportunity to figure out what has changed through the past few months in terms of tools that I presented.

The goal of my talk was to present some practices and open source tools for improving the overall security of Java-based projects. Including them as a part of the delivery pipeline (static code analysis, build process, Docker images creation, etc.) sets up a regular and automated “security audits” routine even without a dedicated security team. Please don’t get me wrong - it doesn’t mean that we don’t need pentesters (“security magicians” in general) or external audits anymore. I believe that if some of their work could be done in an automated manner every day then it should make our apps noticeably more secure and reduce the number of vulnerabilities that could be found later on.

What could your luggage tell you about the cryptography?

Sun, 14 Oct 2018 13:36:43 +0000

A typical luggage case padlock with 3 rings and TSA (backdoor) lock on the left

A combination of 3 digits - this is the level of protection offered by the vast majority of luggage cases on the market. 3 digits secret code, that should keep all your personal belongings safe at the aircraft, lobby and hotel room. Lots to expect for just 3 digits…

Project Lombok - beyond DRY

Sun, 27 May 2018 17:49:27 +0000

I have to admit, that when I first saw Project Lombok few years ago it was quite odd to me. The whole “annotation thing” and code pieces appearing “magically” inside the classes made me skeptical. A few years later, I’m now a fan of using Lombok in my Java projects for many reasons. Not all of its users know, that Lombok has more than just reducing the boilerplate code to offer. Let’s take a look at what’s behind its magic and what could you benefit from adding it to your projects. Instead of making a hello world example using features like @Getter, @Setter or @Builder, this post is focused on some more complex concepts behind Lombok.

Build docker images with Jenkins running in docker

Sun, 21 Jan 2018 23:44:30 +0000

Building docker images within the CI pipeline isn’t something new or unusual these days. Normally it’s super easy - you just have to install Docker in your Jenkins CI environment and add jenkins user to the docker group. Problems appear when your Jenkins instance is a docker container itself.

Inception begins

How to make docker available inside your container? Here is a three steps solution:

Install docker in your container.
Expose docker socket (/var/run/docker.sock) to the Jenkins container.
Expose host’s docker executable (/usr/bin/docker) to the container.

At this point, you should already be able to use docker inside Jenkins’ container. Nevertheless, all docker commands executing by Jenkins must start with sudo docker. That requirement has been greatly explained in Post-installation steps for Linux chapter of docker’s docs. If it fits your needs & security restriction you can stop here - but please know, that there is a better solution ;)

SolrCloud on production - the memory

Thu, 17 Aug 2017 23:02:24 +0000

I want to share with you some of my thoughts about using Apache Solr (especially SolrCloud) on production. In one of the projects I’m participating in, we are using it to provide Near-Real-Time (NRT) searching along with frequent updates to the indexes. Here are some tips, that helped our project stand still on production environment against hundreds of simultaneous requests per second.

This post is focused on the memory related aspects of the Solr configuration. Most of the advice presented below apply to other large-heap Java applications as well.

The uncertain future of Keyczar

Mon, 13 Feb 2017 00:39:27 +0000

The cryptographic world changed a lot since 2008 when Google’s Keyczar library showed up. However, one thing is still the same - effective cryptography is really hard to implement. Keyczar library was a quite successful attempt to provide easy to use crypto solutions based on current security standards to Java, Python and C++. Now, after 9 years of its development, the future doesn’t look so bright.

Ain’t no sunshine when it’s old

In the late 2016 Keyczar’s maintainers announced that:

Still using @author for every file? Please don't...

Thu, 29 Dec 2016 08:06:15 +0000

Luke, I am Your Father!

In his first day at the new job, Bob created the following class:

import java.util.Arrays;
import java.util.List;

/**
 * Returns a sum of given numbers.
 * @author Bob
 */
public class NumberSumCalculator {
    public int sum(List<Integer> integers) {
        int sum = 0;
        if (integers != null) {
            for (Integer integer : integers) {
                sum += integer;
            }
        }
        return sum;
    }
}

He was so proud of it, so he put the @author Javadoc tag with his name at the top. Two days later, his friend Eve performed so called “cosmetic cleanup”:

Welcome to HTTPS era with Let’s Encrypt!

Sun, 11 Dec 2016 20:10:51 +0000

As you can already see in the browser’s address bar, my blog (along with other sites on mkowalski.net domain) received HTTPS support. Thanks to Let’s Encrypt everyone can get valid HTTPS certificate for free! Interested? Check out their’s Getting Started Guide. If you are lucky enough your hosting provider may already support Let’s Encrypt automatically. In my case a manual configuration was required. Luckily, it have been documented well by MyDevil team, so the process took me just a few minutes.

How micro should a microservice be?

Thu, 20 Oct 2016 22:47:00 +0000

Two days ago I’ve participated in a JUG meeting in Poznań which special guest was famous Java rock star Adam Bien with his presentation called Microservices in 2016 — What Worked Well. The session was focused on the typical Bien’s stack: JEE microservices & Docker and overlapped with his presentation on Devoxx Poland 2016. But don’t get me wrong - it was totally worth it!

The Bien’s way

One of the most controversial topics during the session was the preffered size and the granularity of microservices. Bien’s approach is to start with a monolith app (single WAR) and split it only when you have a good reason for it (like security requirements). He typically ends up with just a few microservices (eg. about 5), that not always have to encapsulate just one feature. At the same time they should be ‘micro’ in terms of the WAR size and a minimalistic dependecy set - ideally limited only to JEE libs provided by the application server. Probably the most powerful feature of his development model is the speed - he packages and deploys WAR into dockerized application server blazingly fast (seconds!). But are his microservices really ‘micro’?

Docker shared storage file permission problems

Sun, 11 Sep 2016 22:30:16 +0000

Case

Imagine the following scenario: your world-famous web application is hosted with two Docker containers (eg. with application server). Both containers have access to same host’s directories (passed with Docker’s -v parameter) mounted as:

/configuration - containing few configuration files,
/logs - storing log files outside containers.

Arguably, there are lots of better solutions (including databases, log indexing systems etc.) but that’s the issue we need to face now.

The following user accounts are involved:

Make your git commit verbose

Sun, 24 Jul 2016 22:44:29 +0000

Even if committing changes with git is straightforward, sometimes you want to verify all changes before doing it (e.g. to come up with with a nice and meaningfull commit message). Luckily there is --verbose switch for git commit. According to the manual (git commit --help):

-v, --verbose

Show unified diff between the HEAD commit and what would be committed at the bottom of the commit message template to help the user describe the commit by reminding what changes the commit has.

So you think you can skip tests? The "dark side" of Maven

Tue, 31 May 2016 00:19:26 +0000

Tests are the light side of programming. Period. Running test cases is one of the fundamental duty of every build automation system - including Maven. Even if it’s a kind of ritual and the determinant of style, every experienced programmer knows that sometimes things just have to be MacGavyered instantly. But how to fold up a late night app version using only Maven, bottle of ketchup and an old shoelace if our tests just don’t pass?

Solving locale issues with docker containers

Mon, 16 May 2016 22:28:44 +0000

When docker kicked in to the enterprise market many things started changing. Along with microservice-based architectures it became a must-have technology for any “modern” project (the containers idea itself isn’t new - docker has just made things much simplier). In analogy to Java related slogan from 1995 “Write once, run anywhere” almost 20 years later docker enthusiasts say: “Build once, run everywhere”. In fact both ideas can coexist easily and that’s probably one of the reason they really do in practice nowadays. However, there ain’t no such thing as a free lunch…

Apache FOP - center table cell vertically

Wed, 06 Apr 2016 21:22:38 +0000

Nowadays we can argue if using Apache FOP is still the best solution for generating PDF documents. One of it’s biggest competitors is probably JasperReports Library which supports multiple file formats and does not require creating XML templates manually from scratch (thanks to Jaspersoft Studio).

However, sometimes you just have to face the FOP’s XML monster :)

The FOP’s way of styling elements (text blocks, tables etc.) is almost identical to the CSS. But what if you want table cell content centered vertically? Probably you will try with something like (CSS way):

Checkout specific Git branch or tag using its name only

Tue, 19 Jan 2016 23:49:20 +0000

For some compatibility reasons I needed to checkout specific branch or tag in the Git repository using only it’s name (last part without refs/.../ prefix) from a bash script.

For Mercurial repositories it’s not a problem at all thanks to:

hg checkout $tagOrBranch

I haven’t found similar solution using git checkout, so as a workaround I’ve prepared the following bash script to do the job:

git fetch --all
if git show-ref | grep "refs/remotes/origin/$tagOrBranch"
then
    echo "It looks like a branch"
    git checkout -b $tagOrBranch
    git pull origin $tagOrBranch
else
    if git show-ref --tags | grep "refs/tags/$tagOrBranch\$"
    then
        echo "It looks like a tag"
        git checkout tags/$branchOrTag
    else
        echo "No branch / tag '$branchOrTag' found"
        exit 1
    fi
fi

Hello world!

Sat, 19 Dec 2015 22:50:31 +0000

This post couldn’t have started different - since I’m calling myself a developer.

Why Yet Another Developer Blog? It’s always good to write down things before forgetting them - isn’t it a perfect excuse? Probably there is also another motivation…

If you can’t explain it simply, you don’t understand it well enough.

Albert Einstein