Powering Interactive Data Analysis with Google BigQuery

Márton  is a romanian Google Developer Expert (GDE) senior software architect at REEA/Tirgu Mures who led the implementation of complex and distributed systems serving millions of users for companies like LogoMix, WaterSmart, Ausschreibungsdienste and many more. Among the top romanian StackOverflow users with over 103k reputation points. Active contributor for open-source solutions like Beanstalkd admin console, and Riak admin interface. Expert in Databases and Search system like Google BigQuery, Elasticsearch, Sphinx.

Every scientist who needs big data analytics to save millions of lives should have that power. Complex interactive Big Data analytics solutions require massive architecture, and Know-How to build a fast real-time computing system.BigQuery solves this problem by enabling super-fast, SQL-like queries against petabytes of data using the processing power of Google’s infrastructure. We will cover its core features, working with BigQuery, streaming inserts, User Defined Functions in Javascript, and several use cases for everyday developer: funnel analytics, behavioral analytics, exploring unstructured data.

Clean Lambdas & Streams in Java 8

Victor Rentea is a Java Craftsman.Sr. Engineer & Technical Lead at IBM Romania. Independent Trainer & Coach.

I worked hard on backend systems over the last 10 years, solving technical challenges of a broad range of enterprise Java applications as a developer, lead and consultant. 4 years ago, after I had devoured Uncle Bob’s Clean Code book, I joined the ‘coding craftsmanship’ move.

Of course, soon after I started preaching about it as an independent trainer/coach. This Clean Code, TDD, Pair Programming stuff it’s just too fun too keep it for oneself. For hundreds of days I’ve spread the word to more than 1000 trainees in all kinds of settings (even faculty lectures), usually bundled together with other training modules that I’ve gradually developed, such as Spring, JavaEE, JPA, Design Patterns, and the like. You can find the entire curricula on my website.
My extensive experience as a trainer allowed me to refine a very entertaining presentation style, spiced with jokes, non-IT-world analogies, and examples that is able to make any developer profile understand even the most advanced design discussions.
Recently however, I realized how much I enjoy meeting smarter people, so I’ve started talking at international conferences such as Devoxx MA and VoxxedDays Belgrade and Bucharest, IMWorld Bucharest.

Are you using Lambdas & Streams in your core business logic? Then you might be having this strange feeling that it’s not Java anymore. That at times it’s cryptic, barely readable.. Come and see how to keep your code clean while making best use of Java8. Bring a laptop or Pair with someone.

Everybody’s using Java8 Lambdas and Streams nowadays. So then, why shouldn’t you use them as much as you can in your enterprise application code? It’s absurd to keep away from these powerful features, but at some point you may start having some weird feeling about them. And then you get to your first code review, and you start wondering… What happened with the Clean Code principles when you jumped on Lambdas? How should you use Lambdas in order to keep a clean maintainable codebase – the ultimate goal of any large enterprise application?

During this workshop, I’ll mix my key points/slides with two hands-on exercises: 1. The basics of Lambdas/Streams, then 2. A tougher problem distilled from a real-world scenario. Note: You can join us anytime later during the workshop, if you want to skip to the more advanced topics.

I’ll introduce the Lambda/Streams features roughly from simple to the more mind-stretching following an order inferred from a little study I’m running “Clean Lambdas”. This way, you’ll see that you could adopt these features gradually, to allow your developers to learn the functional thinking bit-by-bit. One particular interesting topic we’ll talk about is how/where to implement predicates, and I bet you won’t imagine all the possibilities.

At the end, we’ll wrap up trying to sketch how the Clean Code principles change when using Lambdas. More specifically, we’ll brainstorm some guidelines you should keep in mind when playing with the lightsaber (oups,I mean.. Lambdas) in your enterprise application code. This session will leave you with a lot of take-aways: hints, tips, warnings, useful even if you don’t have a lot of prior hands-on experience with Lamdas.

Prerequisites: minimum 3-6 months prior Java 8 experience / or a Spartan. Preparation: Personal laptop with Eclipse/IntelliJ on JDK8 installed. Organization: Workshop. I’ll give you the tasks one by one and gradually build the solution together. I would like the audience will Pair Program as much as possible, switching the writer every ~7 minutes. PS: This workshop is based on a training that I delivered a lot of times.

Twelve-factor cloud app in action

Ana-Maria Mihălceanu is a fan of Java software craftmanship and a constant adopter of challenging development scenarios; some of her experiments are available on Dzone. Recently, her technical passion for cloud application development has been badged with IBM Certified Application Developer – Cloud Platform v1; and she would like to share with the audience her experience and experiments. Her other passions? The usual knowledge hunt through reading and growing fashion skills through shopping.

When approaching on premise application development there is an entire literature on “how to do it right under any conditions”. But what’s the blueprint for a cloud app? I will discuss the answer by showing how each of the 12 factors influences a cloud-ready app, with Java&NodeJs demos.

Why should you do something different when your application is destined to be a SaaS or to exist within a PaaS? Because this kind of application represents a solution composed of individually cooperating services that need coordination (usually achieved through DevOps Pipeline). The 12-factor app methodology (https://12factor.net) represents a best practice when comes to cloud application development and this presentation will detail and demonstrate each principle. You will see how you can easilly make a Java or NodeJs web application to be cloud-ready by following each of the 12 principles.

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.