Lambda Core HardCore

Jarek Ratajski is a Java Developer since 1999. I love programming since my first line of code I did on the C64 in Basic. I have 15 Years experience developing JEE software working for various companies and projects. Currently I am working for CSS Versicherung in Luzern. I am Java developer during the days and Scala/ScalaJS at nights. I like to present my experience in public – so far speaked at conferences such as Devoxx, Voxxed Days, JUGs, Geecon, JdayLviv etc. I like to do shows – presenting the things just as they work – with live coding, demos and hacking.

What does it mean… Lambda? The talk will be about story behind this term, from a little bit more scientific point of view. Church Lambda calculus, Entscheidungsproblem and incompleteness theorem. Almost all of that will be presented in Java – in the language that you understand.

Since Java 8 – so called lambda expressions can be used by Java developers. But what does it mean… Lambda? The talk will be about story behind this term, from a little bit more scientific point of view. Church Lambda calculus, Entscheidungsproblem and incompleteness theorem. Almost all of that will be presented in Java – in the language that you understand. And of course you can later impress your friends with some impressive math tricks. There are going to be shown some very crazy code pieces such as perfectly unusable implementation of boolean (based on lambda expressions). Come and see what purely functional really means.

Migrating to Microservice Databases: From Relational Monolith to Distributed Data

Edson Yanaga, Red Hat’s Director of Developer Experience, is a Java Champion and a Microsoft MVP. He is also a published author and a frequent speaker at international conferences, discussing Java, Microservices, Cloud Computing, DevOps, and Software Craftsmanship. Yanaga considers himself a software craftsman, and is convinced that we all can create a better world for people with better software. His life’s purpose is to deliver and help developers worldwide to deliver better software faster and safely – and he can even call that a job! http://www.yanaga.me

The question that every enterprise developer asks when confronted with Microservices is: what about my database? Come to this session to see how zero downtime migrations and different data integrations strategies can help you to break your monolithic relational database!

In a distributed system with multiple moving parts, which is the case of Microservices, we can’t allow that a single complement downtime breaks down the entire system. Dealing with stateless code is easy, but it gets much harder when we have to deal with persistent state. In this scenario, zero downtime migrations are paramount to guarantee integrity and consistency. Within all the Microservices characteristics, undoubtedly the one that creates more perplexity is the “one database per Microservice”. However, very few teams have the privilege of starting something from scratch: most of the times they have a legacy database that will survive any new implementation. In legacy systems you traditionally have a model that adopts transactions, strong consistency, and CRUD. In order to guarantee integrity and consistency with zero downtime, we must reassess some of these concepts. In this talk we’ll discuss strong and eventual consistency, CRUD and CQRS, Event Sourcing, and how these techniq…

ThinkAsync in Java 8

Dmitry Alexandrov is a passionate Java developer with 10+ years experience, BGJUG co-lead, big fan of Java EE, blogger, speaker. Speaker at: – Lambdas and default methods in Java 8, Java2Days Sofia, Bulgaria, 2013, slides: on site; – JavaScript on JVM: Acquaintance with Nashorn and Avatar.js, Java2Days Sofia, Bulgaria, 2014, slides: on site; – Java(Script) on JVM, Joker Conference St. Petersburg, Russia, 2015, slides: http://www.slideshare.net/dalexandrov/javascript-on-jvm-54679017; – Seminars, Hackathons, Adopt OpenJDK, Big Conference: The Story of Our JUG [BOF3150], JavaOne, San Francisco, USA, 2015 – Nashorn extended session, JUG.ru, St. Petersburg, Russia, 2016; – JBatch.. or not such a big data, Joker Conference, St. Petersburg, Russia, 2016, slides: http://www.slideshare.net/dalexandrov/jbatch-67221346 Leaded several lectures and hand-ons regarding JDK development and Lambdas in the local JUG. http://www.tomitribe.com/blog/2016/03/developing-batch-applications-with-tomee/ https://blogs.oracle.com/nashorn/entry/using_nashorn_with_intellij

The parallel infrastructure of Java and JVM itself has evolved greatly in 21 years. It has made it though raw threads, execution pools, concurrency package extensions, as well as other frameworks like actors that found spread in different JVM languages like Scala for example. But developing a parallel/concurrent program is not a trivial task and not only in Java. In order to simplify the approach to concurrent programming and unlock the multicore performance the reactive paradigm was introduced adopting the functional programming style. The CompletableFuture coming out of the box in Java8 opens the full potential of this approach. In the session we will see a brief evolution of the concurrency in java and describe how we got to CompletableFuture, explore it, and see how we could use it.

Mutation testing

Rafal Leszko is a Java developer at Google. Trainer and speaker at international conferences (Devoxx Morocco, Voxxed Days Thessaloniki). In the past he worked in a number of companies and scientific organizations: CERN, AGH University, Luxoft and more. His roles varied from a team lead, trainer, PhD researcher to developer, but one thing remains unchanged: he loves to be as active as possible, looks for challenges and has a lot of creative ideas (he was the one to introduce the Luxoft Lunch & Learn initiative).

How well tested is your system? How do you measure it? Code coverage can give you the answer, however can we trust our unit tests? Trust me or not, but I used to work for the investment banking industry in a big project where a lot of unit tests had no assertions (!). And yes… the coverage was very high.

Mutation testing is a method to check the quality of your unit tests and show more reasonable code coverage reports. In this session I will describe the idea of mutation testing and show a live example with the use of PIT Mutation Testing framework.

Visualizing Bintray operations, with the Firehose Event API and the ELK stack, on Docker

Michael Hüttermann is system architect and delivery engineer and a leading subject matter expert for Continuous Delivery, DevOps and SCM/ALM. He has written a couple of books including the first ones on DevOps (“DevOps for Developers”, Apress, 2012) and Agile ALM (“Agile ALM”, Manning, 2011). He was recognized to be a Oracle Java Champion in 2006. More information: http://huettermann.net.

This interactive talk integrates a best-of-breed tool chain including – Bintray, for managing your binaries – ELK, for gathering and visualizing metrics – Jenkins 2, for defining and running Continuous Delivery pipelines – Docker, for running and managing apps in an isolated fashion. The demo goes through the nuts and bolts and focuses on a developers’ perspective.

Pain of growing up, and moving to large scale

Vladimir Dejanovic is the founder and leader of AmsterdamJUG. Software architect and Team Lead with long experience in developing high performance software in multiple programming languages and technologies with high load traffic. Always interested in cool new stuff, Free and Open Source software Speaker at JavaOne, Devoxx BE and Devoxx US

Although software is deployed for a long time now, not everyone is exposed to it. In big companies developers usually were not involved, while in small companies in most cases scale wasn’t big, so deploying also wasn’t thought so much as a big of a deal. With move to DevOps and having successful “startups” landscape is changing a lot, however a lot of companies and engineers are still struggling with deploying software, especially on a large scale were rules of the game are on completely different level. In case of transition from small to big successful company deployment process can easily be one of the key factors deciding if company will make it or not. Although tools like Kubernetis and similar are designed to solve lot of this problem,in most cases from my experience companies are still not using them in amount they should, and are still relying on “old” techniques for deploying software into production. Also very often articles and blog posts usually point out only good part…

You built your product, put it on server, and it flew like a rocket. Now you need to move to larger scale, but how ? How to go from here ? Deploying software isn’t always the first thing on developers mind, while they work on some software. However as you start moving to larger scale your deployment process can make you or break you. It comes with pain and cruel truth of how good your deployment process really is. Join me while I address pain, issue and problems of deploying software on Large Scale. I will talk about some known approaches and their pro’s and con’s. Also I will share some tips and tricks into making deploying software on large scale easier. All of this come from my personal experience while working on this type of systems.

High-Performance Hibernate

Vlad Mihalcea is a Hibernate Developer Advocate. He spoke at Devoxx France, Voxxed Days Bucharest, JavaZone. This is a list of presentations that he’s been giving in 2016: https://vladmihalcea.com/presentations/

Hibernate is the most popular JPA provider and knowing its inner-workings can make the difference between a high-performance enterprise application and one that barely crawls. This presentation goes through the most common performance bottlenecks issues like exotic mappings, too much flushing, inappropriate queries, JDBC batch updates misuse, and suboptimal result set fetching. Aside from common anti-patterns, I will also present some very useful Hibernate features like the enhanced identifier generators, caching strategies, and bytecode enhancements.

I have a stream: Going reactive with Spring Data

Mark Paluch is a Software Craftsman working as Spring Data Engineer at Pivotal and lettuce Redis driver Project Lead. He is a member of the CDI 2.0 expert group and passionate about open source software.

Data access and application scalability are closely related. Applications employ threads until they are done with their work while most of the time is waiting for I/O. Reactive infrastructure shifts responsibilities to where they can be handled best. It’s a move towards data streaming that does not require upfront fetching and therefore optimizes memory and computational resources. This talk covers what a stream is and how reactive data access leverages scalability bounds by applying the most natural way of data access with Spring Data and Project Reactor. If you are a developer looking to consume data in a functional reactive style, this is your chance to gain the experience how your application can benefit from streaming data access and to learn why not everything should be reactive.

Turbo Charge CPU Utilization in Fork/Join Using the ManagedBlocker

Heinz Kabutz writes the popular “The Java Specialists’ Newsletter” read by tens of thousands of enthusiastic fans in over 138 countries. To sign up, visit http://www.javaspecialists.eu

Fork/Join is a framework for parallelizing calculations using recursive decomposition, also called divide and conquer. These algorithms occasionally end up duplicating work, especially at the beginning of the run. We can reduce wasted CPU cycles by implementing a reserved caching scheme. Before a task starts its calculation, it tries to reserve an entry in the shared map. If it is successful, it immediately begins. If not, it blocks until the other thread has finished its calculation. Unfortunately this might result in a significant number of blocked threads, decreasing CPU utilization. In this talk we will demonstrate this issue and offer a solution in the form of the ManagedBlocker. Combined with the Fork/Join, it can keep parallelism at the desired level.

Developing modern web applications using Meteor and MongoDB

Aleksey Savateyev is a senior architect at MongoDB and works with partners and Fortune 100 companies on building their applications on top of MongoDB database. His primary focus is building web and cloud services – he served as a Director of Product Management for Yahoo’s private cloud, as well as senior software architect for Microsoft Azure, built startups and development teams in few companies and holds a master’s degree in Computer Science.

This talk will walk you through the process of building fully-featured application with Meteor and MongoDB and show tips and tricks to scale and optimize this application once it becomes widely used.

MongoDB is a leading NoSQL database in the world and a primary choice for web developers. Meteor is one of the most advanced full stack development frameworks that has MongoDB at its core (both on server and the client!). This workshop will walk you through the process of building fully-featured application with Meteor and MongoDB and show tips and tricks to scale and optimize this application once it becomes widely used.