GeeCON is a conference focusing on the Java and JVM technology, with special emphasis on dynamic languages – Groovy or Ruby. Conference meetings are an opportunity to share your experience on modern software designing methodologies.
David Moore - Platform and Product Evolution at Sabre
We began this year’s conference from a notion every programmer sooner or later will meet within the course of their professional career. It’s work on the code created by other programmers who no longer work in our company. Such an old code whose implementation details are not known any more is very difficult to maintain and it is difficult to introduce potential changes in it.
David Moore shared his experience connected with such problems with us. His lecture was a great source of knowledge for the people who encounter inherited codes. All his theses were supported with real system examples, which was extremely convincing. This speech was particularly interesting for younger programmers, but I’m certain that also experienced coders learnt many useful details from it.
Matt Raible - Building a PWA with Ionic, Angular and Spring Boot
Matt Raible was the next speaker whom I had an opportunity to listen to. He introduced himself to us as a Java buff and a great fan of VW vans. After an original introduction, he tried to show us a different way of designing applications that will work on all devices, regardless of their size.
The key element here was to start designing the application from small screens (e.g. the small screen of a smartphone). The developer should think about adjusting the site to its full size that the users will see on computer screen later. This way the site’s design will be functional everywhere.
Moreover, we could see the tools supporting this approach, i.e. Ionic supported by Angular and Spring Boot. Technological trends have been heralding the “mobile era” for some time already, so it seems that developers also treat this more and more seriously.
Milen Dyankov - What's NOT new in modular Java?
Modularity of Java is the feature that we use eagerly as programmers. However, we easily forget ourselves and then we end up with a very complex app whose every single module is combined with lots of others. This makes apps almost impossible to manage.
This statement was the leitmotif of this conference. Yet we went further than just to make it. The speaker showed us the tools: OSGI and a novelty in Java - JPMS. All this was intended to show us the techniques that facilitate creating an orderly application. An app that can be managed easily and one that will be easy to modify in the future.
Alexander Gallego - Distributed Stream Processing Over Thousands Of Data Centres
As expected by the audience, the lecture on processing in scattered systems discussed the complexity of such systems. The difficulties resulting from this complexity haunt all programmers dealing with such systems.
What the audience must have been disappointed with was that we were not really given any specific solutions of these problems. Although the problems discussed were real and known to everyone who works with large scale scattered systems, their solutions, or at least suggestions how to handle them, were missing.
Jakub Marchwicki, Jarosław Pałka - Stages of maturity on the way to microservices
The lecture of Jakub and Jarosław was delivered in an exceptionally original way. It was rather a discussion attempting to reconstruct their previous discourse on this topic. This introduced the audience to their line of reasoning, which produced the conclusions included in the presentation.
The main purpose was to discourage us from using microservices. The speakers showed us the assumptions of this technique and, referring to their experience, pinpointed the threats awaiting programmers at particular stages.
The conclusion was that we should use microservices consciously and reasonably. Microservices are a technique that gives us great opportunities, but at the same time creates difficulties both in terms of efficiency and programming. Therefore, they should be used in the situations when it’s really necessary. At present programmers often use them because they are trendy.
Marcin Grzejszczak - Consumer-Driven Contracts to enable API evolution
The so-called contracts discussed by Marcin Grzejszczak are intended for excluding potential errors during system integration via APIs. This method aims to reverse the way of designing tests of the interfaces used by applications to communicate.
Usually the client of the communication process designs the tests of its methods. The reversal proposed in this method consists in the server defining system communication and designing tests. Then the client tests its communication with these tests.
The presentation ended with a case study based on this method and examples of source codes of such contracts.
DuyHai Doan - Big Data 101, all the foundations you need to bootstrap a new project in 2017
The speech on Big Data in fact discussed the Cassandra database and its use in such applications. DuyHai Doan’s lecture was a good example of how to work with this database for everyone who is considering it.
The speaker discussed the problems that will be encountered by everyone who will try to apply this database. Moreover, he analysed it in detail and indicated when a given database should be used and when it is not recommended.
Andrew Sorensen - Sound Synthesis in the Computational Crucible
At the end of the second day the organisers prepared an unusual presentation of Andrew Sorensen, who combines programming and music in his work. Andrew is a DJ who creates his music with a programming language. During his live performances the audience may watch the source code on the screens.
During the lecture we could listen to a live performance and watch how the code transformed into music was being created. It was definitely the most original lecture during the entire conference. To see it watch the video: >>>CLICK<<<
Henning Schwentner - Value types - The Next Big Thing for Java
Henning Schwentner’s lecture discussed the problem that will only appear in the future version of Java (10). It was very interesting to see the syntax that has not yet been determined and is still in development. This definitely casts new light on the way major programming languages evolve.
The main topic were the types indicating specific value, not a variable. It’s a novelty drawn from other languages. The main reason of introduction of this functionality was obviously its performance – it saves the place for initialisation of many same value variables and allows to indicate the same value from different places.
Jakub Kubryński - JPA beyond copy-paste
The thesis statement of this lecture was that developers do not use the JPA tool consciously. Since JPA facilitates developers’ work and makes it simpler, many of us forget about optimisation and assume that the tool will do all the work instead of them. It’s not true. Examples of potential problems that may be encountered were presented to us.
The topics discussed:
- Differences between set, bag and list.
- The N+1 problem during data extraction through lazy
- Differences between persist/merge
- Optimistic locking
- Hashcode number in ID problem
- Flush modes
All these topics were good examples of how easily we go for the easy option of frameworks, which reduce the amount of our work, but when used incautiously they may negatively affect the final performance of the application.
Jakub Marchwicki - Java9 and REPL. Forget debugging, welcome joy and productivity
The lecture concerned the interactive programming environment REPL, which will soon appear in the new version of Java. The speaker presented the functionalities of this tool in the form of a demo.
Programmers know such interactive environments well from other languages. Especially the relatively young ones that were created recently and the script languages. This new functionality of the version of Java that will be released soon may considerably facilitate experimenting with this language. It eliminates the need to laboriously compile and test applications and makes ‘playing’ with shortcodes possible. This functionality in combination with lambda expressions and streams from the previous Java version really gives us a lot of opportunities.
Avishai Ish-Shalom - Actionable Exceptions
During his presentation Avishai Ish-Shalom shared his observations on the abuse of exception mechanism by developers in their apps. After a few words about his professional interests and the kind of whisky he likes to drink while programming, he started to make us realise how often we resort to an exception in a situation when it would be enough to use a conditional instruction.
These observations and his conclusions were illustrated with the data from code analysis of some applications available on github. He proved that in a vast majority of cases developers do not make the effort to catch the errors or solve problems wisely. They are usually logged or disabled.
This lecture brought up the issue which really escapes practically every programmer. It was an eye-opener that made us aware of improper use of one of the most frequently applied Java techniques.
Rod Johnson (Creator of Spring) - Simplification and Automation in Java: Yesterday, Today and Tomorrow
The last lecture during this year’s edition of GeeCON was delivered by Rod Johnson – one of the creators of the post popular Java framework, i.e. Spring. The main idea behind Spring is convention over configuration.
This very thesis was the leitmotif of the lecture. This idea is developed in the Atomist project, which was presented in the form of a demo. This tool facilitates easy automation of application building. The idea known from the Spring framework - convention over configuration – was developed here. As a result, a tool was created thanks to which, if we follow the convention, we can automate our processes with small work input.
Which presentations from this year’s edition of GeeCON were the most memorable for you? What did you find useful? Or maybe you were disappointed with something? Please join the discussion in the comments section!