Gradle added an incubation feature to Gradle 4.6 to add command line options for custom tasks.
This means we can run a task using Gradle and add command line options to pass information to the task.
Without this feature we would have to use project properties passed via the -P or --project-property.
The good thing about the new feature is that the Gradle help task displays extra information about the command line options supported by a custom task.
To add a command line option we simply use the @Option annotation on the setter method of a task property.
We must make sure the argument for the setter method is either a boolean, Boolean, String, enum, List<String> or List<enum>.
The @Option annotation requires an option argument with the name of the option as it must be entered by the user.
Optionally we can add a description property with a description about the option.
It is good to add the description, because the help task of Gradle displays this information and helps the user of our custom task.
Continue reading →
A low code approach to composing microservice architecture diagrams from per service context diagrams.
On a recent assignment I was one of multiple new engineers joining a start-up transitioning into a scale-up.
The past two years had been spent rapidly developing to prove the concept, and while at the outset some diagrams were drawn up, at the time I joined these were outdated, lacking or even misleading.
To help get ourselves and other new developers up to speed, Andrew Morgan and I set out to create architecture diagrams for the system as a whole.
Continue reading →
In this report Sjoerd Valk (@Sjoerdus) and Martijn van der Wijst (@vanderwise) try to sum up their experiences in Cluj-Napoca, Romania.
They stayed in Cluj during the 17th and 21st of April to attend the JSHeroes conference, a frontend conference all about JavaScript.
Presented by heroes of the JavaScript open source community.
Although most of the speakers admitted they weren’t really heroes, the very last speaker gave his talk in a hero-esque costume.
This year marks only the second edition of JSHeroes, but it’s organized really professional.
Speakers are from all over the world, and the location is a chique hotel.
A few kilometers out of the city center.
Its grandeur reminds us a bit of the Grand Budapest Hotel.
The name too by the way: the Grand Hotel Italia.
On Wednesday we followed an Angular Masterclass.
Thursday and Friday are the JSHeroes conference days.
The talks are just 30 minutes each. A quick pace and quite diverse topics.
The popular frameworks (React, Angular and Vue) were covered much, but also webfonts, Codesandbox, and V8, the engine behind JavaScript.
Continue reading →
Getting Stomp working using Spring was very easy.
It didn’t seem that easy to me because I tested my implementation with an integration test which seemed to fail at least as much as it succeeded.
In this post I will take you through my journey of getting a stable integration test on Spring Websockets.
Continue reading →
Congratulations! Someone has made the wise decision to hire you as the new technical lead.
It is an exciting time.
You start in a new environment, will be working with a new team and maybe even have to learn new technologies along the way.
This can be quite challenging.
In the first article I wrote about introducing change.
In this second article I want to share my personal views on shaping great teams.
As team lead, there are certain values that are just part of me and they way I think about leadership.
Fortunately, in JDriven I found a company that matches my values step by step.
These values are #commit, #develop and #share.
In this article I want to go into some of the values that I consider important to create a great team.
I consider sharing knowledge one of the most important values.
Teams consist of people with different experience levels and backgrounds.
It should be everyone’s goal to help each other grow and develop.
You can share knowledge in many ways.
Some examples are pair programming, help troubleshooting/debugging, collaborate on a design or technical sessions or writing articles.
By doing this we grow as a team.
Where one gains technical skills the other gains leadership skills or new insights.
Also don’t forget that even experienced architects can learn about new technologies from new programmers.
Asking for help from others also shows that you’re not some all knowing dictator and one man team.
Working on complex projects is a team effort that benefits from actively helping each other.
Continue reading →
With the release of Java 9, and the introduction of Project Jigsaw (the Java Platform Module System), we no longer have the need for a full-blown JRE to run our Java applications.
It is now possible to construct a stripped-down Java Runtime, containing the minimum set of required modules.
This allows us to create slim Docker containers without excess baggage.
The source code belonging to this blog post can be found at: https://github.com/rlippolis/java9-runtime-image
Our example application consists of two Java 9 modules (basically two JARs, with a module-info.java).
We assume the concept of modules is familiar to the reader.
If not, you can learn more about it e.g. here: http://openjdk.java.net/projects/jigsaw/
Firstly, we have a backend module consisting of a class which provides us with a String (to keep it simple).
The backend module has no explicit dependencies on other modules (only an implicit dependency on java.base).
Secondly, we have a frontend module consisting of an executable main class.
This class gets the String from the backend and prints it to System.out (again, very straightforward).
This module has an explicit dependency on backend, and an implicit dependency on java.base.
To see the application in action, build it with Maven (mvn clean package), and run it from the command line:
(or use the provided run-app.sh) The -p option sets the module path (similar to the 'old' classpath).
The -m option specifies the module and class to run.
Continue reading →
Congratulations! Someone has made the wise decision to hire you as the new technical lead.
It is an exciting time.
You start in a new environment, will be working with a new team and maybe even have to learn new technologies along the way.
This can be quite challenging.
In this two-part article I want to share my personal views regarding Introducing change and shaping teams as a technical lead.
When starting in this new environment you probably bring lots of energy and want to leverage your experience to change things for the better.
In my opinion introducing changes in a new environment requires some consideration.
Continue reading →
With the Asciidoctor diagram extension we can include diagrams that are written in plain text.
For example PlantUML or Ditaa diagrams.
The extension offers a block processor where we include the diagram definitions in our Asciidoctor document.
But there is also a block macro processor. With the block macro processor we can refer to an external file.
The file is processed and the resulting image is in our output document.
In the following example we see how to use the block macro for a Ditaa diagram:
Continue reading →
In our Groovy scripts we can use the @Grab annotation.
With this annotation we define dependencies for our script and they will be automatically downloaded and added to the class path when we run our script.
When we use IntelliJ IDEA we can use a nice intention that is part of the IntelliJ IDEA Groovy support to download the dependencies from our IDE editor.
IDEA downloads the dependencies and add it to the project module dependencies.
This is useful, because this will also adds code completion for the classes in the dependency to our editor.
Let’s see this with a little example. We have the following Groovy script in our Groovy project in IntelliJ IDEA:
Continue reading →
Just as we are over the crest of the microservice hype and can finally see how this architectural tool might (or might not) solve our problems the next hype is already here: serverless programming!
In this first blog post I’m going to explain what serverless is, what it isn’t, and how it can change the way we create software.
In the next posts I’m going to show a few simple examples using a well known 'serverless' platform: AWS Lambda.
Originally posted here .
So what is serverless? It’s not uncommon to see developers joke about how silly the term is because there’s obviously still a server right? Of course there is.
It’s impossible to run software without a CPU somewhere.
So why the name? Well, let’s take a step back in history to how we did things a few decades ago (and how a lot of companies still work!).
Continue reading →