Conference program is forming and call for papers was opened. We will publish all submitted talks here after initial review stage. Final version of the conference program will be published on April 6th. If you have any questions related to the program and talk submission please send them to firstname.lastname@example.org.
Do we need JMS in 21st century?
Java Concurrency Applied
In this talk I will present some tasks we solved in our projects and solutions we came to. It is practical journey to expand your horizons in applied Java concurrency.
How Java developers must test their applications
CompletableFuture is here
Let’s talk about other languages and libraries a bit. For a long time we already have Future and ExecutorService for asynchronous execution. However, with the advent of CompletableFuture in JDK 8, the way opened from callback hell to clean and more functional code.
We look at practical examples of the challenges CompletableFuture ‘with streams and lambdas’ takes and about it’s efficiency.
Side-By-Side Performance Comparisons
There are surprisingly many ways to do it wrong. The talk will cover some of them and discuss the general problem of benchmark suites for Java.
Just what are you doing, HotSpot?
But come on, HotSpot is not a mysterious machine. It is opensource, after all! All the seemingly weird JVM behavior can be reproduced, and explained if one goes just a bit deeper.
This talk will take the audience to the fun world of the JVM sources and review several case studies that are initially puzzling, but are actually quick to be dissolved.
Introduction to Real-Time Big Data with Apache Spark
Where Is My Memory?
First steps in GC tuning
The goal of this talk is to demystify Garbage Collector optimisations. I will explain the basics of Garbage Collector tuning, starting from data collection and analysis. I will show how to formulate optimisation hypotheses, choose right parameters for it and verify if they worked. You will not become a GC expert, but you will not be afraid of GC tuning anymore.
Heap, off you go
I will describe what does “off-heap” memory means for java application developer and how he can use it in order to speed his application up. The majority of this talk is live code demonstration. I will use different ways to implement off-heap data storage and will show how fast one and the same piece of code runs with each implementation.
MVC 1.0 by Example
Improve your tests quality with Mutation Testing
In the realm of testing, the code coverage metrics is the most often talked about. However, it doesn’t mean that the test has been useful or even that an assert has been coded. Mutation testing is a strategy to make sure that the test code is relevant.
In this talk, I will explain how Code Coverage is computed and what its inherent flaw is. Afterwards, I will describe how Mutation Testing work and how it helps pointing out code that is tested but leave out corner cases. I will also demo PIT, a Java production-grade framework that enables Mutation Testing on a simple code base. If time allows, a demo will also show how PIT can be integrated with SonarQube.
Spring Boot for Devops
However, this is only one of the many features of Spring Boot. One of its module also provides many important Non-Functional Requirements out-of-the-box: monitoring, metrics, exposing those over HTTP, etc. In this presentation, I’ll demo some of those, that will make DevOps more than a little happy.
JDK: CPU, PSU, LU, FR — WTF???
Atomics, CAS, and Nonblocking Algorithms
Big Data: from mammoth to elephant – transforming legacy solutions with Hadoop infrastructure
This is exact situation we had 2 years before. So we’d like to shouw our experience:
- Why and how we came into Big Data?
- Why we choose Apache and Hadoop?
- What to do and what is already done?
- What lessans were learned?
- Hadoop and relational databases: fight or synergy?
- Reactive Big Data manifest.
Painfree Object-Document Mapping for MongoDB
On a practical level we take a look at the available annotations and how to map your objects as well as how to easily query data in MongoDB. Next we discuss some patterns on how to solve common requirements, such as the proper use of generics, auto-increments, and the encryption of sensitive data. The talk concludes with some tips and lessons we’ve learned from using Morphia in production for three years.
Fault tolerance – look, it’s possible!
Let’s endue our software with capabilities to survive in the wild world of reality. In this talk I’m going to depict fault tolerance concepts and patterns, to provide guidance for implementing resilient software.
- Level 1 – You know how to use Spring basic without understanding how it actually works under the hood.
- Level 2 – You understand Spring internals, so you can customize it in accordance with the needs of your project.
We offer you an upgrade to Level 3 – to obtain knowledge of very particular but important details about Spring. This session includes many intricate riddles about Spring, which were gathered from real production java projects. Solving them will help you to acquire very important knowledge about Spring and will protect you from different mystical bugs.
Building an Enterprise-less online bank
Play Framework greatly helped to give a quick start and put architecture on the right track, but of course the real life has made some corrections, especially related to integration with backend systems: online bank is responsible for the overall user experience, so it must work around any flaws of IT systems in the bank and outdated legal requirements. I will talk about what is particularly good about Play Framework and what we had to do differently, as well as how Agile practices help us to fight poorly designed backend-systems.
Write code faster with fewer errors: is it possible?
Cassandra in a Microservices platform
There’s a lot of theory on Microservices out there, and with your nose up to the grindstone and progress slow it can at times be difficult to relate to and to remember how important it all is. With a run through of development styles of streaming, raw event stores, event sourcing, graph databases, and drilling down to infrastructure components like Graphite, Kibana, and Zipkin, this talk will share with you the experience needed to implement Microservices, with Cassandra as a cornerstone technology, in a modern polyglot persistence enterprise platform.
With 6 years experience breaking up a monolith java+sql enterprise dinosaur into a Microservices platform today existing with over 200 thrift and http services – Mick can give a hands on account of facing these challenges.
RESTful services and OAUTH protocol in IoT
The Epic Groovy Puzzlers [Season 2]: The revenge of the parentheses
Everything you wanted to know about writing async, high-concurrency HTTP applications in Java, but were afraid to ask
In this talk, we will share the main challenges in developing a highly-concurrent, resumable, async download library on top of Apache HTTP client. We will cover other libraries we tested and why we decided to reinvent the wheel. We will see important pitfalls we came across when working with HTTP and how using the right combination of techniques can improve performance by an order of magnitude. We will also see why your initial assumptions may completely change when faced with other players on the network.
Consider yourself forewarned: lots of HTTP internals, NIO and concurrency ahead!
Spring Boot. Boot up your development
Spring Data, ta da!
Big Data analysis approaches in Java world
“Codename One” – Java to Obj-C bridge
My manager sucks!
Node.js and Evented I/O Alternatives on the JVM
Come and see my Beer-as-a-Service in action!
Web-application I have always dreamt of
Later I tried to bring all the good points I had ever seen together to create “a perfect being” and after years of struggling I feel that I have reached the goal. Let me share it…
How to write IDE for your DSL in one day
Pragmatic Functional Refactoring with Java 8
In this talk we show how you can refactor your traditional object-oriented Java to using FP features and APIs from Java 8 in a beneficial manner. We will discuss things like:
- How to adapt to requirement changes using first-class functions.
- How you can enhance code reusability using currying.
- How you can make your code more robust by favouring immutability over mutability. How you can reduce null pointer exceptions with Optional.
Java Generics: Past, Present and Future
We start by stepping back into the halcyon days of 2004 and explain why generics were introduced in the first place back. We also explain why Java’s implementation is unique compared to similar features in other programming languages.
Then we travel to the present to explaining how to make effective use of Generics. We then explore various entertaining code examples and puzzlers of how Generics are used today.
Finally, this talk sheds light on the planned changes in Java 10 with practical code examples and related ideas from other programming languages. If you ever wanted to understand the buzz around higher kinded types or declaration site variance now is your chance!
Packed Objects, Object Layout & Value Types — a Survey
However, recently this problem has been addressed by several different approaches. My talk will briefly introduce Packed Objects , an extension available in IBM’s Java SDK 8, Object Layout , a layout-optimized Java data structure package proposed by Gil Tene and Value Types , an OpenJDK proposal for small, immutable, identityless value types.
I will describe the commonalities and differences of the three approaches and explain how they can improve the memory overhead and locality of Java objects. Finally I will deep-dive into the implementation of the Object Layout library and explain how it can be transparently intrinsified and optimized in the HotSpot VM.
Attendees of my talk will become familiar with the development of an emerging Java technology. The will also get a good impression of what it means to implement such an extension in the Java Virtual machine and gain some insights into the HotSpot VM.
Delivering Native User Experience in Client-Side Java Applications
And this trend is extending to the desktop as well, forcing ISVs to look for cross-platform solutions.
Now recall that Java offers a variety of rich UI frameworks, from Swing to JavaFX, for all major desktop platforms right now.
However, to be called a native client, an application written in Java should deliver native user experience:
it should install in a native manner, come with no external dependencies, look good, start and work fast, and not consume too much memory.
In this talk we will consider how these requirements are addressed by different Java implementations and solutions.
Java restart with WebFX
I would like to give an overview of the projects, make a live demo, compare the proposed technologies with traditional web and native clients, show how the technologies differ from Java applets and Java Webstart, reveal benefits in compare with RDP-like approaches. Finally, I will share my vision on how to evolve the projects.
Building domain-specific languages with Groovy
What usually stops everyone from implementing really nice DSL is either poorness or complexity of instruments for their creation. Groovy is modern JVM language which features makes it first choice for simple and enjoyable DSLs implementing.
In this talk, we will look at the instruments that Groovy provide for DSL builders and use it for creating our own DSL. We will cover features ranging from what Groovy can suggest for standard Java developer to transform his ugly Java DSL into something acceptable in 5 minutes to advanced features like Metaobject protocol and AST transformations.
Productivity in Scala
This talk is about what tools and practices can be used for the beginners. We will observe Scala Worksheet and its practices. We also will make a review for the most common mistakes in Scala code. Moreover I’ll tell you about refactoring tools and implicits debug tools. This talk will have some introduction to Scala, so any knowledge of this language is not required.
All of this will help people, who want to start learning Scala, to do it in more effective way and it also will help people, who already know Scala, to use it in more powerful way.
DSL in Clojure
ETL all the things!
Microservices, ‘Enterprise’ and Conway’s law
In this talk I’d like to tell you about our (small agile software house working for Big Company) experiences – when is it possible to change the company you’re working for and when it’s better to accept its constraints – and what can you do to make it still a bit better place to live – which rules and practices seen on Netflix gorgeous talks can be easily used and which are more problematic.
Be aware that I’ll use old-fashioned words like OSGi, but I’ll try to omit most technical details and focus more on bigger picture – how we tried to move from good (?) old ESB towards fashionable microservices and where and why we decided to stay.
Lessons from Implementing a Modern B2C System in Scala
Making This Rhinoceros Thunder
Scaling a solution of an NP-hard problem in a cluster of machines using Apache ZooKeeper
App infrastructure for microservices with Spring Cloud 1.0.0
Spring has always been about patterns and Spring Cloud brings you implementation of several widespread ones for distributed apps.
We will talk about the problems we’ve encountered while trying to move our projects in cloud, what pain Spring Cloud promises to fix, how it fits the new cloud world vision. And what should come first – DevOps or Microservices.