Conference program

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 review@jeeconf.com.

Submitted talks

Do we need JMS in 21st century?

Abstract: JMS is known as standard way to implement distributed work with messaging in Java world. There are many JMS providers, both open source and commercial. Large percent of developers use JMS for almost every case when they want to sent message and process it on the other side. But now there are many alternative solutions to organize message queues: AMQP, Redis, ZooKeeper, Apache Kafka or even custom solutions based on Cassandra. Why not to use them instead of JMS? In this talk we will discuss key “issues” in any messaging system and then with this knowledge in mind look once again at JMS and alternative approaches using practical cases from my experience. May be after this talk some more people will stop using JMS and start using their mind. :)
Format: Talk (45 minutes)
Language: Russian

Java Concurrency Applied

Abstract: Every Java developer knows that concurrency is evil and it is very hard to write correct concurrent code, frequently it breaks all expectations. But what tasks do arise in real commercial Java project except traditional running peace of code async?

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.

Format: Talk (45 minutes)
Language: Russian

How Java developers must test their applications

Abstract: In the modern development all developers understand importance of testing. In theory, most of Java developers even understand that they need to write unit and integration tests, or functional tests as the best result. But there is a question from many of them “HOW?”. In the real life everything is not so easy like in samples from the internet. In this talk I will present my expericence, tools and techniques for testing different layers of the application witj RDBMS, NoSQL storages, file system, MVC frameworks, multithreading, REST services and other common parts of almost every Java application. This talk will have very low number of slides, only code, only hardcore!
Format: Master-class (1 hour 40 minutes)
Language: Russian

CompletableFuture is here

Abstract: Many have said that Java has no future. But it is now 2015, the new APIs and trendy lambda dances in Java 8. And a crowd of advanced neighbors​​ that have their own means of asynchronous processing for ‘going to production quickly.”

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.

Format: Talk (45 minutes)
Language: Russian
Speaker: Dmitry Chuyko

Side-By-Side Performance Comparisons

Abstract: Suppose you want to have a general understanding of how the performance changes when you add a new JVM argument. For instance, you develop an agent, and you want to make sure that the clients’ performance does not suffer when it’s attached. Or you want to see if it is a good idea to enable a JVM option by default.

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.

Format: Talk (45 minutes)
Language: Russian
Speaker: Gleb Smirnov

Just what are you doing, HotSpot?

Abstract: Most engineers face problems that are new to them from time to time. Sometimes reading the docs is enough to solve it. Sometimes, there is someone who can help you out. Some other times, you have to dig in by yourself. When things get as deep as JVM, many engineers tend to back down.

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.

Format: Talk (45 minutes)
Language: Russian
Speaker: Gleb Smirnov

Introduction to Real-Time Big Data with Apache Spark

Abstract: This presentation will be useful to those who would like to get acquainted with Apache Spark architecture, top features and see some of them in action, e.g. RDD transformations and actions, Spark SQL, etc. Also we will cover real life use cases related to one of ours commercial projects and recall roadmap how we’ve integrated Apache Spark into it.
Format: Talk (45 minutes)
Language: Russian

Where Is My Memory?

Abstract: Memory leaks and other memory exhaustion situations are frequent enemies of Java application developers and administrators. They can crash your application or make it unbearably slow. This tutorial explains different ways to monitor the memory usage of Java applications and how to distinguish between normal and critical situations. It also explains what information is necessary and when and how to collect it to start solving memory-usage-related problems in your application. You’ll also learn what a memory dump is and how to use it. The presentation also briefly discusses what class loader leaks are and how they differ from object leaks. The session ends with a brief discussion of what other tools are available and if they are useful.
Format: Talk (45 minutes)
Language: Russian

First steps in GC tuning

Abstract: Correctly configured Garbage Collector is essential for application performance. Unfortunately, there are more than 200 JVM configuration parameters which influence GC in one way or another. Their very obscure names make your command line looks like a magic incantation.

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.

Format: Talk (45 minutes)
Language: Russian

Heap, off you go

Abstract: Automatic memory management and garbage collection is one of the biggest advantages of JVM compared with previous platforms. But it has a price: GC overhead and pauses. When every millisecond counts this price can be too high. You can get away and not pay it by taking responsibility back into your hands.

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.

Format: Talk (45 minutes)
Language: Russian

MVC 1.0 by Example

Abstract: JSR 371: Model-View-Controller (MVC 1.0) Specification is targeted to be a part of the upcoming Java EE 8 release. In this session I will quickly go through the nuts and bolts of this JSR. I will then jump right into a demo showing the key concepts by building an application based on MVC 1.0 from scratch. As we go I will also make a quick comparison with other frameworks, such as Spring MVC. This session will be based on a live coding demo backed by a set of introductory slides.
Format: Talk (45 minutes)
Language: English
Speaker: Ivar Grimstad

Improve your tests quality with Mutation Testing

Abstract: Unit testing ensures your production code is relevant. But what does ensure your testing code is relevant? Come discover mutation testing and make sure your never forget another assert again.

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.

Format: Talk (45 minutes)
Language: English

Spring Boot for Devops

Abstract: Spring Boot is a product from Spring, that provides many configuration defaults for a new Spring project, so that one can set up a project in minutes.

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.

Format: Talk (45 minutes)
Language: English

JDK: CPU, PSU, LU, FR — WTF???

Abstract: For the time beeing, there are 4(!) different types of Oracle JDK Updates: Critical Patch Update (CPU), Patch Set Update (PSU), Limited Update (LU) and Feature Release (FR). We will talk about differences between these types of updates, about reasons led Oracle to this model. As a result, you will understand what version of JDK/JRE you should use in production, in test environment and on your develment machine and what to expect from another JDK release.
Format: Talk (45 minutes)
Language: Russian

Atomics, CAS, and Nonblocking Algorithms

Abstract: This talk will introduce you in disadvantages of locking, CAS operations, Java atomic variable classes and a couple of nonblocking algoritms: nonblocking stack and nonblocking queue. If we have time, we will also talk about ABA problem. The talk is based on JCIP (§15) and TAoMP (§§ 5, 7, 10, 11). It will be interesting for Java programmers who have heard about CAS and lock-free, but who have no experience in writing non-blocking code.
Format: Talk (45 minutes)
Language: Russian

Big Data: from mammoth to elephant – transforming legacy solutions with Hadoop infrastructure

Abstract: You run your SQL-centric infrastructure for 10 years and slowly starting to note you can’t do this way anymore – everything is getting too expensive but your business requires things which are simply impossible without radical cahnges.

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.
Format: Talk (45 minutes)
Language: Russian

Painfree Object-Document Mapping for MongoDB

Abstract: Morphia is MongoDB’s JPA-like Object-Document Mapping (ODM). However, there is no object-relational impedence mismatch since documents fit the concept of object-orientation much better. This removes a lot of JPA pain, which makes database interactions fun again.

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.

Format: Talk (45 minutes)
Language: English
Speaker: Philipp Krenn

Fault tolerance – look, it’s possible!

Abstract: The world of old-school approaches to develop software look like are going away. We have no rights to ignore errors that might never happen; connections that might never will be broken or interrupted, processes that might never be killed; networks that might never be slow and this list could continue further…

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.

Format: Talk (45 minutes)
Language: Russian

Spring Puzzlers

Abstract: Everyone knows, that Spring is one of the most powerful and useful frameworks for Java. So how deep are you familiar with it?

  • 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.

Format: Talk (45 minutes)
Language: Russian

Building an Enterprise-less online bank

Abstract: I am pleased to tell you about the architecture of an online banking platform based on Play Framework and PSJ – Plain Simple Java. I will show why it’s better, faster and cheaper than building on the overused Java Enterprise stack. Online banking solutions on this platform now serve Bank Saint Petersburg and UBRD in Yekaterinburg, both of which have won many awards right after launch.

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.

Format: Talk (45 minutes)
Language: Russian
Speaker: Anton Keks

Write code faster with fewer errors: is it possible?

Abstract: Developers want to make very few errors in their code and to spot them as early as possible: with the help of unit tests, or earlier, during compilation, or best of all, immediately after they typed something wrong in their IDE. This is what static code analyzers are for. Some of them are built-in, others need to be run separately, some check just about any code, the others require it to be annotated first, and there are tools that are a little bit of all. Do the ends justify the means? Is it even worth trying? What kind of errors can be spotted by static code analysis? How sure can we be if what an analyzer gives us is a real error or a false positive? This talk hopefully helps you answer these questions.
Format: Talk (45 minutes)
Language: Russian

Cassandra in a Microservices platform

Abstract: Building a Microservices platform takes time and challenges a number of traditions in our industry. Coming to grasp with the Brewer’s theorem, BASE, streaming, and de-normalisation of data is a crucial step in accomplishing a successful 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.

Format: Talk (45 minutes)
Language: English

RESTful services and OAUTH protocol in IoT

Abstract: From the software development perspective Internet of Things (IoT) is about programming sensors, connecting them with each other and integrating them with existing business applications.

While IoT-enabled devices can use a variety of proprietary software, RESTful Web services and OAUTH protocol play a role of a glue that allows to integrate multiple devices into an application workflow. This presentation will demonstrate a sample architecture of such an application. You’ll also see a live demo of using commercial consumer devices as a part of an application that utilizes REST API, OAuth, Websockets, JavaScript and Java. This presentation will give you an idea of how to authenticate users and integrate new IoT devices as they become available on the market.

Format: Talk (45 minutes)
Language: Russian
Speaker: Yakov Fain

The Epic Groovy Puzzlers [Season 2]: The revenge of the parentheses

Abstract: More strange, more bizarre, more fun! The Groovy Puzzlers hits with its second season in which we implemented the lesson learned from the first one – do more of the same (always as a duet)! Expect even more “NO WAY!”, “WHOA!”, “WTF!”, O_o and prizes flying around, and expect to learn more about Groovy’s darkest secrets! As usual, the traps we fell into here in JFrog and contributions from top-notch Groovy authors and users!
Format: Talk (45 minutes)
Language: Russian

Everything you wanted to know about writing async, high-concurrency HTTP applications in Java, but were afraid to ask

Abstract: With tens of millions of clients continuously downloading binaries from our repositories, we decided to offer an OSS client that natively supports these downloads.

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!

Format: Talk (45 minutes)
Language: Russian

Spring Boot. Boot up your development

Abstract: One of the most frequent tasks in software development is deployment and configuration of applications. Spring Boot is modern framework that allows to simplify and speed up both tasks bringing standards and rules in the development process.
Format: Talk (45 minutes)
Language: Russian

Spring Data, ta da!

Abstract: Have you ever migrated from one database to another or needed to change ORM? Have you ever moved from relational database to NoSQL. Or maybe you worked on projects which had a combination of both of them above and planned to introduce additional database? How much did you suffered trying to save your infrastructure features? In the current session, I’ll show you how you can reduce the pain by using Spring Data.
Format: Talk (45 minutes)
Language: Russian

Big Data analysis approaches in Java world

Abstract: Your project got data. Big data. Your business wants using it. On regular basis. Today data varies from mobile app logs to video streams and business needs assistance now and then. How can you get support from technology? You will learn how In-Memory Data Grid, Massively Parallel Processing and Map-Reduce can help. Also you’ll get an overview of a real life use case when sensor data is analized with HP Vertica, Java and R.
Format: Talk (45 minutes)
Language: Russian

“Codename One” – Java to Obj-C bridge

Abstract: Is the good time of Java world “Write once, run anywhere” coming back? Codename One is the only Java iOS tool that currently comes close to this concept. Java bytecode is translated to native C/ObjC code and compiled using Xcode for seamless mobile application development. We will review this open-source platform and see its capabilities.
Format: Talk (45 minutes)
Language: English

My manager sucks!

Abstract: Software developers can be divided into two groups: those who think that their manager sucks, and those who believe that managers are not needed at all. Managers can be divided into two groups too: those who think that they know how to write software and those who know how to deliver the product. In this talk we’ll discuss all points of views to put your mind at ease and come up with a definition of a good manager and a good employee.
Format: Talk (45 minutes)
Language: Russian
Speaker: Yakov Fain

Node.js and Evented I/O Alternatives on the JVM

Abstract: Node.js (or I/O.js) as an evented I/O runtime is very popular and is used widely. But how do you integrate Node in enterprise architectures? There are mature monitoring processes for JVM runtime environments and a significant part of the business logic is implemented in Java libraries. In addition, JavaScript code execution in Node.js is only single threaded, is it worth at all?

The seamless integration and a (nearly complete) compatibility to Node.js applications in JVM environments promise Nodyn from RedHat, but it’s using alternative JavaScript engines from V8 like Nashorn and DynJS; additionally there’s Netty and Vert.x.

This approach deals with the ability to be able to execute JavaScript code not only non-blocking and asynchronously, but also in highly distributed environments using the Vert.x Eventbus. Additionally, there are other advantages of using a JVM-based scripting engine when developing for enterprise environments.

Come and see my Beer-as-a-Service in action!

Format: Talk (45 minutes)
Language: English
Speaker: Niko Köbler

Web-application I have always dreamt of

Abstract: Through years of work have been trying many of Java frameworks which provides different level of abstractions on both server and client-side. Pure Servlet+JSP, JSF, GWT, Struts, Spring MVC, Vaadin, Play!, DWR, you name it. Sometimes it felt good, sometimes not, and with each year number of “good” applications reduced to the critical minimum.

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…

Format: Talk (45 minutes)
Language: Russian

How to write IDE for your DSL in one day

Abstract: Xtext is a new framework for developing parsers for your DSL language linked with power of the Eclipse platform. During this talk I will show how advantages of this tool can help as to build powerful IDE for own DSL language during just one day.
Format: Talk (45 minutes)
Language: Russian

Pragmatic Functional Refactoring with Java 8

Abstract: You may be hearing a lot of buzz around functional programming. For example, Java 8 recently introduced new features (lambda expressions and method references) and APIs (Streams, Optional and CompletableFutures) inspired from functional ideas such as first-class functions, composition and immutability. However, what does this mean for my existing codebase?

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.
Format: Talk (45 minutes)
Language: English

Java Generics: Past, Present and Future

Abstract: Generics are one of the most complex features of Java. They are often poorly understood and lead to confusing errors. Unfortunately, it won’t get easier. Java 10, release planned for 2018, extends Generics. It’s now time to understand generics or risk being left behind.

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!

Format: Talk (45 minutes)
Language: English

Packed Objects, Object Layout & Value Types — a Survey

Abstract: Java is often criticized for not supporting C-style structs. This makes it hard to efficiently implement certain types of data structures like for example arrays of small objects.

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.

Format: Talk (45 minutes)
Language: English

Delivering Native User Experience in Client-Side Java Applications

Abstract: A modern internet service is not just a web client today. It is common to write native mobile clients at least for the major platforms (iOS/Android).

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.

Format: Talk (45 minutes)
Language: Russian
Speaker: Nikita Lipsky

Java restart with WebFX

Abstract: The purpose of the WebFX project is to investigate the capabilities of using JavaFX to build rich web applications. Actually, it is an attempt to create a new web where HTML is replaced with FXML — the markup language for JavaFX UI, and the logic can be written in any programming language that is available on top of Java platform from JavaScript, Groovy, JRuby to Java, Kotlin and Scala. Java ReStart is a complimentary project that acts as transport layer for WebFX allowing FXML pages to reference arbitrary Java byte code on a web server and hence any custom JavaFX UI components and Java third-party libraries. In addition, Java ReStart allows to run arbitrary Java applications instantly from a web server downloading only required parts of applications on demand and executing them in parallel with downloading.

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.

Format: Talk (45 minutes)
Language: Russian
Speaker: Nikita Lipsky

Building domain-specific languages with Groovy

Abstract: Domain-specific languages (aka DSLs) brings their creators to the new level of abstractions power. They indulge two primary desires of each developer: to play with challenging and interesting problems and to make future tasks easier and more pleasant to work with.

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.

Format: Talk (45 minutes)
Language: Russian

Productivity in Scala

Abstract: Scala can be really complicated, and it’s normal that you don’t know how to start learning it. So it really simple to miss possibilities for the beginners to learn Scala effectively.

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.

Format: Talk (45 minutes)
Language: Russian

DSL in Clojure

Abstract: Clojure is a great language, especially for writing DSLs. Talk overviews DSL examples, common problems and approaches to their solving. Also we will discuss Instaparse, Clojure library which makes context-free grammars as easy to use as regular expressions.
Format: Talk (45 minutes)
Language: Russian
Speaker: Misha Kozik

ETL all the things!

Abstract: The talk will compare Cascalog, fully-featured data processing and querying library on top of Hadoop, and Sparkling – A Clojure API for Apache Spark. How both of these compare in terms of performance and code complexity for Big Data processing and why you shouldn’t be writing MapReduce jobs in plain Hadoop API.
Format: Talk (45 minutes)
Language: Russian

Microservices, ‘Enterprise’ and Conway’s law

Abstract: Microservices are today’s hype. It seems that if you’re not doing them – you’re old fashioned and Doing It Wrong. But to do it properly you have to work in certain environment – ‘you have to be That tall’ as Martin Fowler wrote. In particular if you ignore things Conway’s law you’ll fail miserably.

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.

Format: Talk (45 minutes)
Language: English

Lessons from Implementing a Modern B2C System in Scala

Abstract: Whenever a functional language is mentioned, everyone talks about typical applications like DSL, parsing, data mining, or scientific computing. But what about mainstream consumer-facing applications? Can you build your next project with Scala? What if your system must run in the cloud, on desktop computers, and on specialized hardware, can you still do it? We’ll share our experience of implementing such a system for a German fitness startup that utilized custom-built devices, biometrics, cross-platform integration, and, of course, Scala. We’ll discuss the challenges we ran into and pitfalls you can avoid when your team decides to go functional.
Format: Talk (45 minutes)
Language: Russian
Speaker: Yuriy Guts

Making This Rhinoceros Thunder

Abstract: Nashorn, being part of OpenJDK is in unique position of being a JavaScript runtime embedded in the Java ecosystem. I’ll explain some of its under the hood workings (some of them are new in the just released Java 8u40). That understanding will let you get the most performance and functionality out of it when you use it to build Java+JS hybrid services and applications for the JVM.
Format: Talk (45 minutes)
Language: English

Scaling a solution of an NP-hard problem in a cluster of machines using Apache ZooKeeper

Abstract: NP-hard problems play an important role in cryptography and are frequent in graph theory. Large number of computers don’t reduce a complexity of an algorithm, but a solid architecture and design of distributed system can provide good scalability. In this talk, I will solve a non-standard NP-hard problem and will give examples how to solve it in a cluster of machines using Apache ZooKeeper.
Format: Talk (45 minutes)
Language: Russian

App infrastructure for microservices with Spring Cloud 1.0.0

Abstract: In this talk we will cover a new trend in distributed enterprise architecture – microservices. How the leading technology companies like Netflix and Amazon come to use that approach. How does it help them to scale their infrastructure. And how the newest set of tools in the Spring family would help you to apply those design principles in practice.

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.

Format: Talk (45 minutes)
Language: Russian
Speaker: Igor Khotin