The Wombelix Post - Java

Modernizing jDeepL: Java 11 to 17 and Automated Releases

2025-08-02T00:00:00+02:00

I had some time last night - the neighbors were having a party and I couldn't sleep - so I decided to tackle a task that's been sitting in my backlog for way too long: modernizing jDeepL, my unofficial DeepL translation app for Linux.

For those who don't know jDeepL, it's a simple JavaFX desktop application that lets you translate text using the DeepL API. Nothing fancy, just a basic GUI with source and target text areas, language selection, and the CTRL+C+C keyboard shortcut for quick translations. I built it because I wanted something native on Linux instead of using the web interface all the time.

The main problem was that the project was stuck on older dependencies and had practically non-existent documentation. This became obvious when people opened and commented GitHub issue #1 back in March 2023. Around that time jDeepL was also mentioned in a Golem.de Article and I received a couple of Emails. All pointing out that there wasn't much instruction on how to build it and that they ran into compatibility issues with newer Java versions. The project was using Java 11, JavaFX 11, and a bunch of outdated libraries that caused build failures for anyone trying to compile from source.

So last night I finally decided to modernize the whole thing a bit. The work took me a few hours of checking new versions, reading changelogs, and validating that updates wouldn't break anything. I bumped Java from 11 to 17 and updated all dependencies to their latest stable releases. So, same libraries I was already using, but brought up to current versions.

The most interesting challenge was fixing the FXTrayIcon dependency. It had a deprecated constructor that I was using, so I had to dig into the library's source code to understand what the deprecated builder actually did and how to achieve the same result with non-deprecated methods. The old approach let you define image scaling directly in the constructor. The new way requires a two-step approach: use the builder pattern, then call the image scaling method on the returned object. Small change, but it took some detective work to figure out the right replacement.

The documentation also needed some love. The README was more or less just a description of what the app does, with not much information about how to actually build or run it. I added a Quick Start section and expanded the Build section with Maven setup instructions. More importantly, I set up automated releases using GitHub Actions.

This is actually a huge step forward compared to how I handled releases before. Back in version 0.7.4, I was manually uploading pre-built JARs to my personal Nextcloud instance. This worked fine and was documented in the README, but wasn't exactly convenient. Now when I push a tag, the GitHub Actions workflow automatically builds the JAR and creates a GitHub release with the file attached. Users can just go to the GitHub releases page and download binaries instead of having to build from source.

One thing I discovered during this modernization is that jnativehook, the library I use for the global CTRL+C+C hotkey, is likely on its way to becoming unmaintained. It only works with X11 sessions, and with bleeding-edge distros pushing toward Wayland, I might need to find a different approach for hotkey handling in a few years. But that's a problem for future me.

The project now builds with Java 17, uses updated dependencies, has expanded documentation, and automated releases. The original issue about build problems should be resolved now. Users can either download pre-built JARs from GitHub releases or follow the updated build instructions to compile from the source code.

It wasn't groundbreaking work, overall just maintenance that was overdue. But sometimes that's what projects need, a bit of attention to keep them current and usable.

Next, I'm thinking about creating OS-specific packages using jpackage. This would let me provide .deb and .rpm packages that ship with all dependencies. This would make the usage even easier compared to the current JAR file approach.

jDeepL version 0.7.4 released, pre-build binaries available

2023-11-01T00:00:00+01:00

It's been a while since I announced and released the first version of jDeepL - Unofficial DeepL App for Linux based on JavaFX. Since then it was mentioned on a couple of news sites and people reached out to me. Mostly with pointing out that there are not much instructions how to build it. And that I don't offer pre-build binaries that people can directly run.

That was good and valid feedback. I was focused on sharing it with the world. I didn't take into account that non-tech people are the actual users.

As part of the recent Git repos moved to Sourcehut, with mirrors on Codeberg, GitLab and GitHub activities, I allocated a bit of time to tackle some of the addressed issues. The README should now be a bit clearer. I updated some dependencies, improved the release scripts and published v0.7.4.

For the future I plan a CI integration that takes care about publishing new versions. Until then, I uploaded the pre-build version to my personal Nextcloud instance: https://hub.xlii.cc/s/an7E9E9bgFBpRG3

Latest version: v0.7.4 (SHA256 checksum: 206c13ec820451096bdf07f29e336c6827c750db11554d9dcc68812c8b56c796)

It's nice to see that some people find useful what I created.

Second attempt to pass the Oracle 1Z0-819 Java SE 11 Developer Exam

2022-08-31T00:00:00+02:00

I wrote about my first attempt last Year and gave it a another try today, after preparing a lot throughout the last weeks, but not as much as I actually planned to. I made the decision in February and wanted to prepare 4 till 6 months on a daily basis.

That sounded comfortable to work through the whole Study Guide and get enough practice. But then life happened, things didn't worked out as planned and got delayed, so my training schedule for the OCP 11 went down to just a few weeks with ~2 till 3 hours a day.

My Score was 63%, which means 5% below the passing Score of 68%, so unfortunately the second attempt failed as well, but I scored 8% higher as last time.

I have to admit, first I was a little disappointed but then I realized how much I learned and improved my Java Skills since last year in areas like:

JDBC API, Interfaces, Functional Interfaces, Sub- and Super-Classes, Abstract Classes, NIO2 File API, Streams, Collections, Comparator and Comparable Interfaces, Variable Scopes, Encapsulation

So my main goal, to getting better in Java, was actually achieved, even though without some icing on the cake by passing the Exam ;)

Based on the pure numbers, it doesn't seem like a huge step, but taking into account the massive amount of Exam Objectives and the mostly very complex Questions, I count it as huge step forward, especially under the circumstances that I'm not a full time Developer, it's one of my passions but just a small portion of my day-to-day job.

I started programming more than 20 years ago, classic with HTML, CSS and PHP4. Throughout the years I also got experience in Java and Python, I also played around with JavaScript and Golang, learned much about tools around development in general and the ecosystem of those languages. I'm able to understand Code and troubleshoot issues independent of the language, also implement fixes and modifications. I just get things done.

But I have the feeling that I never made it beyond mid-level Skills when it comes to pure Software Development. Also I never learned a programming language A to Z, always just what I needed, when I needed it. That's probably also one of the reasons why I jumped so deep into Java now, I wanted to learn some fundamental concepts in detail instead just scratching the surface.

In my opinion the best way to prepare for the Exam are the Mock Tests from enthuWare and the Java OCP 11 Developer Complete Study Guide, which I mentioned already last year but actually used myself this time. It's a massive Guide and at the beginning it feels overwhelming, but it's worth it to work through it.

Besides that I started using Hyperskill (Referral Link) a few months ago. If you already completed Java Programming - Mooc.fi, that could be a good next step to learn more but also stay motivated by working regularly at some of the projects. For sure you can do the same on your own, but I found it useful that I can just pick a Project and work on it instead making something up on my own. Hyperskill also provides guidance and hints, but leaves the actual implementation fully up to you, so it's about real programming and not blindely following a guide or ending up in the tutorial hell.

Most likely I will not try again to become a Oracle Certified Professional Java Developer very soon, getting certified would've been nice, but I have other things to focus on within the next months and even without passing the Exam, it was a valuable experience and I can definitely use knowledge I gained during the Preparation.

jDeepL - Unofficial DeepL App for Linux based on JavaFX

2022-05-30T00:00:00+02:00

I'm a daily DeepL User, the Windows App is convenient but nothing comparable was available for Linux, so I build my own.

jDeepL is a very simple GUI Application based on JavaFX, developed and tested on openSUSE Tumbleweed with KDE Plasma.

You can find the GPL v3 licensed Source Code here: https://dominik.wombacher.cc/~git/jDeepL/

It's in an early stage but covers the most important functionality: Translating the marked text by pressing CTRL + C + C.

At least that's for me the most important one from the official Windows App ;)

I will probably improve it further within the next time, feel free to Contribute.

Further details can be found in the README: https://dominik.wombacher.cc/~git/jDeepL/

Setup Uyuni Development Environment with focus on Java and IntelliJ

2022-03-09T00:00:00+01:00

Hacking Uyuni, either to troubleshoot and fix bugs or to contribute new features / improvements is something I do since quite a while already, at least whenever I find some time. Getting started wasn't that easy, there are a lot of resources available but sometimes there are outdated, too focused on SUSE employees instead community contributors or just didn't fully answered my questions.

So I want to share my experiences to Setup a Development Environment for Uyuni, with focus on the Java Codebase, on a openSUSE Tumbleweed System by using sumaform and IntelliJ IDEA.

Resources
sumaform
Install Packages
Clone git repo and prepare files / folders
Configure IntelliJ IDEA
Deploying Java code or CSS
Contribute

Resources

You can find a lot of information in the Uyuni Wiki and a great Presentation (Archive, Source) from Cédric Bosdonnat.

sumaform

See my Post Uyuni Test Environment with sumaform on local libvirt host (openSUSE Tumbleweed)

There are Alternative Instructions (Archive: [1], [2]) available in case using sumaform isn't possible or not intended.

Install Packages

Add the systemsmanagement:Uyuni:Utils repository, especially for obs-to-maven, and install the necessary packages.

Manually:

sudo zypper addrepo obs://systemsmanagement:Uyuni:Utils systemsmanagement:uyuni:utils
sudo zypper in java-11-openjdk-devel openssh rsync apache-ivy ant ant-junit servletapi5 cpio obs-to-maven tito yarn

Ansible snippet:

- name: Import systemsmanagement:/Uyuni:/Utils RPM Key
  rpm_key:
    key: https://download.opensuse.org/repositories/systemsmanagement:/Uyuni:/Utils/openSUSE_Tumbleweed/repodata/repomd.xml.key
    state: present

- name: Add systemsmanagement:/Uyuni:/Utils RPM Repository
  community.general.zypper_repository:
    name: systemsmanagement_uyuni_utils
    description: Several utilities to develop, build or release Uyuni (openSUSE_Tumbleweed)
    repo: https://download.opensuse.org/repositories/systemsmanagement:/Uyuni:/Utils/openSUSE_Tumbleweed/
    priority: 95
    state: present
  ignore_errors: true

- name: Package Installation (Uyuni Development)
  community.general.zypper:
    name:
      - java-11-openjdk-devel
      - openssh
      - rsync
      - apache-ivy
      - ant
      - ant-junit
      - servletapi5
      - obs-to-maven
      - tito
      - yarn
    allow_vendor_change: true
    force_resolution: true
    force: true
    state: latest

Clone git repo and prepare files / folders

Fork the Uyuni Repository and clone it. I will use the placeholder <path_to_uyuni> a lot, which refers to the local path of your cloned uyuni fork.

Let's start with some files and folders which are required at a later point for unittest and deployment.

Create the folders /usr/share/rhn/config-defaults, /var/log/rhn and /srv/susemanager, owner and group should match with your user account.

Ansible snippet:

- name: Create Folders for Uyuni Development Unittests and Build
  file:
    path: "{{ item }}"
    state: directory
    owner: wombelix
    group: users
  loop:
    - /usr/share/rhn/config-defaults
    - /var/log/rhn
    - /srv/susemanager

Create a rhn.conf used by JUnit:

cp <path_to_uyuni_root>/java/buildconf/test/rhn.conf.postgresql-example <path_to_uyuni_root>/java/buildconf/test/rhn.conf

Get / update java libraries and dependencies:

cd <path_to_uyuni_root>/java
ant -f manager-build.xml ivy

Compile branding jar for the first time:

cd <path_to_uyuni_root>/java
ant -f manager-build.xml refresh-branding-jar

Configure IntelliJ IDEA

I will focus on IntelliJ IDEA but can also use Eclipse (Archive: [1], [2]) or VSCode (Archive: [1], [2]), if you want.

The following Steps are heavily based on IntelliJ IDEA specific development instructions (Archive: [1], [2]) and Java Development Environment (Archive: [1], [2]) with some adjustments, additional information and tested on IntelliJ IDEA Ultimate 2022.1 EAP.

The JetBrain Toolbox is in my opinion the easiest way to install and update IntelliJ. If you installed it manually, please check the documentation where / how you can configure the vmoptions.

Toolbox App > three dots next to "IntelliJ IDEA" > Settings > Configuration > Java Virtual Machine options "Edit..."

Replace -Xmx2048m with -Xmx4G

Source: https://intellij-support.jetbrains.com (Archive: [1], [2])

Afterwards start IntelliJ IDEA to proceed with the actual configuration.

File > New > Project from existing Source

Select <path_to_uyuni_root>

Create Project from existing Source

Accept the project format defaults

Also accept auto discovered source directories

From the Libraries list, uncheck all items

From the Modules list, only check the items corresponding to the following directories:

uyuni/java/code (change the name to code)

uyuni/branding/java/code (change the name to branding)

Select a Java 11 runtime e.g. the previously installed openJDK

Ultimate Edition: Unselect eventually found frameworks

Enable automatic building

File > Settings... > Build, Execution, Deployment > Compiler and select "Build project automatically"

Configure Code Style

File > Settings... > Editor > Code Style > Java > Imports

Click on the cog / settings icon next to the "Scheme: Default" field at the top, then "Import Scheme", "IntelliJ IDEA code style XML" and select the <path_to_uyuni_root>/java/conf/intellij-codestyle.xml file.

Remote Debugging

Run > Edit Configurations... > + sign

Accept all defaults, except from Host and Port, configure them based on the service you want to debug.

8000 for Tomcat, 8001 for Taskomatic, 8002 for Search (defaults if deployed with sumaform)

Further reading: IntelliJ IDEA Debugging Guide (Archive: [1], [2])

Ivy integration

File > Settings... > Plugins > Browse repositories... > search for "IvyIDEA" > Install the Ivy plugin

Restart IntelliJ IDEA (if asked) to activate the plugin

File > Project Structure... > Modules -> right click on code > + sign > click on "ivyIDEA" to enable the plugin for the project

Click on folder icon at the right side to select the Ivy configuration path: <path_to_uyuni_root>/java/buildconf/ivy/ivy-suse.xml

Check "Use module specific ivy settings"

Click on folder icon at the right side to select the Ivy configuration path: <path_to_uyuni_root>/java/buildconf/ivy/ivyconf.xml

Tools > IvyIDEA > "Resolve for all modules" to get updated Ivy dependencies

Note: When switching branches that have different dependencies (notably, major versions) you have to:

Tools > IvyIDEA > Remove all resolved libraries

Tools > IvyIDEA > Resolve for all modules

Build > Rebuild project

CheckStyle integration

File > Settings... > Plugins > Browse repositories... > search for "CheckStyle" -> Install the CheckStyle IDEA plugin

Restart IntelliJ IDEA to activate the plugin

File > Settings... > Tools > Checkstyle

Change the Checkstyle version to the one in <path_to_uyuni_root>/java/buildconf/ivy/ivy-suse.xml (currently 8.30)

Click on the + sign next to Configuration File

Description: Uyuni

Check "Use a local Checkstyle file", select <path_to_uyuni_root>/java/buildconf/checkstyle.xml

Check "Store relative to project location", click on Next

Set the following values for properties:
checkstyle.cache.file: <path_to_uyuni_root>/java/build/checkstyle.cache.src
checkstyle.header.file: <path_to_uyuni_root>/java/buildconf/LICENSE.txt
checkstyle.suppressions.file: <path_to_uyuni_root>/java/buildconf/checkstyle-suppressions.xml
javadoc.lazy: false
javadoc.method.scope: public
javadoc.type.scope: package
javadoc.var.scope: package
Click on Finish, mark the file as Active, click on Apply and leave the Settings.

Afterwards a new mini-tab will appear at the bottom named "CheckStyle".

Avoid CheckStyle violations

These are recommended settings, which might already be set as default, that help respecting style guidelines independent of the CheckStyle plugin:

enabling automatic import completion

File > Settings... > Editor > General > Auto Import

Set "Insert imports on paste" to "Always"

Select "Add unambiguous imports on the fly" and "Optimize imports on the fly" in the Java Section.

disabling "star imports"

File > Settings... > Editor > Code Style > Java > Imports

Class count to use import with '*' > 999

Names count to use static import with '*' > 999

wrapping and braces

File > Settings... > Editor > Code Style > Java > Wrapping and Braces

Under 'try' statement check 'catch' on new line and 'finally' on new line

Under 'if' statement check 'else' on new line

Faster deployments via manager-build.xml

Change the output directory to enable quick manager-build.xml deploys:

File -> Project Structure... -> Modules -> code -> Paths

Click on "Use module compile output path" and set:

"Output path" to <path_to_uyuni_root>/java/build/classes

"Test output path" to <path_to_uyuni_root>/java/build/tests

Enable usage of precompiled files by adding precompiled=true to <path_to_uyuni_root>/java/buildconf/manager-developer-build.properties, if the file not exist, copy <path_to_uyuni_root>/java/buildconf/manager-developer-build.properties.example, rename and edit the new file.

Configure JUnit tests

File > Project Structure... > Modules > code > Dependencies

Click the + sign > Module dependency > branding > OK to include branding classes and files in the build

File > Project Structure... -> Modules -> code

Mark the directory webapp as Resources

Run > Edit Configurations... > + sign > JUnit

Name: JUnit

Run on: Local machine

Build and run:
JRE: Java 11
-cp: -cp code
-ea: -ea -Drhn.config.dir=$MODULE_DIR$/../buildconf/test/ -Dlog4j.threshold=debug
Select "All in package" to execute all available Unittests, if you want to limit to a specific class or package adjust the dropdown and filepath accordingly

To start the JUnit tests, click on Run > Run.

Important: Start the test database docker container first, otherwise almost all tests will just fail

cd <path_to_uyuni_root>/java
make -f Makefile.docker dockerrun_pg

Deploying Java code or CSS

If you created a terraform based VM with sumaform, you can easily deploy code:

Run checkstyle

cd <path_to_uyuni_root>/java
ant -f manager-build.xml checkstyle

Deploy

cd <path_to_uyuni_root>/java
ant -f manager-build.xml refresh-branding-jar deploy -Ddeploy.host=uyuni-server.tf.local restart-tomcat restart-taskomatic

You can configure the deploy.host in <path_to_uyuni_root>/java/buildconf/manager-developer-build.properties and omit the command line parameter.

Contribute

Uyuni exist since July 2018, the initial release (4.0.0) was based on SUSE Manager 3.2, since then Uyuni is the Upstream Project of SUSE Manager. SUSE Manager is based on Spacewalk, which was sponsored by Red Hat and abandoned, so SUSE decided to start a own Fork (Archive: [1], [2]), Uyuni was born.

Still a lot of development comes from SUSE but there is a growing Community (Archive: [1], [2]) with more and more independent Contributions.

If your dev environment is ready and you want to jump in, but didn't contributed to the Uyuni Project before, I suggest you take a look at some Good first Issues.

Create BMC Control-M usage reports from CLI instead GUI

2021-08-21T00:00:00+02:00

I had to solve a quite interesting problem recently, the Task was to generate Control-M usage reports on a monthly basis and send them via E-Mail.

Control-M provides a Solution for that: BMC Control-M Usage Reporting Tool

But it's a Java GUI Application that can't be automated or run in Batch mode. So I decided to write a small "wrapper" in Java which re-use the original Classes from the Control-M Usage Reporting Tool (Version 9.0.00).

That way the results are 100% identical without any (unsupported) customizing but it can be executed from the command line.

I want to make clear: All Control-M Copyrights belong to BMC, including the Java Code and Classes. All what my little wrapper does, is loading the Class which comes with the original Tool and call the same methods as it would be done in the GUI to generate the report.

Therefore I want to share the Code of my wrapper and the necessary cmd file (yes, all this is only running on Windows due to hardcoded backslashes in file paths in the used Class) to start it.

Downloading the required Jar file from BMC, Building the Project (I used "Export: Runnable JAR file" in Eclipse), adding the necessary data/env.txt and data/config.ini is up to you. I suggest you take a look into the directory structure and files of the BMC Control-M Usage Reporting Tool, it isn't that hard figure it out and get it working :)

ctmusagereport

package ctmusagereport;
import java.io.File;
import com.bmc.ctmem.usagetool.Enhancement.ZipFiles;
import com.bmc.ctmem.usagetool.dbaccess.AddOnsReport;
import com.bmc.ctmem.usagetool.dbaccess.DBAccess;
import com.bmc.ctmem.usagetool.dbaccess.DBAccessManager;
import com.bmc.ctmem.usagetool.dbaccess.EndpointReport;
import com.bmc.ctmem.usagetool.dbaccess.JobCountReport;
import com.bmc.ctmem.usagetool.dbaccess.Params;
public class Main {
    public static void main(String[] args) {
        // Used to Load Env and Config File also to Generate and Get Report Directory
        Params par = Params.instance();
        try {
            par.LoadEMEnvironmentsFromFile();
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            par.LoadConfigParamFromFile();
        } catch (Exception e) {
            e.printStackTrace();
        }

        // Initiates DB Connection based on values in data/env.txt
        DBAccessManager dbam = DBAccessManager.instance();
        dbam.RefreshDBAccessManager();

        // Get DB Connection for Environment 0 (first line in env file)
        DBAccess con = dbam.GetDBAccess(0);
        con.GetEMVersionFromDB();

        // Creates new Directory in reports/ with datetime now ("yyyy-MM-dd-HHmmss")
        par.CreateReportDir();

        // Trigger Generation of all Reports identical to GUI (Wizard / FlowManager)
        new JobCountReport(par.GetReportDirName());
        new AddOnsReport(par.GetReportDirName());
        new EndpointReport(par.GetReportDirName(), true);

        // For easier handling, add all generated files to "reports.zip" in Generated Report Directory
        File[] fileReportsDir = new File(par.GetReportDirName()).listFiles();
        ZipFiles.Zip(fileReportsDir, par.GetReportDirName());
    }
}

ctmusagereport.cmd

java -cp "./*;ctmusagereport_lib/*" ctmusagereport.Main

I tested it successfully with "OpenJDK11U-jdk_x64_windows_hotspot_11.0.12_7" from https://adoptium.net/ on Windows Server 2016.

What I like about working with Control-M is that you can Script and Customize almost everything somehow, even worse that I had to find a workaround like that for the usage reporting, would be great if BMC would offer such an CLI option with the original Tool.

How I prepared and failed the 1Z0-819 Java SE 11 Developer Exam

2021-04-20T00:00:00+02:00

Yesterday I took the 1Z0-819 Exam and failed with a Score of 55% (Passing Score: 68%), but I'm not sad or disappointed, I wasn't just ready yet.

I learned a lot during my preparation and it was one of the toughest Exams I ever tried, so it's not a big deal to fail on the first attempt.

But why did I actually tried it? I learned some Java Basics many Years ago but never used it much. Also my IT Career isn't fully focused on Development, even though that's something I personally enjoy most.

One of my colleagues told me about the 25th anniversary offer from Oracle, were you could get Access to a Java SE Developer OCP Online Training and attend the Exam for 25$. I always wanted to improve my Java Skills, so I thought that would be a great opportunity. But due to the timely limited offer, I just had roughly 4 weeks before I had to take the Exam.

Spoiler: A few weeks, even if you spend many hours every day, are not enough to get from zero to hero in Java and to pass 1Z0-819 ;)

The included Online Training from Oracle wasn't that bad, but wasn't that good either. There were some Hands On Labs but the Guide wasn't provided, so you could only watch the Solution Videos, not perfect but to be fair, it was more or less for free.

I checked out learnjava on reddit and they mentioned https://java-programming.mooc.fi what seem to be very popular learning resource. The University of Helsinki provides two Java Courses, most of the content in written form, with a customized NetBeans IDE Version that includes the Test my Content Plugin.

The cool thing is, you just create an mooc.fi Account, Download the IDE and Login. Afterwards you can work through the Exercises, test them locally and upload them. If your Code is correct and pass all Tests, the Exercise will marked as completed in the Online Course.

Actually that was one of my best learning experiences ever, because you have to solve the exercises on your own but due to the integrated testing, you can always check if you do the things right. During my Exam prep, mooc.fi was the most helpful resource.

In addition the Mock Exams provided by enthuWare were quite nice and very cheap. And before you get confused, it's not about Braindumps, Mock Exams are something different.

During the Exam you have to read and interpret a lot of Code and then choose the right answer(s). So you have to fully understand the Topics and can't just learn Questions and Answers. The Mock Exams can help you to get a feeling how the style of the real exam will be.

For me enthuWare was a good addition to the other resources, also I think it was sometimes harder than the real Exam.

If you prefer learning from a Book, I suggest you take a look at Java OCP 11 Developer Complete Study Guide, it's still usable for the 1Z0-819 Exam. I didn't used it myself, but lot of People recommend it, so I will give it a try next time :)

I definitely plan to give it a second shot end of this Year and overall spent more time programming Java. I'm still very interested in Contributing to the Uyuni Project, were lot of the Codebase is Java, so that might be part my Exam Prep too.