Με αυτή την αφορμή, θα αφήσω εδώ κάποιες σκέψεις σχετικά με τα ανοιχτά δεδομένα στη χώρα μας.

Για όποιον ψάξει για ενδιαφέροντα dataset για να οπτικοποιήσει, γίνεται γρήγορα προφανές ότι τα ανοιχτά δεδομένα δεν είναι πρώτη προτεραιότητα στην Ελλάδα. Δύο από τις “κεντρικές” σελίδες με ελληνικά ανοιχτά δεδομένα είναι το data.gov.gr και το statistics.gr. Υπάρχουν τα παρακάτω μοτίβα προβλημάτων:

• Εγκατελειμένα dataset: dataset που έχουν δεδομένα μέχρι κάποιο έτος, και μετά σταμάτησαν να τα ανανεώνουν.
• Dataset αντί για API: κάποια δεδομένα έχει νόημα να ανανεώνονται συχνά (πχ κάθε μέρα), αντί να είναι στατικά
• Ακατάλληλα data format: Πολλά dataset διατίθενται σε ακατάλληλα format, πχ σε excel, doc ή PDF (συνήθως ένα ανά χρονιά, διαφορετικής δομής), αντί να είναι σε κάποιο format πιο κατάλληλο για επεξεργασία.
• “API” που σερβίρει στατικά δεδομένα: Ειδικά το data.gov.gr είναι γεμάτο “API” τα οποία απλά σερβίρουν ένα στατικό αρχείο που δεν ανανεώνεται ποτέ.
• Έλλειψη ανοιχτών δεδομένων: Ίσως το μεγαλύτερο πρόβλημα είναι η έλλειψη ανοιχτών δεδομένων.

Γιατί όμως είναι πολύτιμα τα ανοιχτά δεδομένα, ώστε να δικαιολογείται το κόστος συντήρησής τους; Τα ανοιχτά δεδομένα έχουν αναμφίβολα κόστος παραγωγής και συντήρησης. Όμως μπορούν δυνητικά να δώσουν πολλαπλάσια αξία. Αυτό επειδή άνθρωποι μπορούν να χτίσουν επιπλέον αξία γύρω από αυτά (οπτικοποιήσεις, προγράμματα), χωρίς κάποια επιβάρυνση για το κράτος, και να κάνουν προσβάσιμη την πληροφορία στο ευρύ κοινό. Όταν τα ανοιχτά δεδομένα είναι προσβάσιμα σε τόσους ανθρώπους, μπορεί να αξιολογείται η λειτουργία του κράτους πλέον μετρήσιμα και αδιαμφισβήτητα, φέρνοντας στην επιφάνεια παθογένειες.

Έχοντας αυτό στο νου, και επίσης επειδή μου αρέσει η οπτικοποίηση δεδομένων, γράφω μικρά και μεγάλα προγράμματα που βασίζονται σε ανοιχτά δεδομένα της Ελλάδας.

Όχι ότι έχει κάποια σημασία, αλλά μια προσωπική wishlist από ανοιχτά δεδομένα, κατά προτίμηση σε μορφή API θα ήταν:

• Τα αστυνομικά δεδομένα με συντεταγμένες (για παράδειγμα στο Ηνωμένο Βασίλειο έχουν εφαρμογή που τα δείχνει στο χάρτη).
• Δεδομένα μετακίνησης (για παράδειγμα το εξαιρετικό Transport for London). Ενώ υπάρχουν API για την τηλεματική του ΟΑΣΑ και του ΟΑΣΘ, δεν υπάρχει για το Μετρό και τον Προαστειακό, ούτε για την ακτοπλοΐα.
• Δεδομένα για την εξυπηρέτηση στα νοσοκομεία

This feels so strange. For as long as I remember, USA was a close ally. In this new world, the US accuses and mocks the EU for all sorts of things, wants to take over Greenland, and wants to take over Canada as well. If you haven’t already, it’s worth listening to the Canadian Prime Minister’s speech at the World Economic Forum 2026.

Europe should use this situation as an opportunity to grow a spine and stand on its own feet.

While we are at it, over the next months, I will try to distance myself from USA-based products and move over to Europe-based stuff as much as possible.

This is my preference:

1. EU-based
2. Open source
3. Rest of the world (non-USA)
4. USA

Here are some resources I plan to explore:

• https://eualternative.eu/
• https://www.switch-to.eu/en
• https://www.goeuropean.org/
• https://european-alternatives.eu/

This is by no means a simple endeavour, and I am also not sure how well it will go. The reason is that, digitally at least, most of us are tied up in one of the two ecosystems: iOS or Android. We use them for critical stuff, like email, photos, maps & navigation etc.

There was some low hanging fruit I quickly picked up. Firefox for web browsing, and Mistral.ai for daily LLM use. So far so good.

When colleagues return from time off abroad, they often bring a local delicacy for the office and announce it in Slack, so that we can help ourselves. Normally people add happy emojis, often including the flag of the country mentioned in the post.

Instead, I like to add the emoji an incorrect flag that only resembles the correct one in appearance, planting a subtle seed of confusion. Most people will go on and click the incorrect flag emoji, and go on with their lives.

The incorrect flag may be:

• A flag with similar patters
• A flag with similar colors

You could call it flagrolling.

Examples:

• 🇺🇾 (Uruguay) instead of 🇬🇷 (Greece)
• 🇵🇫 (French polynesia) instead of 🇦🇹 (Austria)
• 🇮🇪 (Ireland) instead of 🇫🇷 (France)

Goals:

• Be the first one to post an incorrect flag
• Get as many clicks as possible on the incorrect flag
• Extra credit if noone adds the correct flag

Gallery

French Polynesia 🇵🇫 instead of Austria 🇦🇹

Philippines 🇵🇭 instead of Czech Republic 🇨🇿

Norway 🇳🇴 instead of Iceland 🇮🇸

Morocco 🇲🇦 instead of Vietnam 🇻🇳

Credits

Thanks a lot to George Stefanis for the idea to create this post and for proofreading it.

The first presentation was by Vassilis Bekiaris (LinkedIn profile, Twitter) of Hazelcast with title “Using JCache to speed up your apps”. Vassilis began with the main motives for caching and that we should consider it when our data either does not offen change or is very expensive to retrieve. Then he explored how the concepts latency and size come together in caches, as well as when deserialisation plays a role. Then he presented the patterns of caching aside and caching through and went on with the differences of in-process caches (single node) and distributed caches (multiple nodes). In the latter, the cached data needs to be serializable (so that it can be transmitted to all the cache nodes). However, it may be a good practice to serialize in the first case as well, because your data may exceed the heap size (or simply because you may want to be ready to go distributed). JSR-107 is the specification for caching in Java, for which there are several implementations, one being Hazelcast. Vassilis went on with some of the entities JSR-107 specifies (Caching, CachingProvider, CacheManager and Cache), some other constructs to transform or perform computations on your data and with the Listeners your cache comes with. He then showed the annotations (with support for CDI, Spring and Guice) and can also provide real time statistics via JMX. Vassilis showcased some sample code (github) and also played around with caching in the Spring Boot sample (github). You can find the slides of his presentation here.

The second presentation was by Apostolos Polymenakos (LinkedIn profile) and Giorgos Sikalias(Youtube channel), both employees of Eurobank, and was titled “Docker, Kubernetes & Java Microservices”. Giorgos is an ex colleague from our days at Trasys and is an accomplished circuit driver, although I wouldn’t get in a car he drives. Apostolos started the presentation with some basic concepts of microservices and their main differences to monoliths. He went on explaining that containers have actually been around since 2008 and offer OS-level virtualization (they hide everything but the OS kernel and the appropriate binaries and libraries). VMs are inherently different from containers in that you may run multiple isolated containers on the same OS without paying the overhead of the OS again and again for each deployment. Their key advantages are the small footprint, their portability and the fast startup. Docker is the container engine with the greatest momentum. In order to manage a large number of containers in production, we need a container orchestration engine, and Kubernetes is also the one with the greatest momentum. Apostolos finished his part of the presentation explaining that Kubernetes tries to make sure that the production system remains in the specified declared desired state with mechanisms for self-healing, making effective use of the hardware, while abstracting the infrastructure.

Giorgos continued with the second part of the presentation, which was about how his team set out to use Docker and Kubernetes to build the infrastructure for Eurobank. He started with pointing out the importance of selecting an appropriate image with respect to size, out-of-memory handling and startup parameters. He went on with the importance of monitoring in order to be able to track down problems. Having this in mind, they use the Spring Boot Actuator, Jolokia and hawt.io. Giorgos continued with the Spring Cloud family of libraries (some of which come from Netflix) such as Hystrix, Sleuth. Another point to consider is that it is desirable to move as fast as possible to the final (on-premise in Eurobank’s case) infrastructure, as many public clouds are not performant and the developers and operations will need time to familiarize. He closed the presentation with some tips that boosted his team’s productivity, such as Kotlin, Spock for testing and the source-to-image tool. Giorgos also pointed out that a company needs to invest on good hardware and tooling for developers to be able to work effectively (I hope some managers are reading this). You can find the slides of his presentation here and the video below:

This was the first meetup for the 2017-2018 season, and we were happy to have gathered around 90 JHUG members plus around 20 employees of our host. Seeing that there is this kind of interest for the meetup is indeed very encouraging for us, the organisers.

Some devops information: Although we recorded the presentations, due to a glitch with our new recording equipment (a generous offer by yours truly), we were not able to record the sound. This means that the sound in the videos to come will be the one captured by the camera.

Moving on with the presentations. Sam Shemirani (Linkedin) made a presentation on “Microservices with Spring Boot”. Sam walked us through the subject using their project that implements the EU PSD2 directive that has to do with credit card charges on banking systems. He began with some basic ideas on Microservices vs Monoliths and advantages and disadvantages of each architectural paradigm. He then explored several aspects which are important to implement a Microservices architecture, the first being authentication. He also explained how their system makes use of Netflix Eureca for service discovery and Netflix Zuul for routing incoming requests to different microservices (hence the universal hostname and port for all requests). He overviewed two flows of oAuth (which his team decided to use over JWT) and performed a demo with Postman on their API. Another concern Sam explored is centralised logging, which helps figure out the sequence of requests spanning several microservices. His team implements centralised logging using Logback, Apache Kafka and the Elastic Stack. Their system makes use of Docker for the containerisation of the microservices. This also enables using a container orchestration system (such as Kubernetes or Docker Swarm) for deployment, monitoring, elasticity and scaling. A very interesting part of the presentation is how Spring Boot brings all this together for us. If you haven’t seen it already, you will be impressed with Spring Initializr, where you can check the dependencies you need, and a new project will be generated for you where you can start writing your business logic. You can find the slides here and watch the video below:

The second presentation was by Ioannis Kolaxis (Linkedin, Twitter), who talked about Java 9. The first key feature he presented was, naturally, modules. Ioannis explained how modules further refine access control in our codebase, and that the feature was indeed huge, as it incorporated splitting the JVM itself into modules. A (big, red) cherry on top is the jlink tool, with which we can “generate” a custom, lightweight JVM, which only contains the modules our code needs. Ioannis went on with the syntactic sugar Java 9 brings for defining immutable collections, and the gotcha of random iteration order for unordered collections. Another big change is in garbage collection, where G1 is the new default. As Ioannis said, G1 is a low latency-oriented garbage collector, which uses several smaller regions (instead of 2 bigger ones for Young and Old generation). Java 9 changed the memory representation of Strings, which makes them more compact. Java 9 also brings new classes for native process handling and a brand new HTTP client, which also supports HTTP2. Finally, Ioannis demonstrated the jshell (Java Shell) tool, a REPL tool like the ones commonly used with scripting languages. Jshell is ideal for trying out and experimenting with small snippets of code without having to recompile - redeploy our application. You can find the slides here and watch the video below:

At the end of the meetup, we gave away a copy of Spring Microservices in Action and a copy of Java 9 Modularity.

See you all at the next meetup!

The art of visualising software architecture (Simon Brown)

The keynote speech was by Simon Brown, who started his presentation by pointing out the disparity and lack of standardisation of software architecture diagrams (functional view, component view). Members of the same team will draw the same system they just architected together differently and will not understand each other’s diagram. He went on with some different software visualisation approaches and their disadvantages describing architecture. For example, UML (which is too low level), N+1 and the methodologies in the book View points and perspectives. Almost always the Logical view and the Development view are different, because they are created by different people with different viewpoints (i.e. Business vs Architect).

The problem is that there is no good, ubiquitous vocabulary to describe software architecture. The so called “Component diagrams” all around the world have a different level of abstraction (he showed a diagram with a cryptic “Business Logic” component). He also listed some desired properties for a diagramming model:

• To be text-based (in order to be version-controllable and diffable)
• To be connected to the code

Simon brown has created his own software system diagram, Structurizr, which has 4 levels of abstraction: Software system > Containers > Components > Classes. It is a static model around which all sorts of views can be created. Structurizr comes with 2 libraries (one for Spring and one for .Net), which scan a compiled project with reflection and generate the text model for the software. You can have a look at some of the diagrams that can be created out of the generated model here. Some of these, have “drill-down” capabilities from the high-level to the lower-level layers of the architecture.

You can do better with Kotlin (Svetlana Isakova)

Next I attended the talk about Kotlin by Svetlana Isakova of Jetbrains, which is as of yesterday officially supported for Android development. Kotlin compiles to Java bytecode, to Javascript and native code. Also, Gradle plans to support Kotlin. Thanks to Jetbrains (who also develops one of the best IDEs), it also has very good tooling (she also showed us the Java to Kotlin converter). She then went on with some important features of the language, like the named method parameters, the data keyword (which adds equals and hashcode methods to classes) and the nullable types. She spent the rest of the talk on coroutines, one of the (experimental for now) features of the language, which provides the language constructs for async-await.

Continuous learning of Tech Professionals in an evolving world (Dimitris Livas)

The next talk I attended was by Dimitris Livas, and was about the important role of continuous learning of tech professionals in a world that evolves with great speed. He started by exploring the needs of a professional in order to remain relevant (i.e. to be marketable, up-to-date) and the needs of businesses (to be attractive to talent, to be able to migrate its tech). As far as professionals are concerned, common challenges are self awareness, field state awareness and the adaptation to new evolving stages. Also, different professionals have different goals (i.e. long term employment, or using bleeding edge technology, or set a target role for the next years).

A key takeaway from the talk was that the term “scrumification” is applicable for the personal development of a professional (where the professional is the scrum master and product owner, their personal development is the product and the things they want to grow into are the backlog). The professional development also has “sprints”, as it involves small steps, reevaluation of targets and keeping track of the progress.

Dimitris Livas also pointed out the importance to have a coach, who works on the same area with the goals of the professional. Finally, he closed with five values that are essential for the personal development: Having a purpose, being adventurous, being agile, respecting and empowering colleagues and trust.

Taming the Dragon: Conquering non blocking code with RxJava (Frank Lyaruu)

I then attended the talk by Frank Lyaruu on RxJava. Frank started by listing the merits of blocking code over non-blocking: it is familiar, easy to reason about and easy to debug. He went on by comparing the same code in non-blocking servlet 3.1 (>30 lines) versus node.js (3 lines). He went on with RxJava and wrapped some blocking code in a non-blocking method returning an Observable, showing that it is light and easy to add to existing apps. He also touched the notion of backpressure.

Frank continued by clearing out that non-blocking code is not about running faster, but rather unblocking threads, and pointed out that there are few reactive drivers available (i.e. RxNetty, RxMongo, Couchbase, barely any SQL support). Furthermore, he underlined that blocking IO is a lie, but you can get away with it if network latecy is low (however, applications cover more distance) and if our network is reliable (however, we use wireless more and more).

He closed concluding that blocking code misbehaves under pressure and that its price will keep going up. So the adoption of non-blocking code will be inevitable.

Mutation Testing to the rescue of your Tests (Nicolas Frankel)

This was my favourite technical talk of the conference, by Nicolas Frankel, and was about mutation testing. Apart from the interesting topic, the talk had just the right amount of developer grievances and humour. Nicolas started with listing the many kinds of testing that we use (unit, integration, performance, penetration, end-to-end and others) trying to ensure the quality of our production code. He pointed out that one of the metrics we most often use is code coverage, and we often fool ourselves that high code coverage alone means quality code, which is not the case given how easy it is to achieve high code coverage without testing anything of value.

He then went on by explaining what mutation testing is. Mutation testing in essence messes up our code in different ways (how cool is that!) and makes sure that our normal tests fail. If the tests don’t fail on the messed up code, there is something wrong. He went on with PIT and the list of mutations it supports. Some important ones are the “conditionals boundary mutator” (it you have if (a<b) {...} the mutator may change it to if (a<=b) {...}), removing method calls and others.

Nicolas went on with a demo, and closed saying that PIT comes with its own set of shortcomings. For example, it does produce false positives, it is slow (it will create a new version of the code for each applied mutation, run all the tests on it and produce aggregate results). Some of these shortcomings have workarounds, like using more threads, incremental analysis (i.e. running mutation tests only for changed code), and not binding to the test phase.

Better security and privacy for your web apps (Panos Astithas)

Next on my schedule was the talk by Panos Astithas on better security and privacy for web apps. Panos started by underlying that privacy and security are more important than ever, and people have began caring.

He started with encryption, pointing out the “good parts” of the last years: HTTP/2, TLS 1.3, HTTP Strict Transport Security, HTTP Public Key Pinning and most importantly Let’s Encrypt, which is backed by many companies, is free and tries to be transparent. He went on with the not so good parts: insecure algorithms, missing intermediate CA certificates (~6% of HTTPS requests on FF), mixed content (passive vs active) and insecure logins (~25%).

Panos then went on with the tools we have on Content security:

• For cookies we have useful directives, such as Expires and Max-Age, Secure and HttpOnly, Domain and Path. Also, experimental directives (supported in Firefox) such as __Secure- and __Host-.
• The Content Security Policy HTTP header can be used to limit the places our resources can come from.
• He also mentioned the experimental Web Crypto API
• Cross Origin Resource sharing and Subresource Integrity.
• For permissions on the web (for geolocation and notifications, push and WebRTC) he mentioned the Permissions API
• Best practices: avoid the load event, pre-prompt for context, prefer HTTPS, prompt in parent frames

He finished his talk with some points on Privacy:

• tracking erodes trust (users only trust the first party to track them, and not third parties), that Ad networks can serve malware, and that there is a differentiation between tracking protection versys ad blockers.
• Tracking mitigations: tracking scripts may fail to load, sendBeacon vs onBeforeUnload, anti-fingerprinting, lean data practices (https://www.mozilla.org/en-US/about/policy/lean-data/)
• Internet health report (https://internethealthreport.org/v01/)
• Observatory (https://observatory.mozilla.org/)

Numbers (Douglas Crockford)

The closing keynote was by the well known Douglas Crockford.

Conclusion

International IT conferences were not part of our life in Athens. Voxxed Days was a very pleasant addition to our lives. Not everything around it was perfect, but the conference was overall very successful. Lots of people (~450) attended and had a good time, exchanged ideas, learning interesting things. Now that Voxxed Days was held, we should support it so that it can come back next year with more talks and more attendees.

So, cheers to the team! I am looking forward to it.

The first presentation was by Petros Kaklamanis (Linkedin), whose talk was about the Cassandra database. Petros had presented the first part in December’s meetup (video here). He picked up pointing out that Cassandra offers lightweight transactionality in two ways: compare-and-set (CAS) operations and batch statements. He went on with data modeling, and explained that defining a schema that will accommodate our needs, one has to start by analysing what queries will needed. This step will help identify the partition and clustering columns. After the schema definition, Petros underlined the importance of testing out the schema with the development tools that come with Cassandra (i.e. CQLSH), and also deciding on the way to interact with Cassandra (a driver or 3rd party integration layer, such as Spring Data). You can find the slides here (slide 57 and on for this part of the presentation), the sample application here and watch the video:

The second presentation was by Spyros Anastasopoulos (Linkedin, Twitter), whose talk was about Reactive Extensions in Java. Spyros is a long-time member of JHUG and is known for his engaging presentations. He started by explaining why modern computing has moved away from sequential programming towards concurrent programming, and that Java provides only low level tools for that, which makes reasoning about the correctness of our programs difficult. Spyros continued with the history of Reactive Extensions and explained how they hide the complexity of concurrent programming with high level constructs, and allow us to focus on our business logic. The center of Reactive Extensions is Observable, which brings together the Observer pattern and asynchronous programming. In contrast to standard Java constructs (i.e. Future) which don’t protect us from mixing together concurrency and business code, Reactive Extensions help us write our code in a clear way. Spyros went on with some common methods (create, flatMap, zip, take, amb, reduce) and also presented how he wrote a website scraper with the reactive magic. He concluded by listing the available implementations of Reactive Extensions in Java. You can find the slides here and watch the video:

At the end of the meetup, we gave away a copy of Cassandra: The Definitive Guide and a copy of Reactive Programming with RxJava.

See you all in the next meetup!

The first presentation was by Panagiotis Kapralos (Linkedin), whose talk was about Code Refactoring. The talk was entry level, but also useful for more experienced software engineers. Panos began with an example of a class with several opportunities for refactoring. Step by step, he refactored the class to a more maintainable piece of code, explaining what caught his eye each time. After this example, he went on with a set of common Refactorings (i.e. extract method, extract variable, consolidate duplicate conditional fragments) and what each means. Then he presented the not-so-obvious relation between refactoring and economics (which you can use to convince your manager you are not losing your time and his budget). Furthermore, he explained that a software engineer should regard refactoring as an opportunity and not a chore, and allocate time for it. Finally, he concluded by reminding that there are cases where refactoring should not be considered (i.e. when the end-of-life of the software is close). You can find the slides here and watch the video:

The second presentation was by George Kalfopoulos, who talked about Microbenchmarking with JMH, the Java Microbenchmark Harness. George started by explaining why benchmarking is not straightforward because of optimisations that take place in several layers (JDK, JVM, OS, Hardware). These optimisations can give you a false picture of how performant your software is. JMH helps you profile your code with useful metrics (i.e. throughput, average time) in different setups (i.e. single thread, parallel threads) and even JVM initialisation arguments. It takes care of excluding setup tasks and warm-up executions in the results, so that you have a better picture of how your code behaved while actually executing. George reminded that even JMH results should be taken with a grain of salt, because even a minor Java update may have a drastic effect on the produced numbers. You can find the slides here and watch the video:

In the end of the meetup, we gave away 2 copies of Java testing with Spock, by our own Kostis Kapelonis, and 2 free invitations for Voxxed Days Athens (May 18th – 20th 2017), which were kindly offered to JHUG by the conference organizers.

The first presentation was by my two co-workers, Nikos Dimos (Linkedin) and Rui Miguel Forte (Linkedin), who lead the Sourcing and Data Science teams respectively. Nikos talked about how the Sourcing team at Workable moved to Microservices architecture. He started with some basics, like defining what a monolith architecture and a microservice architecture are, and when each is a good fit (no silver bullet here either). He then drilled down to specific problems that kept cropping up with our old, monolithic architecture, and how they were mitigated by moving to Microservices. He showed how the new architecture relies on Rabbit MQ for inter-service communication, and employs tools like Apache Kafka to keep track of what service invocations took place and how. Key takeaways were understanding the tradeoffs when selecting between the Monolith and Microservices, how testing becomes easier and the fact that when moving to a Microservice architecture you need to embrace working asynchronously and make the most out of it. You can find the slides here and watch the video below:

Miguel (who is also the leader of the Data Science Athens group) carried on with an introduction on what Data Science is and the kind of problems we use it to solve, and went on with tools that his team frequently uses. The first tool is Apache Tika, a toolkit that extracts text and metadata from multiple file types. He also demoed (code available to play with on Github - branch develop) some more advanced tasks, such as image and links extraction. The presentation went on with PMML (Predictive Model Markup Language). A common problem our Data Science team has is that predictive models are easier to develop and train in languages like Python or R, but then those models need to be ported to Java for production. PMML is a - surprisingly old - exchange format allows us to transfer (export and re-import) the models from from one platform to the other, so that the model does not need to be developed and trained from scratch (which may take days, depending on the model). You can find the slides here.

The second presentation was by Marios Kogias (Linkedin), who talked about Code Maintainability. The talk was based on the book Building Maintainable Software by Joost Visser and others. As Marios pointed out, the methodology promoted by the book is not written in blood, but is essentially a set of best practices which can make our life easier in the long run. Essentially, the talk highlighted three simple day-to-day habits, like keeping methods at most 15 LoC, duplicating code wisely, and keeping method signatures simple using encapsulation. Marios also described which refactoring operations (most IDEs have them out of the box) are appropriate for each case. Finally, the presentation mentioned code analysis tools like Better Code Hub, PMD and the fantastic SonarQube. The presentation is also appropriate for junior devs. You can find the slides here and watch the video below:

The third presentation was by Thomas Pliakas (Linkedin), who talked about Garbage Collection performance tuning. We all know that GC is something taking place in the background, and we don’t worry about it often. When we do though, it is useful that we know at least which are the basic Garbage Collectors, what algorithms they use and the phases of their execution. Thomas began with the presentation of the sub-regions of what we see from the outside as Java Heap (Eden, Tenured, Permgen), and why GC revolves around the age of objects. He then went on to explain what Minor, Major and Full GC are, as well as available Garbage Collectors. Thomas explained factors to take into account before tuning GC (latency, throughput, capacity) and continued with tunings for the G1, which is going to become the default. The presentation finished with references which are a very good starting point for people diving into the interesting world of GC. You can find the slides here.

The first presentation was by Kostas Saidis (twitter, linkedin), who talked about Gradle. The presentation is entry level, so it is a good starting point for someone looking into what build systems exist today for Java projects. Kostas showed how Gradle builds upon lessons learned by pre-existing build systems (conversion-over-configuration, dependency management) and combines them with customizability, to enable custom and maintainable builds. Gradle takes full advantage of Groovy and its syntactic sugar, and offers a concise DSL, which makes build files less verbose and easy on the eye. You can find the slides here and watch the video below.

The second presentation was by my friend Kostis Kapelonis (web, twitter, linkedin), who talked about Spock. Kostis is very knowlegeable about Spock, he has (literally) written a book on the subject. The presentation showed how Spock can be used to test Java programs, and how it can deal with cases where Java traditional testing tools (JUnit, TestNG, Mockito) produce non-elegant test cases. Spock helps the developer write structured test cases with clearly separated steps (given, when, then), and avoid common pitfalls of assertions intermingled with setup method calls. Also, the use of plain English in Spock allows the generation of readable reports, and facilitates communication with non-developer members of the team. You can find the slides here and watch the video below:

The meetup was followed by pizzas, which were kindly offered by Playventure.