As mentioned in the previous blog posts from MrHaki jq is a powerful tool to work with JSON from the command-line.
The power of jq can also be leveraged to extract data from a JSON structure and export it to CSV.
To illustrate this, we use the public Open Library Api found in this extensive overview of Public APIs.
After completing the Kotlin for Java Developers Course on Coursera I was looking for an excuse to put my freshly gained Kotlin knowledge into action. I decided to address my frustration about the large amount of falsely detected movements by one of my security camera’s.
One of the core components of that solution is a REST API that receives an image and returns a list of detected objects. I decided to develop that using Kotlin, KotlinDL and KTor.
This blog posts describes the core components of the solution. The source code of the example is available at GitHub.
More and more web-traffic is moving to https instead of http protocol. Because users are using a modern browser that defaults to https or a browser extension like Https-By-Default . A great development from a security- and privacy perspective. But with some side effects as it pointed out that the redirect service offered by our hosting provider does not fully support https which causes a security warning.
Although valid commercial solutions are available this fully triggered my (somewhat rusty) not invented here syndrome. Performing the redirect sounds like a suitable functionality for a simple cloud function. With the additional requirement that it should be able to host the cloud function on the (sub)domain(s) we want to use for our redirects.
This blog post will describe the simple steps to develop a cloud function using Firebase Functions and expose it through Firebase Hosting over https using a valid certificate.
Micronaut makes it possible to easily configure your application using the provided mechanisms based on Spring and Grails. This blog demonstrates how to configure a Kotlin based Micronaut application using Micronaut version 1.0.0.RC1.
First we create a Micronaut application featuring Kotlin:
After that we create our DemoController:
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.
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. We’ll verify two types of packaging strategies; package by layer and package by feature. For a definition of these strategies please have a look at this blog from Simon Brown.
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. At first we add the snapshot repository to our build.gradle file.
repositories {
jcenter()
maven {
url "https://oss.sonatype.org/content/groups/staging/"
}
}
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. Het ontwikkelen van een specialisme vergt tijd. Het vindt eigenlijk pas plaats tijdens een studie en wordt continu ontwikkeld tijdens je verdere carrière. Maar de passie voor het vak, dat wat mijn collega’s uniek maakt, wordt al veel eerder gelegd. Zonder uitzondering blijkt het ontstaan van deze passie te herleiden naar één of twee toevallige gebeurtenissen in hun jeugd: een ouder met een passie voor electronica, een vriendje (of vriendinnetje) met een computer etc..
Zelf heb ik het geluk gehad dat ik ook als kind de passie voor het maken heb mee gekregen. Door mijn opa al timmerend aan het werk te zien; een speelgoed tractor, een bed, een klimrek. Daarna werd het al snel mee timmeren en samen een vogelhuisje maken. Toen er via het werk van mijn vader een computer bij ons in huis kwam kreeg ik de kans om met het moderne maken in aanraking te komen. Samen met mijn vader de eerste programma’s schrijven zoals een muziekspeler, een spelletje en een catalogus om mijn muziek-verzameling in vast te leggen. De optelsom van deze ervaringen is van grote invloed geweest op mijn toekomst. Niet omdat ik destijds uitstekend heb leren programmeren, maar omdat mijn passie voor het vak daar is ontstaan en ik me op basis van die passie verder heb kunnen en mogen ontwikkelen.
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:
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:
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:
$ brew install grails
