About Rob Brinkman

Rob's interests and knowledge focus on application development using open source software. He utilizes his Java experience as a developer hands-on architect on successful JVM based projects. When not online he prefers to spend his time with his kids and kitesurfing.

Implementing architectural fitness functions using Gradle, JUnit and code-assert

Architectural fitness functions

Inspired by Neal Ford’s presentation at our Change is the Only constant event I started experimenting with architectural fitness functions. An architectural fitness function provides an objective integrity assessment of some architectural characteristic(s).

If you want to take a deeper dive into evolutionary architectures including fitness functions take look at Neals book: Building Evolutionary Architectures: Support Constant Change.

Neal’s slides contained an example of verifying package dependencies from a Unit Test using JDepend.


Verifying code modularity

In this blog post we’ll elaborate on that approach and create a Unit Test that verifies that our code complies to the chosen packaging strategies using an alternative to JDepend named code-assert.

Continue reading

Exploring the Vert.x MQTT server project

In the last few years we used Vert.x to prototype and develop several IoT related projects. Most of the projects use MQTT for lightweight messaging between the connected devices (or things ;)) and the applications. The messaging is handled by an external broker liker Mosquitto.

Instead of using an external broker it’s now possible to connect MQTT enabled devices directly to Vert.x using the Vert.x MQTT server project. Although the project is still in Tech Preview we’ll show you how use it to create a MQTT server within Vert.x. Continue reading

Het ontstaan van de passie voor het moderne maken

Als JDriven ervaren we elke dag hoe schaars het talent is dat nodig is om onze klanten optimaal te ondersteunen. Deels omdat we op zoek zijn naar echte specialisten maar vooral omdat we verwachten dat collega’s een passie hebben voor hun vak en erg gemotiveerd zijn om mooie dingen te maken.

Deze passie is voor ons essentieel en wat mij betreft is dit de basis van succesvol software ontwikkelen oftewel het moderne maken. Continue reading

Building Vert.x projects using Gradle

We currently use Vert.x in several internal and external projects. Until the most recent project we where building our Vert.x modules using Maven.

Gradle is our build tool of choice, but the default approach described at the Vert.x site caused several issues:

  • The task of cloning, cleaning and configuring the template project is error-prone;
  • The template project does not support recent Gradle versions >= 2.x;
  • This approach is not compatible with the Gradle support in IntelliJ IDEA.

While starting our most recent project we investigated the possibility of using Gradle again. Instead of using the approach described at the Vert.x site we are using the excellent Vert.x Gradle plugin provided by Daryl Teo.

Using the following Gradle build file we are able to build and run our project from Gradle and import it successfully into IntelliJ IDEA:

Using this configuration exposes the following Vert.x related Gradle tasks:

  • modZip : Creates the module zip
  • debugMod : Run the module including remote debugging
  • runMod : Run the module

More information regarding this marvellous Gradle Vert.x plugin can be found at:

Note that the credits for the Vert.x Gradle plugin fully go to Daryl Teo. This post is only meant to raise the awareness of the existence of the plugin and to complement him for his great work.



Suggested Parleys Watchlist for Devoxx 2013

This year we attended Devoxx 2013 with a total of 9 JDriven colleagues. After more than a week we finally recovered from a vast amount of great sessions, personal encounters and  ‘some’ Belgian beer. Looking back at Devoxx we had a great conference and like to thank the Devoxx team for making this possible. It was also good to notice that the majority of the sessions are related to subjects that drive us at JDriven, during our daily job and while further developing our expertise and craftsmanship, to name a few: Continuous Delivery, AngularJS, RESTful API’s, Gradle, Groovy, Grails, Java 8, Java EE.

The Devoxx 2013 sessions will be available at Parleys soon, hopefully just before the holidays. To protect you from infobesity we’d like to share our list of must watch sessions with you:

Suugested Parleys Watchlist for Devoxx 2013

Sven Peters – How To Do Kick-Ass Software Development
Sven, a presenter who is just full of energy, tells how software is developed at Atlassian and how they can build great software with even greater pleasure.
He explains how a good team, becomes a kick-ass team. He also mentioned that we as developers are always working to help automate others, but often forget to automate our own work. The presentation contains lots of tips and tricks.

Guillaume Laforge – What Makes Groovy Groovy
A great overview of the various aspects and power of Groovy targeted at Groovy newbies. The presentation contains great code examples, starting with Java code and showing off the Groovy alternatives ending up with less code but exactly the same functionality. A great session and good overview of how Groovy enriches (and improves) Java. Probably not too much news for Groovy experts but for a newbie certainly valuable.

Ben Hale – Designing a REST-ful API using Spring 4
Very good presentation that covered lot’s the concepts of the REST standards (or lack of it) and how to implement this using Spring 4 features and Spring-HATEOAS.

Seth Ladd – Mobile, multi-device, multi-player with HTML5 and Dart
A pretty solid, almost marketing, talk about developing the word game Boggle entirely using Dart. Seth also demonstrates his own recently developed API for offline-enabled browser-based web apps: Lawndart. The application has been developed as set of custom reusable components using polymer.dart (instead of angular.dart).
This presentation gave a great overview of Dart and the initial impression of Dart is very impressive. It certainly creates interest in investigating and playing with Dart.

Paul Sandoz – in full flow: Java 8 lambdas in the stream
A clear overview of the use of the new stream API to declaratively perform actions on lists using lambdas. Also the benefits and pitfalls of using streams in combination with multithreading are explained.

Simon Ritter – Is It A Car? Is It A Computer? No, It’s a Raspberry Pi JavaFX
A very nice session that explained how a Carputer could be made from a RaspberryPI and the risks you introduce when connecting your car with a RaspberryPI.
Using a touch screen connected to the RaspberryPI and an application developed using JavaFX to operate and view the data from the on-board computer.

Tugdual Grall, David Pilato – Elastify your app: from SQL to NoSQL in less than one hour!
Within an hour, a simple application backed by a SQL database is converted to a CouchBase database and then coupled with a Elasticsearch. The steps to take to convert the existing application are clearly explained. After the conversion, the data in the system is visualized using Kibana.

Geert Bevin – Programmers are way cooler than musicians
Geert Bevin presents the Eigenharp, a musical instrument which has been built on a completely different approach from it’s predecessors. Throughout his presentation he shows not only the instrument but also hints at the possibilities one gets if he lets go of “how things are”. An interesting display of thinking outside the box leading to a new design.

Hans Dockter – Gradle for Android and the Rest of the World Conference
Hans illustrated the possibilities and power of Gradle by explaining how the Gradle based build system for Android works. This new build system has been developed as a Gradle plugin by the Google Android team. He also noted that some people see the flexibility of  Gradle as a downside but stated that the opposite is true because you can use the power of Gradle to limit this flexibility. For instance you could fail a build when dependencies from a non whitelisted  repository are used.

This is just our short list ;) but have fun and see you next year @Devoxx!

Quick Tip: Installing and switching Grails versions on OS X using Homebrew

I’m using Homebrew “The missing package manager for OS X” for a while now but when it come’s to Grails I still install it manually: until now!

Installing the most recent version of Grails using Brew is straight forward:

But the main reason for me to install Grails manually is the fact that I ‘d like to be able to install multiple versions and select a specific version for the project I’m working on.
I just found out that that’s also very easy with Homebrew.

Continue reading