Modern SQL

Markus Winand teaches efficient SQL. He covers both aspects: the development time to accomplish a task using SQL as well as the runtime of the final solution. He also published the book “SQL Performance Explained“ and is currently working on his next book, which is being published on an ongoing basis at http://modern-sql.com/

A lot has changed since SQL-92. This session goes through some SQL features introduced by later standards, shows which databases support them and demos how these features solve every day problems more easily. Topics covered include: processing graphs, more powerful aggregations, ranking and more.
As a matter of fact, most textbooks, websites, and even universities teach SQL as it was 25 years ago (SQL-92). In the meantime, SQL evolved into a more modern data processing language that is not limited to relational algebra anymore. Although many databases support more modern SQL for years, hardly any developer knows how the new features can be used to solve common problems. This session is, therefore, not limited to explaining SQL features but also compares the SQL-92 solution to common problems to the more modern solution to make the benefit directly visible. Finally, the session also shows how long these features are supported by various databases so that you immediately know whether the shown solution works in your environment or not.

Distributed Tracing – get a grasp on your production

Nakul Mishra is a Consultant around JVM and related technologies. Prefer automation over manual configurations. Keen on continuous delivery, unit testing and code simplicity. Interested in developing applications that requires creativity, imagination, fast-learning and zest for putting theory into code. Previous experience: Voxxed days bristol, BuildStuffLT, JavaDayKiev, TopConfLinz, etc. for full details please refer http://lanyrd.com/profile/nklmish/ Slideshare http://www.slideshare.net/nklmish.

Large scale distributed systems are complex; they consist of hundreds of services, developed by various teams using polyglot stack.
When a single request travels in such a system, it might end up touching hundreds of services deployed across many machines.
What happens when suddenly your system starts to get slower? How can you reason about performance issues? How can you troubleshoot such problems?
We can go to our best engineers but due to the distributed responsibility spread over different teams, they might not be able to guess or pinpoint the exact cause of performance issue.
Processing the sheer volume of log files containing the overwhelming amount of information requires a lot of time and deducing anything meaningful that could quickly help us to diagnose the latency issue is rather hard.
Can’t metrics help? They can show us that we have some latency issues but can’t tell what is the cause and depending on how we aggregate might even mislead us.
What we need is a distributed tracing system. In this talk, we will take a look on OpenZipkin, which is based on Dapper, see how it can help us to pin point latency problems in our production. Discuss why 99th percentile matters for latency and build a demo application using polyglot stack (Java, Spring cloud Sleuth & GO) to see OpenZipkin in action.

Lambda Core HardCore

Jarek Ratajski is a Java Developer since 1999. I love programming since my first line of code I did on the C64 in Basic. I have 15 Years experience developing JEE software working for various companies and projects. Currently I am working for CSS Versicherung in Luzern. I am Java developer during the days and Scala/ScalaJS at nights. I like to present my experience in public – so far speaked at conferences such as Devoxx, Voxxed Days, JUGs, Geecon, JdayLviv etc. I like to do shows – presenting the things just as they work – with live coding, demos and hacking.

What does it mean… Lambda? The talk will be about story behind this term, from a little bit more scientific point of view. Church Lambda calculus, Entscheidungsproblem and incompleteness theorem. Almost all of that will be presented in Java – in the language that you understand.

Since Java 8 – so called lambda expressions can be used by Java developers. But what does it mean… Lambda? The talk will be about story behind this term, from a little bit more scientific point of view. Church Lambda calculus, Entscheidungsproblem and incompleteness theorem. Almost all of that will be presented in Java – in the language that you understand. And of course you can later impress your friends with some impressive math tricks. There are going to be shown some very crazy code pieces such as perfectly unusable implementation of boolean (based on lambda expressions). Come and see what purely functional really means.

Migrating to Microservice Databases: From Relational Monolith to Distributed Data

Edson Yanaga, Red Hat’s Director of Developer Experience, is a Java Champion and a Microsoft MVP. He is also a published author and a frequent speaker at international conferences, discussing Java, Microservices, Cloud Computing, DevOps, and Software Craftsmanship. Yanaga considers himself a software craftsman, and is convinced that we all can create a better world for people with better software. His life’s purpose is to deliver and help developers worldwide to deliver better software faster and safely – and he can even call that a job! http://www.yanaga.me

The question that every enterprise developer asks when confronted with Microservices is: what about my database? Come to this session to see how zero downtime migrations and different data integrations strategies can help you to break your monolithic relational database!

In a distributed system with multiple moving parts, which is the case of Microservices, we can’t allow that a single complement downtime breaks down the entire system. Dealing with stateless code is easy, but it gets much harder when we have to deal with persistent state. In this scenario, zero downtime migrations are paramount to guarantee integrity and consistency. Within all the Microservices characteristics, undoubtedly the one that creates more perplexity is the “one database per Microservice”. However, very few teams have the privilege of starting something from scratch: most of the times they have a legacy database that will survive any new implementation. In legacy systems you traditionally have a model that adopts transactions, strong consistency, and CRUD. In order to guarantee integrity and consistency with zero downtime, we must reassess some of these concepts. In this talk we’ll discuss strong and eventual consistency, CRUD and CQRS, Event Sourcing, and how these techniq…

ThinkAsync in Java 8

Dmitry Alexandrov is a passionate Java developer with 10+ years experience, BGJUG co-lead, big fan of Java EE, blogger, speaker. Speaker at: – Lambdas and default methods in Java 8, Java2Days Sofia, Bulgaria, 2013, slides: on site; – JavaScript on JVM: Acquaintance with Nashorn and Avatar.js, Java2Days Sofia, Bulgaria, 2014, slides: on site; – Java(Script) on JVM, Joker Conference St. Petersburg, Russia, 2015, slides: http://www.slideshare.net/dalexandrov/javascript-on-jvm-54679017; – Seminars, Hackathons, Adopt OpenJDK, Big Conference: The Story of Our JUG [BOF3150], JavaOne, San Francisco, USA, 2015 – Nashorn extended session, JUG.ru, St. Petersburg, Russia, 2016; – JBatch.. or not such a big data, Joker Conference, St. Petersburg, Russia, 2016, slides: http://www.slideshare.net/dalexandrov/jbatch-67221346 Leaded several lectures and hand-ons regarding JDK development and Lambdas in the local JUG. http://www.tomitribe.com/blog/2016/03/developing-batch-applications-with-tomee/ https://blogs.oracle.com/nashorn/entry/using_nashorn_with_intellij

The parallel infrastructure of Java and JVM itself has evolved greatly in 21 years. It has made it though raw threads, execution pools, concurrency package extensions, as well as other frameworks like actors that found spread in different JVM languages like Scala for example. But developing a parallel/concurrent program is not a trivial task and not only in Java. In order to simplify the approach to concurrent programming and unlock the multicore performance the reactive paradigm was introduced adopting the functional programming style. The CompletableFuture coming out of the box in Java8 opens the full potential of this approach. In the session we will see a brief evolution of the concurrency in java and describe how we got to CompletableFuture, explore it, and see how we could use it.

Mutation testing

Rafal Leszko is a Java developer at Google. Trainer and speaker at international conferences (Devoxx Morocco, Voxxed Days Thessaloniki). In the past he worked in a number of companies and scientific organizations: CERN, AGH University, Luxoft and more. His roles varied from a team lead, trainer, PhD researcher to developer, but one thing remains unchanged: he loves to be as active as possible, looks for challenges and has a lot of creative ideas (he was the one to introduce the Luxoft Lunch & Learn initiative).

How well tested is your system? How do you measure it? Code coverage can give you the answer, however can we trust our unit tests? Trust me or not, but I used to work for the investment banking industry in a big project where a lot of unit tests had no assertions (!). And yes… the coverage was very high.

Mutation testing is a method to check the quality of your unit tests and show more reasonable code coverage reports. In this session I will describe the idea of mutation testing and show a live example with the use of PIT Mutation Testing framework.

Visualizing Bintray operations, with the Firehose Event API and the ELK stack, on Docker

Michael Hüttermann is system architect and delivery engineer and a leading subject matter expert for Continuous Delivery, DevOps and SCM/ALM. He has written a couple of books including the first ones on DevOps (“DevOps for Developers”, Apress, 2012) and Agile ALM (“Agile ALM”, Manning, 2011). He was recognized to be a Oracle Java Champion in 2006. More information: http://huettermann.net.

This interactive talk integrates a best-of-breed tool chain including – Bintray, for managing your binaries – ELK, for gathering and visualizing metrics – Jenkins 2, for defining and running Continuous Delivery pipelines – Docker, for running and managing apps in an isolated fashion. The demo goes through the nuts and bolts and focuses on a developers’ perspective.

Pain of growing up, and moving to large scale

Vladimir Dejanovic is the founder and leader of AmsterdamJUG. Software architect and Team Lead with long experience in developing high performance software in multiple programming languages and technologies with high load traffic. Always interested in cool new stuff, Free and Open Source software Speaker at JavaOne, Devoxx BE and Devoxx US

Although software is deployed for a long time now, not everyone is exposed to it. In big companies developers usually were not involved, while in small companies in most cases scale wasn’t big, so deploying also wasn’t thought so much as a big of a deal. With move to DevOps and having successful “startups” landscape is changing a lot, however a lot of companies and engineers are still struggling with deploying software, especially on a large scale were rules of the game are on completely different level. In case of transition from small to big successful company deployment process can easily be one of the key factors deciding if company will make it or not. Although tools like Kubernetis and similar are designed to solve lot of this problem,in most cases from my experience companies are still not using them in amount they should, and are still relying on “old” techniques for deploying software into production. Also very often articles and blog posts usually point out only good part…

You built your product, put it on server, and it flew like a rocket. Now you need to move to larger scale, but how ? How to go from here ? Deploying software isn’t always the first thing on developers mind, while they work on some software. However as you start moving to larger scale your deployment process can make you or break you. It comes with pain and cruel truth of how good your deployment process really is. Join me while I address pain, issue and problems of deploying software on Large Scale. I will talk about some known approaches and their pro’s and con’s. Also I will share some tips and tricks into making deploying software on large scale easier. All of this come from my personal experience while working on this type of systems.

High-Performance Hibernate

Vlad Mihalcea is a Hibernate Developer Advocate. He spoke at Devoxx France, Voxxed Days Bucharest, JavaZone. This is a list of presentations that he’s been giving in 2016: https://vladmihalcea.com/presentations/

Hibernate is the most popular JPA provider and knowing its inner-workings can make the difference between a high-performance enterprise application and one that barely crawls. This presentation goes through the most common performance bottlenecks issues like exotic mappings, too much flushing, inappropriate queries, JDBC batch updates misuse, and suboptimal result set fetching. Aside from common anti-patterns, I will also present some very useful Hibernate features like the enhanced identifier generators, caching strategies, and bytecode enhancements.