5 Gradle plugins for working with modular Java projects

Java 9 was release in September 2017 and with it came a brand new modular platform known as JPMS, delivered by Project Jigsaw. Building projects that an leverage this new feature can be a bit daunting however the Gradle plugins in the following list can help you in keeping things under control. 1. JDeps – https://github.com/aalmiray/jdeps-gradle-plugin This plugin generates a report of your production code and compile/runtime dependencies using the jdeps tool available since Java 8. Jdeps can tell you if your codebase is vulnerable to API changes such as relying on internal APIs (like sun.misc.Unsafe) even if you don’t Read More


The Gradle SuperPOM

Following up with the Gradle POM, where a familiar structure found in Maven projects can be brought to Gradle projects, I’d like to discuss another Maven feature that many see as an advantage and that’s lacking in Gradle: the ability to enforce settings in a top-down fashion with hierarchical POM files. In Maven, a parent POM delivers configuration that will be used by a child POM as is. Children POMs have the option to override and extend these properties. A typical use case in parent POMs is to provide <pluginManagement> and <dependencyManagement> sections; they also configure default dependencies, properties, plugins, Read More


The Gradle POM

Gradle is an extensible and very flexible build tool capable of building projects that target many platforms, not just Java. In the Java space it’s often compared to Apache Maven; one of the often cited complains against Gradle is that it’s “too complicated” or rather “too flexible” when compared to Apache Maven. It appears a large percentage of Maven users do love having a fixed structure that restricts the amount of havoc a junior developer may bring to the project if he or she desires to play with the build file. However this fixed structure also restricts power users from Read More


An opinionated way to build Gradle projects

If given a choice I’d pick Gradle over Maven as build tool 9 times out of 10. Gradle is a very extensible tool which has allowed me to customize my builds exactly how I want them to be, however this flexibility comes at a price as there’s a lot of configuration that has to applied to make a project follow a certain structure. Let’s say you’ve created a project and release it as Open Source. You’d typically post a release to Maven Central which requires following these guidelines, which include A well defined POM file. Attach a sources JAR. Attach Read More


More JavaFX Related Announcements

Following up on the recent news of JavaFX 11 and Java 11 being released, I’d like to announce that the following JavaFX related projects have been released as well: Project Version Link JDK 8 JDK 9 JDK 10 JDK 11 HarmonicFX 0.2.0 https://github.com/aalmiray/harmonicfx Y P P P BootstrapFX 0.2.4 https://github.com/aalmiray/bootstrapfx Y Y Y Y DesktopPaneFX 0.12.0 https://github.com/aalmiray/desktoppanefx Y Y Y Y JSilhouette 0.3.0 https://github.com/aalmiray/jsilhouette Y Y Y Y Ikonli 2.4.0 https://github.com/aalmiray/ikonli Y N N N Ikonli 11.0.0 https://github.com/aalmiray/ikonli N N N Y Y: Fully supported. N: No support at all. P: Partial support; some classes may not work due to Read More


Ikonli 11.0.0 Released

Celebrating the recent release of JavaFX 11 and the upcoming release of Java 11 (any moment now!) I’d like to announce that Ikonli 11.0.0 is out! Judging by its number you can tell that this release synchronizes with both JavaFX 11 and Java 11. This release provides 30 icon packs (the same number as 2.4.0) but it requires Java 11 as a minimum. All artifacts have been fully modularized and take advantage of JPMS. You can configure and run your application on the module path or in the classpath, either way Ikonli will resolve your favorite icons. If running on Read More


Nested Composite Builds with Gradle

If you work with source code of multiple dependencies at the same time then Composite Builds is the feature you didn’t know you needed. Back in October 2016 Gradle 3.1 introduced Composite Builds to the world. The idea behind this feature is to let a project build its external dependencies as needed; think of quick fixing a bug or checking for breakages before publishing a snapshot release. I’ve got a real world scenario for this feature: the set of builds for JSR377, the Desktop Application JSR. This specification provides the following artefacts jsr377-api: Defines the API for this JSR. jsr377-spec: Read More


Running Griffon Applications with JavaFX 11

JavaFX 11 has just been released! You can get the latest release and find more documentation about it at https://openjfx.io. Java 11 is just around the corner too. In order to prepare yourself for what’s coming here are the first details on modifying your Maven and Gradle builds to compile and run your Griffon project. Maven Make sure to have the latest Maven version installed. The current version is 3.5.4. Edit the pom.xml file and add a couple of additional properties <plugin.compiler.version>3.8.0</plugin.compiler.version> <javafx.version>11</javafx.version> Add the following dependencies to the <dependencies> block <dependency> <groupId>org.openjfx</groupId> <artifactId>javafx-base</artifactId> <version>${javafx.version}</version> </dependency> <dependency> <groupId>org.openjfx</groupId> <artifactId>javafx-graphics</artifactId> <version>${javafx.version}</version> Read More


DesktopPaneFX 0.11.0 Released

Version 0.11.0 has just been released! You can download it directly from Bintray’s JCenter and/or Maven Central. This version delivers the following changes: Bulk window operations added to DekstopPane and InternalWindow. A richer set of InternalWindowEvent values. Ability to register explicit InternalWindowEvent event handlers on InternalWindow. Bulk operations include the following ones: minimizeAllWindows minimizeOtherWindows maximizeAllWindows maximizeVisibleWindows restoreMinimizedWindows restoreVisibleWindows closeAllWindows closeOtherWindows tileAllWindows tileVisibleWindows tileHorizontally tileVertically These operations are available as direct method calls on DesktopPane. All of them except for the tiling ones are also available when popping a contextual menu on the title bar of an InternalWindow. Events triggered by Read More


Griffon Becomes 10!

I’m quite ecstatic to say that today is Griffon‘s 10th year anniversary! It all started way back in late 2007 when the Groovy Swing team decided to join forces and make the existing set of Groovy based builders for a handful of Java Swing widget sets more easy to mix and match to build better looking desktop applications. At that time Grails was making a big splash in the Groovy community, thus we decided to follow their lead and create a “Grails for desktop applications”, and so Griffon became a reality when Danno posted the announcement for Griffon 0.0 back Read More


ˆ Back To Top