Workshops

We will offer a few one day long workshops on 12th of May. These will start at 9:30 am and work until 5:00 pm with an hour break for a lunch.

The workshops will be delivered at:
Hotel Wyspiański
Westerplatte 15 St.
Kraków

The workshops are paid additionally. The price will include lunch or pizza.

List of workshops:

• Lambdas & Streams in Java 8
• Vaadin
• Microservices
• Elasticsearch Intro
• Elasticsearch Advanced

---

Lambdas & Streams in Java 8

Date: 12th May, 9:30 a.m
Price: 819 PLN (199 EUR) + 23% VAT

You will need to bring your laptop!

This workshop is devoted to the stream framework, which is an extension to the JDK collection framework. Streams offer an easy way to parallelize bulk operations on sequences of elements. The stream API differs from the classic collection API in many ways: it support a fluent programming style and borrows elements from functional languages. For instance, streams have operations such as filter, map, and reduce. The new language features of lambda expressions and method references have been added to Java for effective and convenient use of the stream API.

In this workshop we will introduce lambda expressions and method / constructor references, give an overview of the stream operations and discuss the performance characteristics of sequenial vs. parallel stream operations. Attendants are encouraged to bring their notebooks. We will not only explore the novelties in theory, but intend to provide enough information to allow for hands-on experiments with lambdas and streams.

---

Vaadin is a Java framework for building modern web applications that look great, perform well and make you and your users happy

Date: 12th May, 9:30 a.m
Price: 610 PLN (149 EUR) + 23% VAT

You will need to bring your laptop!

In most projects you and your team have as many front-end skills as back-end skills, or there are two different teams that need to integrate their code together. The first case is rare, the second costly. Vaadin is also the shortest way for pure Java programmers with few front-end skills to quickly create nice-looking and robust web applications running on the JVM.

At this workshop you’ll learn how to write web applications with Vaadin effectively. Given that you code only in Java, compile to bytecode you can integrate it easily with Spring, CDI, JDBC, JPA, etc. and build rich and robust application with minimum effort.

During this workshop I’ll guide you through the steps of development of a typical web application with Vaadin. This application will be a simple Chat application through which we will demo fundamental Vaadin features:

• First, we will some overview over Vaadin Components and Layouts, including sizing and alignment.
• After that we’ll move forward and architecture the code developed so far to be Object Oriented, then extend that basic application with Screen switching and Notifications.
• Finally, we will integration with the database and display the result into a table to add more business value into that.
• If time allows, we’ll add Push features so as to have a feature-complete Chat application and integrate with the Spring framework.

Forget all about JavaScript and all those fancy frameworks that become hype and are replaced after only a couple of months: after the workshop, participants will be able to build professional looking business applications on their own, with only knowledge of Java and Vaadin.

All that is going to be done within your favourite IDE with Java so you may use all the familiar things like OOP, static typing, refactoring, etc.

---

MicroServices - Let’s Build Some!

Date: 12th May, 9:30 a.m
Price: 819 PLN (199 EUR) + 23% VAT

You will need to bring your laptop!

It is one thing to talk about MicroServices. It is another altogether to have to build them.

After a brief introduction of MicroService principles, we will watch an animation of a micro­service environment. We will start with a pre­built skeleton microservice environment (message bus plus a couple of RESTful services running against it). We will then design and implement additional services to broaden the overall functionality. These additional services can be written in any language that will run on the participants laptop. While pairing is strongly encouraged, it is not required.

In the final stage, different pairs will implement different services, yet they will all run together implementing the animation.

We wrap up with the participants making observations on what they learned (and how it may be different from MicroServices they are currently implementing, if any). Outline/structure of the session

1. Introduction to MicroServices
2. Sample asynchronous MicroService application
3. Installation of sample MicroServices for the exercise
   • Installing RabbitMQ drivers for your language
   • Testing access to RabbitMQ server
4. Implementing a new MicroService
5. Discussion of effort
6. Implementing a second MicroService
7. Discussion and review of code
8. Implementing the application (teams develop different services that will work together)
9. Wrap up observations by participants

The focus of the workshop will be on:

1. Understanding how to design asynchronous service architectures,
2. Creating small, yet functional, services rather than larger services,
3. Reducing coupling to the bare minimum (JSON packets with extra fields ignored),
4. Debugging asynchronous systems.

---

Elasticsearch Intro

Date: 12th May, 9:30 a.m
Price: 1420 PLN (350 EUR) + 23% VAT until 5th May; 1620 PLN (400 EUR) + 23% VAT later

You will need to bring your laptop!

Attendees will go through a series of short lectures followed by exercises and Q&A sessions covering the following aspects of Elasticsearch:

1. Introduction to Elasticsearch
   • Installing Elasticsearch
   • Basic setup instruction with production tips
   • Document CRUD - adding/retrieving/updating/deleting
   • Elasticsearch REST API background
   • Searching and filtering
   • Data analysis - aggregations
2. Data structure
   • Introduction to types of data
   • Text analysis basics
   • Out of the box analysis
   • Defining custom analyzers
   • N-grams and shingles
3. Queries and relevance
   • Source filtering
   • Pagination
   • Choosing the right query for the job
   • Elasticsearch REST API background
   • Filtering
   • Relevancy optimization
4. Aggregations
   • Buckets vs metrics
   • Knowing aggregations types
   • Queries, filters and aggregations together
5. Document relationships
   • Objects
   • Nested data
   • Parent and child
   • Objects vs nested vs parent and child
   • Querying the structure
6. Performance and scaling basics
   • Bulks, Multiget, multisearch
   • Routing
   • Caching
   • Merging
   • Shards, replicas and sharding strategies
7. Monitoring and administration basics
   • Aliases
   • Cat API
   • SPM
   • Backing up

---

Elasticsearch Advanced

Date: 12th May, 9:30 a.m
Price: 1420 PLN (350 EUR) + 23% VAT until 5th May; 1620 PLN (400 EUR) + 23% VAT later

You will need to bring your laptop!

This workshop is for people who already know the core concepts of Elasticsearch -- like defining a mapping or running an aggregation -- and want to improve their skills and learn more advanced techniques.

In the context of scale and performance tuning, we will discuss core features, like queries, filters and aggregations, as well as more exotic features, like geo search, percolation and tools from the Elasticsearch ecosystem. There will be exercises that help get a better feel of the techniques presented, as well as Q&A sessions throughout the day. Please come with your own performance and scaling pain-points along with your laptop. There will be plenty of opportunities to get production tips & tricks that make things smoother.

Outline

• performance tuning
  • bulk, multiget and multisearch APIs
  • memory management: field/filter/page cache, OS cache and heap size; useful JVM parameters; using filters to make the best use of caches
  • using doc values to reduce heap usage
  • how often to commit: translog, index buffer and refresh interval
  • how data is stored: merge policies; store settings
  • how data and queries are distributed: routing, async replication, search type and shard preference
  • thread pools
• relevancy and aggregation tuning
  • defining custom analyzers; using them in multi-fields for better relevancy
  • using bool, multi-match and function score queries efficiently
  • making terms, significant terms and cardinality aggregations faster
• scaling out
  • multicast vs unicast
  • when to overshard, using more shards or more replicas for search concurrency
  • when to use dedicated master and client nodes
  • cluster configuration with different racks or availability zones
  • using time-based indices, routing and aliases
  • using node tiers for different indexing and search patterns on time-based data
  • using tribe nodes to scale independent sets of data
• beyond search
  • geo search: filtering and aggregations on points, geohashes and geo-shapes
  • using the percolator at scale
  • implementing fast and relevant did-you-mean and autocomplete suggestions
  • highlighting relevant fragments
• tools: using Logstash, rsyslog and/or Apache Flume to ingest lots of data into Elasticsearch