DDevelopment & Design

Opportunity to grow

In 2022, in addition to the work we do for our clients, we put our heads together and organized events and activities that would help us further develop our skills and knowledge, while providing a healthy break from our daily tasks. What follows is a brief account of what we planned, what worked and what didn’t.

Book Santa

We started the new year with gifts. Everyone could order a book, an actual physical book made of paper and ink, the only condition was that it be “at least a little work-related”. The idea was well received and orders soon poured in. The logistics involved in collecting titles from 130 people, ordering and then sending them to those who work more often remotely proved something of a challenge, but somehow we managed. Only one book from the UK got irretrievably stuck in customs (thanks, Brexit!). I don’t know how many books were read – since they were gifts, it didn’t seem appropriate to ask! – but I do know that one of them is currently being used as a monitor stand. An unexpectedly fascinating side effect of the scheme was being able to take a look at the freely available excel sheet and see who had ordered what and to learn about books you’d previously been unaware of.

Flashtalks

We meet once a month on a Friday to hear three people from the company, usually developers, give short presentations. Ensuring that every month there are enough volunteers willing to talk about something technical or somehow related to our work is no mean feat. Persuading, encouraging, twisting the arms of busy colleagues is a major challenge for the organizers of these talks. Occasionally, these talks cover less technical areas and we get the chance to learn about advantages of giving and receiving feedback, money saving and how to become a conference speaker. The purpose of Flashtalks is to both share knowledge and create a space where presentation skills can be practiced and honed in front of a larger audience. In 2022 there were 29 speakers (seven of whom spoke twice) and 36 presentations altogether. Topics ranged from “How to monitor applications after deployment” to “Will Niagara Files work on the Mississippi” and “DIY simple lab power supply”. Both novice developers as well as senior conference veterans share their wisdom. One of the great things about Flashtalks is the post-talk questionnaire, which always provides us with valuable feedback on what went well and what could be done better. Each Flashtalk ends with a quiz, which introduces an element of gamification and prevents Flashtalks from becoming merely a chance to take a break from work.

One of the aims of the Flashki is to create new conference speakers. This year Monika Fus made her debut at Confitura, an event very much close to our hearts, where she spoke about “L10n, i18n and t9n in the JVM world”. Other speakers included Piotr Fus with his presentation “How to get started with metrics”, Maciek Próchniak with “Well, it’s time to synchronize watches” and Dominik Przybysz with “OOP Revisited”. The whole team traveled around Poland and beyond with their presentations. Check them out here: https://touk.pl/talks/2022. While we had hoped there would be more newcomers in 2022, we are confident that 2023 will see a greater number of conference debuts.

Dojo

TouK Dojo is a more hands-on learning initiative that one of the developers came up with this year. We hold technical workshops for each other and meetings where we solve problems, often algorithmic. It’s a good opportunity to bounce ideas off each other about how to do things, try out tools, ask questions and work on real examples. Meetings usually take place once a week, live and online.

Blog

In April, as a grassroots initiative, a few of us set a goal to post monthly on our company blog. We wanted to restore it to its former glory, or perhaps just revive it after the drought years of the pandemic. We almost succeeded, with our combined efforts resulting in six posts about hackathons, a summary of the first post-pandemic Confitura, and of course some technical posts. We are now thinking about how to take the initiative further. It seems that the valuable content we could share is there, but we need to find the time and a way to overcome writer’s block.

Hackathons

Last year we organized a couple of hackathons: one in the spring and one in the autumn. We had initially considered having four in the space of a year, but that turned out to be a bit too ambitious, given the amount of work we do for our clients and the number of ideas to hack. The general framework developed in battle is: two days in our office, any project, any team composition, pizza and snacks for all. You can read detailed descriptions of what we achieved here: https://touk.pl/blog/2022/05/12/touk-hackathon-toukathon-april-2022/ and https://touk.pl/blog/2022/11/28/toukathon-october-2022/. In spring sixteen people coded together, in autumn eight.

Books

It has always been possible for any employee to order books for our shared library. Perhaps because of the number of books gifted at the start of the year, the number of books ordered during the year was a little smaller than normal. Still, our library has now been enriched with:

  • Diagnosing and Changing Organizational Culture: Based on the Competing Values Framework, Kim S. Cameron, Robert E. Quinn
  • The Enterprise Big Data Lake, Alex Gorelik
  • The Java Module System, Nicolai Parlog
  • Bulletproof TLS and PKI 2ed, Ivan Ristić
  • Job crafting nowa metoda budowania zaangażowania i poczucia sensu w pracy, Malwina Puchalska-Kamińska, Agnieszka Łądka- Barańska
  • Functional programming in Scala second edition, Paul Chiusano, Runar Bjarnason
  • Functional Design and Architecture v7, Alexander Granin
  • Functional Event-Driven Architecture, Gabriel Volpe
  • Code, Charles Petzold

Since January is time for resolutions, here are ours. This year we want to continue the Flashki (the first has already taken place on 20 January), we will confidently hack together, and we are already planning a calendar of speeches at conferences.

— Previous article

TouKathon – October 2022

You May Also Like
DDevelopment & Design

Multi module Gradle project with IDE support

This article is a short how-to about multi-module project setup with usage of the Gradle automation build tool.

Here's how Rich Seller, a StackOverflow user, describes Gradle:
Gradle promises to hit the sweet spot between Ant and Maven. It uses Ivy's approach for dependency resolution. It allows for convention over configuration but also includes Ant tasks as first class citizens. It also wisely allows you to use existing Maven/Ivy repositories.
So why would one use yet another JVM build tool such as Gradle? The answer is simple: to avoid frustration involved by Ant or Maven.

Short story

I was fooling around with some fresh proof of concept and needed a build tool. I'm pretty familiar with Maven so created project from an artifact, and opened the build file, pom.xml for further tuning.
I had been using Grails with its own build system (similar to Gradle, btw) already for some time up then, so after quite a time without Maven, I looked on the pom.xml and found it to be really repulsive.

Once again I felt clearly: XML is not for humans.

After quick googling I found Gradle. It was still in beta (0.8 version) back then, but it's configured with Groovy DSL and that's what a human likes :)

Where are we

In the time Ant can be met but among IT guerrillas, Maven is still on top and couple of others like for example Ivy conquer for the best position, Gradle smoothly went into its mature age. It's now available in 1.3 version, released at 20th of November 2012. I'm glad to recommend it to anyone looking for relief from XML configured tools, or for anyone just looking for simple, elastic and powerful build tool.

Lets build

I have already written about basic project structure so I skip this one, reminding only the basic project structure:
<project root>

│

├── build.gradle

└── src

    ├── main

    │   ├── java

    │   └── groovy

    │

    └── test

        ├── java

        └── groovy
Have I just referred myself for the 1st time? Achievement unlocked! ;)

Gradle as most build tools is run from a command line with parameters. The main parameter for Gradle is a 'task name', for example we can run a command: gradle build.
There is no 'create project' task, so the directory structure has to be created by hand. This isn't a hassle though.
Java and groovy sub-folders aren't always mandatory. They depend on what compile plugin is used.

Parent project

Consider an example project 'the-app' of three modules, let say:
  1. database communication layer
  2. domain model and services layer
  3. web presentation layer
Our project directory tree will look like:
the-app

│

├── dao-layer

│   └── src

│

├── domain-model

│   └── src

│

├── web-frontend

│   └── src

│

├── build.gradle

└── settings.gradle
the-app itself has no src sub-folder as its purpose is only to contain sub-projects and build configuration. If needed it could've been provided with own src though.

To glue modules we need to fill settings.gradle file under the-app directory with a single line of content specifying module names:
include 'dao-layer', 'domain-model', 'web-frontend'
Now the gradle projects command can be executed to obtain such a result:
:projects


------------------------------------------------------------

Root project

------------------------------------------------------------


Root project 'the-app'

+--- Project ':dao-layer'

+--- Project ':domain-model'

\--- Project ':web-frontend'
...so we know that Gradle noticed the modules. However gradle build command won't run successful yet because build.gradle file is still empty.

Sub project

As in Maven we can create separate build config file per each module. Let say we starting from DAO layer.
Thus we create a new file the-app/dao-layer/build.gradle with a line of basic build info (notice the new build.gradle was created under sub-project directory):
apply plugin: 'java'
This single line of config for any of modules is enough to execute gradle build command under the-app directory with following result:
:dao-layer:compileJava

:dao-layer:processResources UP-TO-DATE

:dao-layer:classes

:dao-layer:jar

:dao-layer:assemble

:dao-layer:compileTestJava UP-TO-DATE

:dao-layer:processTestResources UP-TO-DATE

:dao-layer:testClasses UP-TO-DATE

:dao-layer:test

:dao-layer:check

:dao-layer:build


BUILD SUCCESSFUL


Total time: 3.256 secs
To use Groovy plugin slightly more configuration is needed:
apply plugin: 'groovy'


repositories {

    mavenLocal()

    mavenCentral()

}


dependencies {

    groovy 'org.codehaus.groovy:groovy-all:2.0.5'

}
At lines 3 to 6 Maven repositories are set. At line 9 dependency with groovy library version is specified. Of course plugin as 'java', 'groovy' and many more can be mixed each other.

If we have settings.gradle file and a build.gradle file for each module, there is no need for parent the-app/build.gradle file at all. Sure that's true but we can go another, better way.

One file to rule them all

Instead of creating many build.gradle config files, one per each module, we can use only the parent's one and make it a bit more juicy. So let us move the the-app/dao-layer/build.gradle a level up to the-app/build-gradle and fill it with new statements to achieve full project configuration:
def langLevel = 1.7


allprojects {


    apply plugin: 'idea'


    group = 'com.tamashumi'

    version = '0.1'

}


subprojects {


    apply plugin: 'groovy'


    sourceCompatibility = langLevel

    targetCompatibility = langLevel


    repositories {

        mavenLocal()

        mavenCentral()

    }


    dependencies {

        groovy 'org.codehaus.groovy:groovy-all:2.0.5'

        testCompile 'org.spockframework:spock-core:0.7-groovy-2.0'

    }

}


project(':dao-layer') {


    dependencies {

        compile 'org.hibernate:hibernate-core:4.1.7.Final'

    }

}


project(':domain-model') {


    dependencies {

        compile project(':dao-layer')

    }

}


project(':web-frontend') {


    apply plugin: 'war'


    dependencies {

        compile project(':domain-model')

        compile 'org.springframework:spring-webmvc:3.1.2.RELEASE'

    }

}


idea {

    project {

        jdkName = langLevel

        languageLevel = langLevel

    }

}
At the beginning simple variable langLevel is declared. It's worth knowing that we can use almost any Groovy code inside build.gradle file, statements like for example if conditions, for/while loops, closures, switch-case, etc... Quite an advantage over inflexible XML, isn't it?

Next the allProjects block. Any configuration placed in it will influence - what a surprise - all projects, so the parent itself and sub-projects (modules). Inside of the block we have the IDE (Intellij Idea) plugin applied which I wrote more about in previous article (look under "IDE Integration" heading). Enough to say that with this plugin applied here, command gradle idea will generate Idea's project files with modules structure and dependencies. This works really well and plugins for other IDEs are available too.
Remaining two lines at this block define group and version for the project, similar as this is done by Maven.

After that subProjects block appears. It's related to all modules but not the parent project. So here the Groovy language plugin is applied, as all modules are assumed to be written in Groovy.
Below source and target language level are set.
After that come references to standard Maven repositories.
At the end of the block dependencies to groovy version and test library - Spock framework.

Following blocks, project(':module-name'), are responsible for each module configuration. They may be omitted unless allProjects or subProjects configure what's necessary for a specific module. In the example per module configuration goes as follow:
  • Dao-layer module has dependency to an ORM library - Hibernate
  • Domain-model module relies on dao-layer as a dependency. Keyword project is used here again for a reference to other module.
  • Web-frontend applies 'war' plugin which build this module into java web archive. Besides it referes to domain-model module and also use Spring MVC framework dependency.

At the end in idea block is basic info for IDE plugin. Those are parameters corresponding to the Idea's project general settings visible on the following screen shot.


jdkName should match the IDE's SDK name otherwise it has to be set manually under IDE on each Idea's project files (re)generation with gradle idea command.

Is that it?

In the matter of simplicity - yes. That's enough to automate modular application build with custom configuration per module. Not a rocket science, huh? Think about Maven's XML. It would take more effort to setup the same and still achieve less expressible configuration quite far from user-friendly.

Check the online user guide for a lot of configuration possibilities or better download Gradle and see the sample projects.
As a tasty bait take a look for this short choice of available plugins:
  • java
  • groovy
  • scala
  • cpp
  • eclipse
  • netbeans
  • ida
  • maven
  • osgi
  • war
  • ear
  • sonar
  • project-report
  • signing
and more, 3rd party plugins...