Oleg Šelajev
From ZeroTurnaround
Oleg is a Java developer, Evangelist and RebelLabs editor at ZeroTurnaround, with a focus on Continuous Delivery and Devops. He also enjoys spending time using Clojure, Github and Google docs. He is currently studying for a PhD on dynamic system updates and process migration and is a part-time teacher at the University of Tartu. As a technical writer for RebelLabs, Oleg regularly provides content for blogs and popular reports. In his free time he plays chess at a semi-grandmaster level, loves puzzles and solving problems. He is a geek but loves to hang out with people.
Blog: http://rebellabs.com
Java SE
Java Bytecode Explained
If you never goofed around with assembler or machine code Java bytecode can seem an obscure piece of low-level magic. But sometimes things go really wrong and understanding that bit may be what stands between you and solving the problem at hand. This talk will introduce you the JVM and bytecode basics using tiny code examples. It's my hope that you'll walk out armed for the next battle with low-level issues. From the basics, to more advanced gotchas: * How to obtain the bytecode listings * How to read the bytecode * How the language constructs are mirrored by the compiler: local variables, method calls, autoboxing, exception handling, etc * How to manipulate Java bytecode at the load time in order to achieve the customized behavior
Java SE
Unlocking the magic of monads in Java 8
This code-heavy session demystifies what monads are and outlines reasons why you would even want to introduce them into your code. We’ll take a look at the traditional definition for monads and offer a corresponding type definition in Java. We’ve selected a sample Java 8 implementation of a ‘Promise’ monad, which represents the result of async computation to help us answer practical questions about monads. Also, we'll go over the Laws of Monads and show that you can have a proper monad in Java, if you are brave enough to allow the underlying platform change the rules a bit.
PS. You won’t be penalised or ridiculed during this session for your (lack of) Haskell knowledge!
Java SE
Flavors of Concurrency in Java
Writing concurrent code that is also correct is unbelievably hard. Naturally, humanity has developed a number of approaches to handle concurrency in the code, starting from basic threads that follow the hardware way to do concurrency to higher level primitives like fibers and work-stealing solutions. But which approach is the best for you?
In this session, we'll take a look at a simple concurrent problem and solve it using different ways to manage concurrency: threads, executors, actors, fibers, monadic code with completable futures. All these approaches are different from the simplicity, readability, configuration and management point of view.
Some scenarios are better modelled with threads, while sometimes you're better off with actors. We'll discuss the benefits of each approach and figure out when it's worth pursuing in your project.