Every millisecond counts

Ignorance is bliss, or so they say. But is it really when the things we measure have nothing to do with what our clients observe? During this talk i will try to answer the questions why every millisecond is so precious in distributed systems and how to avoid being fooled by tools that were supposed to help us.

Pro-tips for Building a Great Tech Culture

In the last eight years, the leaders at Gilt Tech have sought to decentralise decision making, empower teams, create the conditions for innovation, get things done, and, always, keep it fun. That all sounds great, but really, is that something you can replicate in your organisation? If so, how? In this talk, I’m going to talk about some of the concrete things we do that you might adopt to help grow your own culture. And, I’m gonna share where I’ve landed some of the magic variables: team size, department size, and other golden ratios.

Scaling microservices at Gilt

The ecommerce company Gilt.com (founded 2007) started out as a monolithic Rails application built and maintained by just a handful of engineers. Gilt has since become a global e-commerce destination built upon a sophisticated Scala/Java micro-services architecture strong enough to handle the company’s intense traffic spikes--generated by millions of the company’s members simultaneously visiting the site at noon each day. The concept of micro-services--smaller, lighter, faster components delivered swiftly to production--has resolved many of the growing pains we experienced evolving from “just a handful of engineers” into an engineering team of +100. However, microservices bring their own set of tradeoffs. In this talk I'll discuss the evolution of Gilt's micro-service architecture, and the challenges we now face today. How do you move a large Micro-Service deployment to the cloud? How does micro-services affect ownership and software quality? Why do API’s really matter? How can the micro-service approach applied to front-end web applications? And, why has our adoption of micro-services lead us to the conclusion that all our teams should prefer to deploy and test software in production?

IOT, timeseries and prediction with Android, Cassandra and Spark

IOT has a massive potential and its impact in our daily life is important. Here is an exemple of using a connected object and analysing its data: we'll see how to collect data using the accelerometer sensor of your smartphone. Then, we'll store it in Cassandra as a Timeseries model. Finally, we'll analyse those data and predict the activity with Spark. We will see a live demo on stage to show this solution working in realtime.

jcmd, one tool to rule them all

TBD

Inspiring teenagers to code

In fall 2015 we - a team of engineers in several IT companies - launched DressCode (https://events.withgoogle.com/dresscode/), an online program that aims at teaching Polish girls to code. And I mean code, for real - not solve puzzles with Blockly, but design CSS stylesheets, implement sorting algorithms, or create interactive animations. We were pioneers in teaching kids online, rather than in class. We were the first in Poland to target kids as young as 10 y.o. And we succeeded. The purpose of this talk is to tell you about our motivation, to share our experience, and to invite you to help us inspire more boys & girls across Poland to learn to code.

Flux - new/old approach to building frontend

We all know that in Javascript world everything is changing at the speed of light with bunch of new libraries, frameworks, and build tools coming out almost every day. At first, I imagined React and Flux as another set of JS toys. However, after working quite a bit with React it turned out to be completely different than I initially thought. It is only a VIEW layer. As opposed to frameworks like AngularJS, it does not imply neither structure nor architecture of our code. Nowadays applications become larger, more complicated and grow faster than ever. As a result, we need nicely decoupled, more maintainable codebase. This is where Flux comes in handy. It encourages one-way data binding, which simplifies reasoning about application flow a lot and removes spaghetti dependencies between components. So is MVC the easy approach and Flux the simple one? During my talk I will show live-coded examples of React with Flux application. I will also demonstrate how to structure out codebase and connect all elements.

Java and Docker, a good idea?

Containers are the latest hype. I think it goes without saying that Docker for the development environment is a good thing but what about running our production Java applications inside a container? The first question is why? It is already common practise to build self contained executable jars that only depend on a JRE being installed, what does a container actually give a pure Java shop? At Sky we've gone down this route for one main reason: Utilisation. We used to run single purpose VMs, which for production still make sense but for our countless test environments it is prohibitively expensive and even with IaaS it is still too slow to provision new environments and bootstrap new applications. This talk will be focussing on the downsides / lessons learned from running JVMs inside containers. We'll cover:
- A brief summary of the benefits of running a Java application inside a container
- An in depth view of the downsides and complexities of running a Java application inside a container.
- Tuning memory limits, the heap is the easy bit: a limit needs to be made up of Heap, Native memory, Metaspace, Stacks to avoid being OOM killed
- Demo of tracking native memory with jcmd
- What tools should you include in your container for debugging / analysis e.g the Swiss Java Tools https://github.com/aragozin/jvm-tools
- Tuning thread numbers for various frameworks/servers e.g. Jetty, Tomcat, Ratpack, GC
- Motivation for moving to non-blocking frameworks like Ratpack to avoid the cost of a thread per request

Beyond lambdas - the aftermath

As Java developers we are used to having rich ecosystems of libraries and tools that make our lives easier. As of the release of Java 8, we finally got our hands on building blocks like lambdas, optionals, and streams. All sorts of tools that help us write more concise code. But now, when the honeymoon is over, are there any downsides to Java 8 or is it a silver bullet? Are there any new anti-patterns emerging? Or subtle bugs caused by the new style of programming? Have there been any lessons learned? Are there any best practices? If you are interested in learning about the challenges encountered when moving over to a functional style of Java programming, what code constructs to avoid, and best practices to use, well then this session is for you.

jQAssistant - Verify Your Design And Architecture

Static code analysis tools provide very fast and valuable feedback on potential bugs or violations of coding guidelines. The latter often include rules on the level of design and architecture but tools often operate on a lower level of abstraction as needed, i.e. language elements like Java packages or classes. Furthermore it is often quite difficult to express individual rules which are only valid for a certain project. The talk presents the approach behind the open source software analytics tool jQAssistant: It can be plugged into the build process and allows scanning of relevant structural information like Java packages, classes and Maven descriptors into a Neo4j graph database and applying rules to them. These rules are written as developer documentation in Asciidoc containing queries which may enrich the data by common technical or user defined concepts from the design or architecture language of the project, e.g. Entity, Repository, Module, Layer etc. Based on these abstractions constraints can be expressed like 'all JPA entities must be located in packages named model' or 'service layers must only depend on repositories but not on UI controllers'.

Caught in the Act: Kotlin Bytecode Generation and Runtime Performance

In this talk, we'll dive into the details of how various language features supported by Kotlin are translated to Java bytecode. We'll use the JMH microbenchmarking tool to study the relative performance of various constructs and to understand how we can ensure top performance of the Kotlin code that we write.

Apache Zeppelin for your Big Data ecosystem

If you are interested in Big Data, you surely have heard about Spark, but do you know Apache Zeppelin ? Do you know that it is possible to draw out beautiful graph using an user-friendly interface out of your Spark RDD ? In this session, I will introduce Zeppelin by live coding example and highlight its modular architecture which allows you to plug-in any interpreter for the back-end of your choice.

Functions & Materialized Views in Cassandra 3.0

Cassandra is evolving at a very fast pace and keeps introducing new features that close the gap with traditional SQL world, but they are always designed with a distributed approach in mind. First we'll throw an eye at the recent user-defined functions and show how they can improve your application performance and enrich your analytics use-cases. Next, a tour on the materialized views, a major improvement that drastically changes the way people model data in Cassandra and makes developers' life easier!

Building HATEOAS into your API

This talk focuses on implementing HATEOAS into a Spring (and Spring Boot) REST API. The first part of the presentation introduces the HATEOAS constraint, the WHY and goes over practical examples of how a Hypermedia driven API is useful from the point of view of a Client of the API. The second part is focused on an actual implementation with Spring Hateoas and Spring Data REST.

Distributed Java Streams with Infinispan

Infinispan is a distributed in-memory key/value data store capable accelerating data processing using Hadoop, Spark and home-grown Map/Reduce APIs. Starting with Infinispan 8, you can now also use the Java 8 Stream API to process, transform and analyse the data stored in the grid, without burdening the architecture with external platforms. Processing can be applied to keys and/or values and it uses Infinispan's data partitioning logic to distribute operations to nodes where data lives so that they can be executed locally. In this talk you'll learn about this new extension to Java 8's Stream class to process data in Infinispan and how it compares with existing APIs.

What's Oracle Doing With JavaScript?!

At JavaOne/OpenWorld 2015, Oracle announced that its own internal developers have been using JavaScript for several years to develop Cloud applications and that a toolkit built up out of open source solutions is being made available for general use. Data in the Cloud needs to be visualized in interesting and understandable ways, which is the key reason for the existence of Oracle JET (Oracle JavaScript Extension Toolkit). JET provides JQuery UI components that make available graphs, charts, and similar components, on top of Require.js for modularity, Knockout.js for data binding, and more. The entire toolkit has been open sourced. Come to this code-driven session to find out what Oracle is doing with JavaScript and how you can leverage these open source solutions too!

PrivateEye

In this talk we will sleuth into what is privateeye. We will turn our detective skills on how your application actually work and we will do it using nothing but a REPL. You know how to code, let's code through a murder mystery together.

A Decade of DDD, CQRS, Event Sourcing

...

Agile vs the fear of the white blank page

Imagine this: the biggest bank in Singapore. Huge waterfall system. Extremely vertical structure. Projects that take years to deliver. And you arrive there, with your laptop and a product to integrate with their systems. You mention Agile and Continuous Delivery and managers look at you with skepticism. The rest of the team you have to work with tilt their heads a bit with a question in their eyes: Agile? So you take a deep breath, take out your laptop, your cards, a few sharpies and get ready to start. Let the game begin! The talk starts with the fear of the blank white page. Given a group of people that ranges from “I once read a blog post about Agile” to “Agile what?”, how does one get started? First step: introduce concepts like Continuous Delivery, Pair Programming, iterations, cross-functional team, and so on. Once the team has been briefed on the basics of Agile, it’s time to talk about the tools. Although this decision had been made for us this particular case, there are plenty of tools in the market that can be used, and the challenge is to introduce them to the team, show how useful they can be, and make use of them. After the tools, it’s time for the rituals. Stand up, planning, sprint review and retrospective. Taking the role of Scrum Master during the learning period, drive all of these meetings with the aid of the team. Just one brief example to show the complexity of this step: time-tracking. It is never easy to convert man-days into complexity. Once the machine is running, it’s time to oil the gears. There’s always friction in change, and very few things runs smoothly from the start. But Agile is all about adapting itself to its users needs. And during the oiling, little by little, start giving responsibilities to the team members while slowly removing them from yourself. Start rotating the role of Scrum Master during the stand up; let the team drive the retrospectives and argue about what improvements should be done; let other team members decide on the complexity of the stories, and whether they should be split into smaller tasks. And finally, take a step back and look at the team running on its own without needing your help anymore. That feeling of satisfaction is the reward of a job well done.

Reactive Database Mapping with Scala and Slick

Are you familiar with Object-Relational Mapping? Let's get out of the comfort zone and meet a completely different approach to mapping database tables to domain objects using Scala's Slick library during this no-fluff-just-code live-coding session. Slick does what some call FRM, i.e. Functional-Relational Mapping (as opposed to ORM), which basically lets you access your relational database as if it was a Scala collection. And since reactive is THE way to go nowadays, we' re going to be no different.

JVM dive for mere mortals

For developers using Java on a daily basis, JVM is a pretty important component - it runs our software. But it is usually treated like a magic box, which takes code in and produces business features. Have you ever thought about what you are missing with such an approach? During my talk I'll cover some of the JVM internals which should not be avoided even during regular Java development. We'll discuss real differences between primitives and their wrappers, talk about the cost of using lambdas and streams, see what really gets erased in the type erasure process and what we can gain by removing stacktrace from our business exceptions.

Learning modern JavaScript without node.js

People have mixed feelings about JavaScript (me included). On one hand, JavaScript is easy to bash - you know all the PHP joke, ain't you; on the other - whatever can be written in JavaScript, will be written (Atwood Law, 2007). So, no matter what you do know - getting familiar with JavaScript is not a question why but when. And if you haven't tried it yet - this is a session for you. Whenever you try to start - with which ever framework / library - it usually starts with an infamous `npm install {library-to-try}` and quickly new things come into play: gulp, grunt etc. It's like in Java, everything starts with Maven / Gradle dependency. However, when you start fresh - these all just make the learning curve steeper. In this session I'll make a digestible walk through a set of JavaScript tools, technologies, conventions, which can make it easy for you (a backend engineer) get on the JavaScript bandwagon. Obviously, there will be a flavour of node, npm, build tools in it - but not in the first place. They will come kind of naturally.

Composing Music in the Cloud

Leveraging the power of the cloud and microservices, this session demonstrates how music can be analyzed and composed in real-time to augment musical performance with a futuristic instrument. This session contains an introduction to relevant cloud technologies, and an introduction to music theory and composition. This session also has musical demonstrations and code snippets scattered throughout. Enabling technologies demonstrated in this session include Spring Boot and Cloud Foundry.

Navigating ALL the Knowledge

This session demonstrates how all of the world’s knowledge may be semantically navigated by a web application that utilizes the facilities of Wikimedia.org projects (e.g. Wikipedia and Wikidata). The web application was created specifically for this session, and demonstrates technologies that include Java, HTML5, Spring Data, Neo4j, Spring Boot, Spring Cloud, and Cloud Foundry. The application runs in the cloud and contains/leverages several microservices. We'll walk through lots of code during this session.

Rainbow, ponies and Equestria

And the water from the oceans occurred, and of these voracious beasts, hostile to man, and the fourth rider to emerge ... no, this time there will be a JVM (I hear it hum in the room). You all probably know the actor model, algebraic data types, and you go out beyond the illusion that the inheritance is the only type of polymorphism. What if we add to this 'object capabilties model' and type system, which will provide you with secure access to memory, without the need for locks and atomic operations? Welcome to the world Pony, still fledgling new programming language. No one ever promised so much more, so why not try? So how about compiler so clever that it detects you have a data race in your code, and because he can, you don't need locks, semaphores and synchronized in your code? How about language where actor is a keyword? I will show you syntax and type system, several working or not examples, a little bit of internals of Pony network stack, automatic memory management, and compiler based on LLVM'

Beyond NoSQL – Go Events / DROP DATABASE

Are You satisfied with JPA and Hibernate? Do You think there is nothing better than classic three tier architecture where all data is processed in so called database? Or maybe... it is just a waste of time and money and You just do not know the alternatives... This is not going to be about NoSQL... This is about making one step more – No DB. There will be event sourcing presented and Prevayler as persistence framework. There will be shown how to utilize all the power of the JVM and how fun programming of business applications can can be (again – hurray!). Finally, there will be discussed problems, limitations and possible further alternatives in NoDB area.

Lisp in the machine

TBD

Hands-on Apache NiFi

While Apache NiFi provides out-of-the-box support to build powerful and scalable directed graphs of data routing, transformation, and system mediation logic, some times 'the world is not enough'. Roll up your sleeves and put your hands on the keyboard as this hands-on talk structured as a set of quick tutorials will take you through a journey of developing in NiFi. It will cover extension points such as Processor, ControllerService, ReportingTasks as well as other less known areas of NiFi internals, sharing some tips and tricks along the way.

REST no more use an actor (and Lego and Raspberry)

Last year we started a new Internet of Things project: The Internet of (Lego) Trains. In our normal jobs we use languages like Java and Scala to build applications for large organizations running on big servers. We wanted to find out if we could use the same languages and tools on IoT hardware. We also wanted to investigate whether or not (remote) actors could replace REST endpoints in our applications. We used Lego trains and Raspberry Pi’s as a sample project. The Lego trains are equipped with a Raspberry Pi, camera, wireless dongle, infrared transmitter, speaker, RFID reader and battery pack. Next to that we have automated switch tracks and camera's again with the help of Raspberry Pi's. We also build some lightning effects with LEDs controlled by Particle Photon’s. On top of that we also automated a Lego ferris wheel. To control the trains and other parts we built an remote actor based application with Scala, Akka, Akka HTTP and AngularJS.

Twelve BDD Antipatterns - stories from the trenches about how NOT to do BDD

Behaviour Driven Development is a powerful collaboration technique that can empower teams to deliver higher value features to the business faster and more effectively. But although Behaviour Driven Development is based on a number of simple principles, it can go dramatically wrong in a myriad of different ways.In this talk John will discuss twelve BDD anti-patterns that you will frequently encounter in real-world BDD projects; these are anti-patterns that can dramatically reduce the effectiveness of BDD as a practice, and that can even cause BDD adoption to fail entirely!>/p>

Take me on a journey - the next step in automated testing practices

Every test tells a story, but some tell a better story than others. Every test illustrates a specific path through the system to achieve a specific goal, but some paths are clearer than others. Valuable tests are the ones that both tell a compelling story, and can stand the test of time, providing value not only as acceptance tests but also as living documentation and easily maintainable regression tests.Come on a journey of discovery to learn how to write clean, clear and maintainable tests using the Journey Pattern, an innovative new approach to writing automated acceptance tests that are easier to understand, easier to extend and easier to maintain. You will also witness a demonstration of these principles in action, with live coding of Serenity BDD automated tests.

The Bootiful Application

Alright, so maybe 'bootiful' won't ever work, but I tried, and it was worth it too because you're reading this. Spring Boot, the new convention-over-configuration centric framework from the Spring team at Pivotal, marries Spring's flexibility with conventional, common sense defaults to make application development not just fly, but pleasant! Spring Boot aims to make address the common functional and non-functional requirements that gate quickly moving to production.Join Spring developer advocate Josh Long for a look at what Spring Boot is, why it's turning heads, why you should consider it for your next application (REST, micro services, web, batch, big data, integration, whatever!) and how to get started.

Cloud Native Java

“It is not necessary to change. Survival is not mandatory.” -W. Edwards DemingWork takes time to flow through an organization and ultimately be deployed to production where it captures value. It’s critical to reduce time-to-production. Software - for many organizations and industries - is a competitive advantage.Organizations break their larger software ambitions into smaller, independently deployable, feature -centric batches of work - microservices. In order to reduce the round-trip between stations of work, organizations collapse or consolidate as much of them as possible and automate the rest; developers and operations beget “devops,” cloud-based services and platforms (like Cloud Foundry) automate operations work and break down the need for ITIL tickets and change management boards.But velocity, for velocity’s sake, is dangerous. Microservices invite architectural complexity that few are prepared to address. In this talk, we’ll look at how high performance organizations like Ticketmaster, Alibaba, and Netflix make short work of that complexity with Spring Boot and Spring Cloud.

Greenfield effect: Patterns for Effective Disaster Delivery

How does that happen that codebase so lean at start, end up as catastrophe? How is it that team of experienced professionals delivers a shameful ball of mud? What is the genesis of a programming disaster? This presentation is aimed at all project stakeholders to help them understand how does a software product grow, evolve and decay. We will identify behaviors and phenomena affecting people and code, that have negative or even disastrous effects on teams and products. Commonly we refer to those as 'anti-patterns'. It is essential, especially for those without diverse experience to be able to recognize when bad things happen, to be able to name them and act on them. After this talk you will understand how to be a good citizen of our industry and how to help this profession grow up of its state of a teenager. It is about time!

Creating Jenkins pipelines with groovy-based DSL

It's already 2016, you have automated build for your application, provisioning and creation of new environments, you have suite of automated tests, automated CD pipeline capable of deploying to production, basically you automate all the things, yet you create CI jobs manually. I bet you can automate that as well. In this live coding session I'll show you how to leverage Jenkins job-dsl plugin and its groovy-based DSL to create CI jobs and CD pipelines that you can put under version control and recreate in seconds. Along the way we'll also take a brief look at Jenkins internals and see some groovy goodies.

Make your data beautiful!

Combine R, Python and D3 to create powerful & interactive visualizations. Do you know bits of R or Python? Or maybe you’re the JS expert? Learn how to combine them to create beautiful and meaningful data visualizations.

Moving to G1GC

One of the quieter changes that will come with Java 9 is that Garbage First (G1GC) will replace the Parallel collector as the default garbage collector. These two collectors are as different as night in day. In this talk we’ll explore some of these differences and how they will potentially impact the throughput and responsiveness of your application. In addition, we’ll look at some of the current sore points in the G1GC as well as some tuning strategies to help you cope with them.

What we can learn from Smalltalk

Programming languages have always been about offer developers better metaphors to express abstractions. It is without a doubt that Object Orientation has been hugely successful and the language that best supported that metaphor was Smalltalk. Though work started on Smalltalk in 1969, to this day, Smalltalk remains as the model language for supporting OO. In this lighting talk we’ll look at a short history of Smalltalk, it’s influence on Java and what we can still learn from this exceptional body of work.

Akka Streams made Live (what they're all about)

In this talk we'll have a deeper look into Akka Streams (the implementation) and Reactive Streams (the standard). The term streams has been recently pretty overloaded, so we'll disambiguate what streams are and what they aren't. We'll dive into a number of real life scenarios where applying back-pressure helps to keep your systems fast and healthy at the same time. We'll mostly focus on the Akka Streams implementation, but the general principles apply to any kind of asynchronous programming.

Beat Aliens with Akka Cluster

Does anyone remember the game “Missile Command” on Atari? I bet you know it or played some kind of clone. I have also crated clone but with small difference, computer system is defending cities. During this session I would like to run missile defence system on a few Raspberry Pi's. Under the hood there will be Scala and Akka Cluster. You want to have defence system which is responsive and resilient, so do I. I will perform network and power failures to provide some idea how quickly it can recover and prove that Akka application can be responsive and resilient.

Big Data means Big Change

Introducing the new methodology of Big Data causes stress within enterprises due to its impact on existing infrastructures and processes. While an Enterprise Data Hub can be gradually introduced into IT, the impact on data pipelines is fundamental: the entire isolated, silo’ed architecture of the existing EDW is merged into a single, always available system, that requires new ways of handling every stage of the pipeline. From ingest to staging and discovery, all the way to processing and delivery, there is no need to move data, but only regulate access to it. In this talk I discuss the impact on the physical architecture, as well as organisational roles. Where in the past we have seen 6–12 months development cycles for data products, we now see continuous deployment. Where we have seen management planning long term, we now see short refresh cycles. A corporate wide data strategy is replacing departmental information segregation, and with it new opportunities arise, which requires careful change management on every organisational level. We will be looking into roles such as management, IT staff, developers, and end users, addressing concerns during the migration process from EDW to EDH.

Is HBase still a thing?

With the advent of many open-source storage solutions, focussing more and more on actual hardware enhancements, such as SSDs and non-volatile memory, it seems as there are now so many choices, seemingly all doing a better job compared to HBase, that it warrants to take stock of the landscape and clearly position HBase where it can play out its own strengths. While marketing makes you believe that product XYZ can do OLAP and OLTP workloads out-of-the-box, so no need to use anything else, they cannot cheat physics. In the end, every solution has its pros and cons, and hybrid systems that can handle multiple workloads just do sleight of hand trickery to use multiple storage architectures without you noticing - or so the story goes. HBase is not dated, nor marginalized, it is strong and proven, with many great applications. This talk is a summary to show the current landscape and reason about where HBase fits naturally, where it could be used but is not, and why the lack of marketing is causing hurt.

A practical RxJava example with Ratpack

RxJava seems to be this awesome thing that every cool kids start using. But when you read about it, half of the time it's hard to make anything out of it. Sure the isolated examples look nice but it's always hard to put this in perspective with a real app. In this talk I'll go through an application made to store, index and search files. We'll see the benefit brought by using RxJava and Ratpack. Nothing too complicated or advanced, just something pragmatic.

What Does 'Diversity in Tech' Really Mean, Anyway?

In this interactive talk, Zalando Open Source Evangelist Lauri Apple will ask the audience to define what 'diversity in tech' means to them, before sharing her own perspective (based on research, case studies, and some personal observations). She'll then talk about bias, focusing on ways that unconscious biases influence the makeup of our tech teams, the industry, and the way we define 'diversity.' Finally, she'll suggest ways that technologists can use common agile practices to promote diversity in their teams and workplaces--citing some case studies/examples from Zalando's implementation of agile practices.

The Evolution of the Gosu Programming Language

Gosu is a modern, flexible language for the JVM. It uniquely serves as both a concise scripting language and as a powerful general purpose language used for building large enterprise applications. This presentation provides a quick tour of the basics and then moves on to cover some interesting features and type system highlights. The talk concludes with information regarding Gosu's open source projects, tooling, and roadmap.

Lift framework in 45 minutes

In 45 minutes I want to build a full blown web app based on Lift framework to show of its key features

Beyond the hype: a reactive web app in practice

In this talk & live-coding session we will have a practical look at why we would want to have and what makes out how a reactive web application and how resilience, elasticity and responsiveness translate into code. We will start by having a quick theoretical introduction to asynchronous computation and then build, run and deploy a small reactive web application built with Scala, the Play Framework and Akka, exploring a few key concepts such as Futures, Actors and Circuit Breakers along the way.

Microservices tracing with Spring Cloud and Zipkin

2015 was the year of microservices. It’s already common knowledge that creating distributed systems is not easy. It’s 2016 and it’s time to show how that complexity can be contained. Service Discovery and Registry (Zookeeper / Consul / Eureka), easy request sending with client side load balancing (Feign + Ribbon), request proxying with Zuul. Everything is easy with Spring Cloud. Just add a dependency, a couple of lines of configuration and you’re ready to go. That’s fixing difficulties related to writing code - what about solving the complexity of debugging distributed systems? Log correlation and visualizing latency of parts of the system? Spring Cloud Sleuth to the rescue! In this presentation we’ll write a microserviced based system using the Spring Cloud tooling. We’ll focus on distributed tracing with Spring Cloud Sleuth and Zipkin.

Interesting nooks and crannies of Spock you (may) have never seen before

Spock becomes more and more widespread among Java developers. Thanks to its flat learning curve, a sensible Java programmer (without prior Groovy experience) can start writing Spock specifications within several minutes. However, when you combine Groovy & Spock magic, a new fascinating meta-world is created. The exploration of its every nook and cranny can take much longer (and it's definitely much more efficient with a guide ;-) ). There will be no basics during my presentation, just a set of more advanced (and/or less known) techniques and mechanisms, the use of which can even more simplify and facilitate the testing of our code. You have to be forewarned that we will also visit those dark areas where it is better not to enter, things that do not work at all or work in a way nobody expects.

Cool stuff, but HOW DO I GET MY COMPANY TO DO IT?!

Cloud Native, Docker, DevOps, microservices, and more: we go to conferences and get excited about the potential of so many things that could revolutionize our development and change our organizational and professional lives! And then, we go home...and hit the wall. If you've ever asked yourself, 'This stuff is cool, but HOW CAN I GET MY COMPANY TO DO IT??!', this is the session for you. Learn from an experienced software developer (who also happens to have an MBA) how to make your case to leadership, presenting management-ready justifications for changes in 'your world' that will positively impact the business as a whole. Topics include: * How would this change affect your organization's/group's/team's work? * How would this change impact (positively and negatively) your tech stack (internal considerations)? * How would this change contribute to recruitment/retention (external considerations)? * Seeing beyond your borders: how could this change positively - and negatively - affect the business? * Putting numbers with it: pros, cons, and caveats Come to this session to dramatically boost your chances of making an actual, positive change to your organization!

Top 10 Performance Mistakes

Building high-performance systems is tough they say. Today this is especially tough since a lot of the common wisdom for what makes a system high-performance is misleading at best, and often just plain wrong. This talk aims to expose the common mistakes and folklore related to building high-performance systems. Building efficient systems with pretty good performance can be a whole lot easier if you avoid the common mistakes. Martin will cover his updated Top 10 performance mistakes that even experts building high-performance trading or big data systems often fall prey to. Taking an approach of 'measure everything' has been an enlightening education into what works, and what doesn't, when trying to achieve high-throughput at low-latencies. Topics covered will include Java, concurrency, operating systems, functional programming, and how hardware really works.

A quest for predictable latency with Java concurrency

Concurrent programming with locks is hard. Concurrent programming without using locks can be really hard. Concurrent programming with relaxed memory ordering and predictable latency semantics is said to be only for wizards. This talk focuses on a decade long quest to discover algorithms and data structures that provide very high throughput while keeping latency low and predictable. Additionally, data structures need to provide real-time telemetry on how a system is performing via non-blocking operations.We will cover some fundamental theory of concurrency and then compare various approaches to the same problem so that we can measure the impact on latency. We'll also show how some of these algorithm implementations get more interesting given the new features in Java 8.This talk is aimed at programmers interested in advanced concurrency who want to develop algorithms with predictable response times at all levels of throughput which push our modern CPUs to the limit.

Machine Learning for (JVM) developers

Extracting useful information from all the data that overflows our software systems nowadays is becoming more and more of a challenge. Machine learning is one way to tackle this problem. While you certainly do not need a Ph.D. in it or a degree in mathematics/statistics to start using it in your application with the help of existing frameworks but you do need to understand a plethora of new terms and concepts to get the best of it which might seem daunting. In this talk/live coding session we will:
- talk about what exactly machine learning is and how can we benefit from it
- see what are our options on the JVM
- define common terminology and see how can it be implemented on the JVM using Scala, Spark and MLlib
- define all the steps needed to create a good machine learning component
- implement few basic ML apps
- point out the challenges which 'big data' brings Since it will be a talk for beginners I promise I will keep all the math to the necessary minimum.

Human Design Engineering

Testing Patience

Automated testing is widely considered a best practice. After considerable effort, the industry now agrees that unit testing, system testing, usability, and performance testing are essential in most serious development efforts, but we know that they are hard work. In this keynote, Michael Feathers will discuss challenges to the testing orthodoxy presented by micro-services, transient code, and functional programming, and reflect on where we might find ourselves in 10 years.

Don't fear the devops. Taming servers infrastructure with Ansible

These days 'full-stack development' means more than simply coding stuff ranging from pretty UI down to DB access. Sometimes it's required to be able set up set of staging/production boxes, automate deployments and then maintain this infrastructure setup over time. Let me show you Ansible and start setting up your infrastructure like a pro. This talk will be based on my experience from real life project, where we used Ansible to build multi-server cloud infrastructure from scratch and set up deployment for JVM-based app.

Building Snake using Streams

This talk introduces streams and reactive streams. You will learn how stream-based programming can be used to implement web frontend and multiplayer backend of the classic game: Snake. Creating dynamic applications using imperative approach tends to create lots of unmaintainable code. Stream-based programming tries to solve this problem by introducing fully declarative way of defining application logic. While using streams, you will focus on what needs to be done, not how and when. The talk is divided into 3 parts. In the first part you will learn how to create a frontend of the Snake web game using streams as building blocks. Then, we will move to the server side and use Scala and Akka Stream library to create backend service that will allow the game to be played by multiple players. In the third part, we will discuss reactive streams and how they make asynchronous communication safe.

Top 10 Key Performance Techniques 4 Hybrid mobile

It is an easy task to develop, and deploy your hybrid mobile apps to your favorite stores, and get it ready for your client. But what about your application performance, is it fine tweaked for your audience devices. Writing HTML5, CSS3, and JavaScript code is an easy task for web and desktop developers. But very different when we talk about mobile devices. Is your application consume your customer battery?, is it a data hungry application to consume your customer bandwidth?, Take to much memory? , is it slow or even too slow?, is it , is it …. etc. questions about performance. Okay lets see in this session how to keep in mind a very important top 10 key performance techniques while we architecting and developing our hybrid mobile applications to avoid performance issues, with coding examples. You’ll learn how to enhance your mobile applications performance, by implementing those top 10 performance concepts. So what are you waiting for, click to enroll.

Automate your legacy deployments

There are several buzzwords that are all fantastic concepts. If we were to architect a system today, we would apply almost instantly. However, many of us have to operate with architecture that is several years old. Regardless of the age of the systems, reducing server down-time and ensuring high-availability are rules that will always persist. Finding improvements for systems that aren't built using modern tools is a challenge that many of us face. In this talk, Navin Surtani will go through his learnings from his time with a customer at C2B2 Consulting. Along with how we can learn to identify where improvements can be made with deployments in legacy environments, he will describe some of the terrors that lie ahead when organisations attempt to jump straight into modernising their systems.

Supercharge your Android-Fu with Kotlin

For some time, I've been teaching myself Android by developing an application. I tried to use the 'right' development stack with libraries such as Dagger 2 and Butterknife. Kotlin is a JMV-based language provided by JetBrains, along with Anko, a library using Kotlin dedicated for Android. At first, I just wanted to play with both, but I quickly became convinced those were right choices. In this talk, I will show what you can achieve with both so you can supercharge your Android-Fu

Confidence in the frontend with Elm

During the last few years, more and more logic in web applications has shifted to the frontend. Technologies like AngularJS, React and Redux have made it reasonable to build large apps that run in the users' browsers. However, being a fully dynamic language with no guarantees, JavaScript can easily get unwieldy as the project scope grows. With static typing and an incredibly helpful compiler, Elm can alleviate these problems.Elm is a fun contemporary language designed for building UI applications. It compiles to standard JavaScript. With this talk, you will gain an understanding of developing in Elm feels like in practice. In particular, you will learn why using the language leads to an unprecedented confidence in frontend development.

Life without Objects

Clojure is a nice language for illustrating functional design concepts. Transitioning from OOP to functional style can be quite challenging, not least because OO developers are used to modeling nouns but not verbs. Programming languages like Clojure use functions as primary means of abstraction, so one is forced to try out other approaches to design. Assuming basic familiarity with the fundamentals of FP like immutability and purity, we will explore new ways of designing things, doing composition and polymorphism. Fear not! What you have learned about good OO design can be applied to FP, in obvious and sometimes weird ways. After all, an object is just a collection of partially applied functions. Oh, and we won't need monads for any of this.

Kubernetes automated blue-green deployments

Kubernetes is a great tool to run (Docker) containers in a clustered production environment. There are also a few things that Kubernetes doesn't solve though. When deploying often to a production environment we need fully automated blue-green deployments, which makes it possible to deploy without any downtime. We also need to handle external HTTP requests and SSL offloading. This requires integration with a load balancer like Ha-Proxy. Another concern is (semi) auto scaling of the Kubernetes cluster itself when running in a cloud environment. E.g. partially scale down the cluster at night. Although Kubernetes doesn't provide these things out of the box, it does provide an API that can be used to make all of this happen. Tools for automated blue-green deployments and scaling a Kubernetes cluster were developed as part of the Cloud RTI project which is developed in open source. In this technical deep dive you will learn how to setup Kubernetes together with other open source components to achieve a production ready environment that takes code from git commit to production without downtime.

Java 9 Modularity in Action

With Java 9, modularity comes to your doorstep (whether you ordered it or not). This isn't your average language feature: making the most out of it may involve rewiring your brain. In this session we explore the benefits of a modular codebase using Java 9 modules. Because who doesn’t like more reliable and secure applications, meanwhile killing the dreaded classpath? After reviewing the basic concepts of modules, we'll explore modularity patterns that enhance your design and development skills. We all have existing software, so migration of codebases to a modular world is an important topic as well. Automatic modules, the 'unnamed' module and other new concepts are added to your toolbox to this end. Want examples? We've got plenty in this practical and code-driven talk. Even if you intend to use Java 9 without modules, this talk helps you prevent common issues. You'll be ready for Java 9 before you know it.

Stop Doing Scrum; Start Being Agile!

“If I got a cent for each time I heard a variant of ‘We implemented Agile/Scrum/Kanban/Xp at our company, but it didn’t work for us, because we do things differently,’ I would have 4.10 € (or $).” During this session, I'll go into why you should stop trying to implement a methodology from a book in just one team and instead try to create an agile methodology for your company as a whole. I'll present to you : - The history of agile and the ideas behind it - How you can enlighten your company about the advantages of agile - Successes and failures and how we can learn from them And I would love to get some stories from the audience too, so be sure to bring your best agile stories! At the end of this session, you’ll have ideas, tips, and tricks for making your company agile. Disclaimer: Don't let the title fool you. I love Scrum, it's a great methodology. It's just being abused so much.

Augmented Reality in Scala.js

During the talk I would like to present Scala.js capabilities and show how to use it together with other existing solutions to build something working and usable quickly. Key theme of the talk will be augmented reality application, which I will incrementally build during the course of the presentation. I will use camera connected to the laptop to present all the changes, so attendants will be able to monitor progress in the real-time. I will start with simple features like point-tracking, to quickly build something much more impressive. Some code will be written in Scala during the presentation, but I will also use several existing javascript libraries to speed up the progress. Among others I plan to use WebRTC for camera support and Three.js to handle graphics. The main emphasis of the presentation will be on how to wire all parts together to take advantage of various ecosystems. I do not plan to go very deep into image analysis algorithms or Scala.js internals. I want to make this presentation interesting even to people who had no prior experience with Scala.

From Java to Big Data - how to start?

During my presentation I will try to explain how to become Big Data engineer. I will show how to switch over from Java development to building Big Data systems. We will discuss the nature of batch and streaming processing of huge data. I will talk about skills that are crucial for the success. We will discuss if it becoming a DevOps is necessary to work with Big Data. I will show you the architecture of working system and explain why we have made such decisions. To get familiar with the event sourcing nature of click-stream I will talk about recalculation and enrichment of historical data. Short presentation guideline: 1) Big Data – why bother? 2) Skills that you need to become Big Data Engineer (good programming and a devops skills) 3) Typical migration path – from Java to Big Data 4) Example technology stack (Kafka, Spark, Scala, Ansible) 5) Batch processing vs Stream processing 6) Why do you have to automate deployment and become a DevOps? 7) Practical example of the architecture of Big Data system – recalculation of historical data 8) Beauty of the event source systems like click stream and it’s impact on reality

How to Think, in RxJava, Before Reacting

RxJava is a library that helps in writing code using reactive paradigm. When writing programs using RxJava, the hardest part is thinking in Reactive, which requires one to let go of old imperative and stateful habits of programming, and start thinking in a different paradigm. At my work in ThoughtWorks I have been using RxJava for more that six months in production applications. My talk will be based on the knowledge that I gained and lessons that I learnt from my practical experience of RxJava. My goals from this talk are: (1) To demystify the reactive paradigms concepts for the attendees and (2) Provide enough information about the mechanics of RxJava so that attendees can straight away start experimenting with the library The topics that I will be talking about are: (1) Introduction to Reactive Programming, (2) Creating Observable (the source), (3) Creating Observer (the consumer), (4) Subscribing (connecting consumer to source), (5) Operators (for Transforming, Filtering and Combining), (6) Building Resilience (Error handling), (7) Using Concurrency (Schedulers), (8) Unit Testing Utilities

Field Notes of a Command Line Ninja

Have you ever witnessed someone write fancy commands and perform magic from the console. Have you ever wished you could learn, or brush up on, those skills too? Maybe you want to be more effective at your everyday tasks, or need a new topic for the next family dinner? Join us and learn some awesome command line ninja skills. You will be able to find something new no matter your level of experience. The audience will get a chance to show off their skills as well, and there will be small prizes to contributors. The black belt and a little surprise await you at the end of this talk. You can bring your PC with you and hack-along! All you need is a PC or a Mac running OS of your choice - Windows, Linux, or Mac OS. Windows users are advised to have their cmd.exe ready, and to install Cygwin.

MDD: Metrics Driven Development

Moving to a distributed system will solve all your problems and you will be in developer heaven. Right? Not exactly, having hundreds of services doing different things means it's increasingly difficult knowing where exactly production issues are hiding. In this talk Sam Elamin will relate his real life experience working on a distributed system dealing with £100,000 worth of transactions every hour. Sam will cover monitoring and how to develop your features based on how your customers use your platform and, most importantly, business metrics. Sam will cover how to implement metrics in your application and setting up dashboards to gaining visibility into what is happening in your production system right now. We'll also go through some helpful techniques to help you convince your domain experts that gaining this insight is invaluable to keeping your competitive advantage. As an extra treat come and see how JUSTEAT time travels in production, using open source software that can be set up in a matter of days!

Code Review - how to do it better?

The more complex application is the more people are working on it. The more code they're are creating, the more important is to take care of quality of this code. And Code Review is a great practice to doing it. Yet, it happens really often that after a while, when your eagerness decreases and the amount of reviews grow, many people starts to complain. They're looking for excuses to not have a time for the reviews. For doing it carelessly. Is it a problem? Only if you won't react. Because there's a room for improvements in here!

Introduction to Designing Voice-Driven Experiences

Amazon Alexa enables customers to interact with devices and services in a more intuitive way using their voice. Join this talk for an introduction to voice design.

Julia: fast, productive, composable & generic programming

Consider the following properties of a programming language:
1. High performance
2. Simple programming model
3. Composable, reusable, generic code
It’s hard to get two, let alone three, of these in a single programming environment. Julia provides all three. Write straightforward code like you would in Python or Ruby; it’ll run at the speed of C – and execute the same native machine code. Unlike C, however, where each function only works for a single concrete set of types, Julia code is highly generic: the same code works for an unlimited set of types. Moreover, it’s straightforward and common to combine functionality defined in one library with types defined in others in entirely unanticipated ways – and it just works. The secret to Julia’s composability is multiple dispatch, a programming paradigm, which is simple yet surprisingly powerful: instead of dispatching functions on just one argument – the “object” in “object-oriented” – Julia dispatches functions based on all of their arguments. How can such a simple change matter so much? In a nutshell, it lets Julia solve “the expression problem”: in object-oriented languages, extending existing operations to new types is easy, while in functional languages, adding new operations to existing types is easy – but each paradigm struggles in the other direction. Multiple dispatch allows both extensions in an intuitive, elegant manner, which turns out to have surprisingly broad benefits for writing composable and reusable libraries. This talk will be full of live coding and examples, with all of the excitement and suspense entailed.

DI Frameworks - some hidden pearls

Dependency Injection is now part of nearly every Java project. But what is the difference between DI and CDI. How to decide what I could use better, what frameworks are available and what are the differences for me as a programmer? What could be an option for the IoT-, Desktop- or Webproject? In this talk we will get an overview over different frameworks and how they are working. We are not checking the well known big one only, but we are looking at some small sometimes specialized implementations.

Rise of the Machines - Automate Your Development

When we talk about automation in software development, we immediately think of automated builds and deployments. We may also be using scripts to help make our daily work easier. But this is really just the beginning of the rise of the machines. I show you how leading developers in our industry are using open source and commercial tools for automating much more. They've got 'robots' for monitoring production servers, updating issues, supporting customers, reviewing code, setting up laptops, doing development reporting, conducting customer feedback -- even automating daily standups. In what instances is it useful to automate? In what cases does it not make sense? Automation prevents us from having to do the same thing twice, helps us to work better together, reduces workflow errors and frees up time to write production code. Plus, as it turns out, spending time on automation is fun! Don't be afraid of robots in software development, embrace them! Even if I save you just half an hour a week, this talk will be a beneficial investment of your time.

Tracking huge files with Git LFS

Developers love Git for its raw speed, powerful history traversal, distributed nature, and the fact that it was built by super-developer Linus Torvalds. What we don't love is the fact that, out of the box, Git has terrible support for tracking large binary files! Fortunately, developers from Atlassian, GitHub, and Visual Studio Online have teamed up to work on an open source project to solve this problem: Git LFS (Large File Support). This means researchers, web designers, game developers, multimedia producers and all other developers who need to work with large data and rich media can move off legacy centralized systems and start using modern version control. In this session I'll cover the computer science behind Git LFS' internals & architecture, CLI usage and how to build an effective Git LFS workflow for a development team. Attendees will take away an understanding of how Git LFS works under the hood, and some practical advice on using Git LFS with their software projects and teams.

Better living through pull requests

Code reviews mean slightly better code at the cost of extra developer time, right? Wrong! Code reviews not only improve your code, they share knowledge, increase team cohesion and improve your company's 'bus factor' by an order of magnitude. In this fast-paced, entertaining talk I'll show participants some of the unexpected and undersung benefits of peer code review. Come along to find out why teams that aren't regularly reviewing code probably shouldn't let their developers attend Geecon!

Serverless Architecture in the Cloud – AWS Lambda

The objective of the presentation is to present the concept of servless architecture in the Cloud – in which the user doesn’t need to worry about underlying infrastructure: about scaling, provisioning and managing servers. The presentation shows how using Lambda the user can accomplish those goals. The user can just upload his code (Java, Node.JS, Python) and Lambda takes care of everything required to run and scale code with high availability. The main goal of the presentation is to show how this new approach of building backend applications can significantly accelerate the time needed to build systems, reduce the costs, and simplify the administration and designing of systems.

Backend-less Development revisited

'It's obvious that SPA interfaces rely on RESTful APIs'. But does it have to be like this always? Tight-coupling between interfaces and APIs result in great development issues. Backend-less development is an emerging approach of decoupling the two sides, enabling them to be developed independently. The costs and the benefits of mocking the entire API. The three possible architectural approaches in doing so. Mock engine examples in Angular.js and sinon.js. Simulating business logic in mocks using plain JavaScript and JSONs. Using JSON Schema do generate massive amounts of mock data on the fly. The technical and business aspects of separating frontend and backend - these are the topics I will cover.

How shit works: Storage

The beautiful thing about software engineering is that it gives you the warm and fuzzy illusion of total understanding: I control this machine because I know how it operates. This is the result of layers upon layers of successful abstractions, which hide immense sophistication and complexity. As with any abstraction, though, these sometimes leak, and that's when a good grounding in what's under the hood pays off. This first in what will hopefully be a series of talks covers the fundamentals of storage, providing an overview of the three storage tiers commonly found on modern platforms (hard drives, RAM and CPU cache). You'll come away knowing a little bit about a lot of different moving parts under the hood; after all, isn't understanding how the machine operates what this is all about?

The Wix Microservice Stack

While microservices are conceptually simple, it's a deep rabbit hole to go down. Deceptively simple questions can have far-reaching implications: Which communication protocol should I choose? Is event-driven the way to go? What monitoring tools should I put in place? In this talk we'll cover some of the fundamental questions, outline the solutions adopted or developed by Wix, and share our hindsight on what worked well for us, what didn't and thoughts on future directions for our stack.

Self-Healing Systems

We can think of the whole computer systems as a human body that consist of cells of various types. They can be hardware or software. When they are software units, the smaller they are, the easier it is for them to self-heal, recuperate from failures, multiply or even get destroyed when that is needed. We call those small units microservices and they can indeed have behaviours similar to those observed in a human body. The microservices based system we are building can be made in a way that is has the ability to self-heal. That is not to say that self-healing we are about to explore is applicable only to microservices. It is not. However, self-healing can be applied to almost any type of the architecture but provides best results when combined with microservices. We'll explore practices and tools required to set up fully autonomous self-healing systems capable of both reactive recuperation from failures and proactive predictions of steps that should be taken to prevent failures before they happen.

Theory of Constraints -­ science behind every effective process

If you have ever struggled with managers who push too much tasks on you and your team ­this presentation is definitely dedicated to you! You will learn:

Need Robust Software? Make It Fragile

In any software project, the goal is to create something stable. We don't want it to break in front of a user. We also don't want our website to show an 'internal application error' instead of a web page. We want our software to work, not fail. That's a perfectly valid and logical desire, but in order to achieve that, we have to make our software as fragile as possible. This may sound counter-intuitive, but that's the way it is. The more fragile your app is in development, the more robust it is in production. I will demonstrate, with practical Java examples, what Fail Fast means and how it helps us make software more stable.

Registration & breakfast

Breakfast

Break

The best time to take coffee or juice

Coffee Break

The best time to talk with speakers and attendees

Lunch Break

Opening ceremony

TBA

To Be Announced