BOM generation of all submodules in Gradle.

When you create a common use library, which consists of many sub modules (artifacts), you probably would like to generate a Maven BOM (Bill of Material) file, so that you can avoid version declaration duplication.

Doing it in Maven is quite straightforward, but in Gradle (as of today) it is not well documented and many Gradle based complex projects lack BOM file.

Fortunately Spring IO Dependency Management plugin helps us with doing that.

Let’s start with a simple Gradle based project with two submodules (client and server):

First you need to apply maven-publish and io.spring.dependency-management plugins. The first one will be responsible for BOM generation and the latter one will add a `dependencyManagement` DSL to define versions of your modules.

plugins {
    id 'maven-publish'
    id 'io.spring.dependency-management' version '1.0.5.RELEASE'

To simplify project configuration, all projects have following configuration:

allprojects {
    repositories {
    apply plugin: 'java'
    group 'pl.greenpath'
    version '1.0-SNAPSHOT'
    sourceCompatibility = 1.8
    dependencies {
        testCompile group: 'junit', name: 'junit', version: '4.12'

Then you need to declare versions of modules in dependencyMangement section. We will add all gradle modules (subprojects) so that we are not forced to manually add each new module.

dependencyManagement {
    dependencies {
        rootProject.subprojects.each {
            dependency(group:, name:, version: it.version)

Then, all we need to do is to declare maven BOM generation using maven-publish plugin’s DSL. We need to define `mavenBom` empty publication (without additional artifacts defined).

publishing {
    publications {
        mavenBom(MavenPublication) {

Now, everything is done and we can test it:

./gradlew publishToMavenLocal

In effect we have following BOM artifact generated:


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="" xsi:schemaLocation="" xmlns:xsi="">

I hope this going to help you create useful BOM files. Having BOM’s it is easier to keep track of project’s dependencies and to enforce consistent versioning across applications you create.

How to install Kernel 4.17 on Ubuntu 18.04

Recently Kernel 4.17 has been released. It has a major power consumption improvement so I decided to check it out now, before it is officially supported in Ubuntu 18.04.

There is a nice tool to do the upgrade on Ubuntu, it is called ukuu.

To install it just type:

$ sudo add-apt-repository ppa:teejee2008/ppa
$ sudo apt install ukuu

Then you are ready to go.

Ukuu has a nice graphical interface

All you need to do is choose the right version (4.17.2 in my case) and install it.

After reboot you should see the new kernel.

You can check it by typing

$ uname -r

The kernel seems to be very stable. I didn’t see any problems since the upgrade.

Have fun!.

Spring Framework – file upload using ConversionService

Sometimes, when creating web application, we want to enable user to upload files to a server.

The uploaded file can be an image, document or any other regular file.
Developing our application using Spring should be relatively simple, so we need simple method for uploading files using this beautiful framework :-).

In our example I’ll use a Company entity, which among the others will contain an Image object with Data of the image and its name.

My Company entity looks like this:

public class Company {
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long id;
	@ManyToOne(cascade = CascadeType.ALL)
	private Address address;
	private String name;
	@OneToOne(cascade = CascadeType.ALL)
	private Image image;
... accessors ommitted

As you can see I need company Address, Name and the Image.
In this example image is identified by name and data (content of image file), but you can do whatever you want with uploaded data, during conversion process.

On Spring Framework’s  documentation sites we can see a usage of custom editor support to convert file uploaded using HTML form into regular Java object.

I went in a different way and used ConversionService to easily convert file from HTTP POST request, which is more comfortable for me.
If you want to use ConversionService you’ll need to create a converter, which implements org.springframework.core.convert.converter.Converter interface.

Let’s create converter then:

import org.springframework.core.convert.converter.Converter;
import org.springframework.web.multipart.MultipartFile;
public class MultipartFileToImageConverter implements Converter<MultipartFile, Image> {
	public Image convert(final MultipartFile source) {
		final Image image = new Image();
		return image;

We need to register our converter in conversion service, so in application context we add:

<bean id="conversionService" class="">
	<property name="converters">
			<bean class="pl.greenpath.converter.MultipartFileToImageConverter">

I use annotation-based configuration of controllers, so configuration of controller is pretty straightforward:

        CompanyService _companyService;
	@RequestMapping(value = "", method = RequestMethod.POST)
	public String doEdit(@Valid final Company company, final Errors errors) {
		if (errors.hasErrors()) {
			return "admin/companies/edit";
		} else {;
			return "redirect:/admin/companies/" + company.getId();

Going this way we have company object with filled data from HTML form.
To obtain image data we just need to invoke e.g. company.getImage().getName();

The main advantage of this solution is its simplicity. You don’t need to create configuration of editors in your controller. All you need is to create a converter and register it in ConversionService. Spring will do all other stuff for you.

I hope it will help simplifying your web app 😉

To-Read sites 4.0

I’ve just uploaded new version of To-Read sites extension into Opera Extensions portal.

By now extension is awaiting moderation and it should be available after 1st of January.


New version brings:

1. Sites synchronization which enables you share sites between many browsers.

I used Opera Link JS Api (thanks  Joel) to synchronize sites so all you need is My Opera account.


2. Turkish translation (thanks to Samet from


All we need is to wait for moderation to be complete 🙂

Find To-Read sites on Opera Extensions portal.




To-Read Sites v.3 – introducing export/import feature.

I’ve just updated To-Read Sites to 3.0 version.

The new release brings export and import feature. Now you can easily save your sites to a file and move it to another Opera instance.

To use the new feature right-click on To-Read Sites extension button and go to “preferences”.

To-Read Sites preferences window.

You can download the new version here:

Enjoy 🙂

How to create multilingual Opera Extension

Opera supports multilingual extensions and creating such one is quite easy. Let’s start with config.xml file

<?xml version='1.0' encoding='utf-8'?>
<widget xmlns="" id="extensions:to-read-sites" version="2.1-3">
	<name>To-Read sites</name>
	<description xml:lang="en">Temporary list of sites you want to 	visit later.</description>
	<description xml:lang="pl">Poręczna lista stron, które chcesz odwiedzić później.</description>
	<description xml:lang="ru">Список сайтов, которые вы хотите посетить позже.</description>
	<icon src="icon.png"/>
	<icon src="icon_16.png" width="16" height="16"/>
	<author href="">Michał Borek</author>
	<access origin="*" subdomains="true"/>

To translate config.xml values you need to add xml:lang attribute into particular nodes. You can apply this attribute into nodes as follows:

  • name
  • description
  • license

You can also define text flow direction by defining dir attribute, the same way as the one above:

  • ltr – left to right
  • rtl – right to left
  • lro – left to right override
  • rlo – right to left override

Another thing we must deal with is translating extension itself. Fortunately Opera provides locales folder for all files connected to translations.

Extension folder structure of extension.

All files that need to be translated should be put in specific subfolder in locales folder (pl for Polish, ru for Russian and en for English in our case). When you create a file in one of locales’ subfolder it will be automatically for specific language. Example:

<link rel="stylesheet" href="styles/style-translation.css"/>

Opera will try to find such file in one of locales’ folder and if there is no such file, the default one will be loaded (from root folder). For English it would be:  locales/en/styles/style-translation.css. To translate buttons’ labels you can use CSS content attribute as follows:

#addButton {
	content: "Add current";

To change another values (like anchor titles, error messages and so on) you can create translations files. I used popup.js to achieve this goal:

var tr = {
	addButtonLabel: "Add current page to list",
	deleteButtonLabel: "Delete site from the list",
	lockButtonLabel: "Lock site"

All you need is to use tr.* values instead of literal strings in your extension. I hope this article will simplify your Opera Extension development process. If you have any suggestions or questions, feel free to post a comment.

To-Read sites – minor update

I’ve just updated To-Read sites Opera extension removing an annoying bug (site is not being deleted from list) and making visual improvements:

  • I changed badge color, because it was annoying for some of you.
  • Sites list haven’t been centered (it looked odd) – it looks fine now.

To-Read sites 2.1-2

New version will be available on shortly.

Many of this extension users asked me about syncing – it’s in plans. But I really have no time to do it now, but I hope I will finish that soon, please be patient :-).

OMeasure! 2.0 – available soon

I’ve just uploaded new version of OMeasure! plugin.

New version brings possibility to resize measuring area and few visual improvements.

I’ve changed HTML5 Canvas drawing used in v.1.0 to DOM based one and it’s easier to make detailed result.

OMeasure! 2.0 in action

New version should be available shortly via Opera Addons page.

OMeasure! – my new Opera Extension

Starting from this post I’m switching to English.

Yesterday Opera published my second extension – OMeasure!

OMeasure! is a simple tool for web developers which simplifies measuring of elements of web sites.

You can download OMeasure! here:

Known bugs:

Doesn’t work on https sites.

Opera Extensions – moje pierwsze rozszerzenie

Od wersji 11.0 Opera zacznie wspierać rozszerzenia (tzw. extensiony).
Dziś stworzyłem pierwsze rozszerzenie do Opery, które pozwala na dodawanie stron “do przeczytania później”.

Opera 11.0 zawiera jednak drobny błąd, więc funkcjonalność jest chwilowo ograniczona (opisane jest to poniżej).

Aby ominąć błąd należy przełączyć karty (dowolne 2 karty). Po zainstalowaniu wtyczki, najlepiej zresetować przeglądarkę (wyłączając też wszystkie karty).

Rozszerzenie tymczasowo można ściągnąć tutaj:  to-read-sites.1.0.oex