Polycon Barcelona 2017
6 - 8 Oct 2017 at Auditori AXA

4

Event-based architectures such as Event Sourcing provide multiple benefits: scalability, complexity management, auditing, etc. However, let’s face it, getting there is quite hard. We lack skills, expertise and courage. In this talk, I’m going to show you some tips and tricks to painless evolve your current architecture towards Event Sourcing, one small step at a time. We’ll start from an Hexagonal Architecture application and we’ll end up in the Event Sourcing doors. Marco Pivetta will do the rest in his talk about Event Sourcing next day. The path that we’ll follow is: - Hexagonal Architecture - Hexagonal Architecture with Domain Events - Stepping Stone Architecture (CQRS without Event Sourcing) - Event Sourcing

Symfony has always been a great way to create high-quality, professional apps. But actually building that app... well... it's never been as fast and simple as it should be. That's about to change! With Symfony 4, the community worked hard to remove as much boilerplate as possible, so that it's never been easier to create your app, whether it's a traditional one, or a cutting edge API first single page app. We'll practice the new experience of developing with Symfony, with a totally new way to build apps, where you start micro (just 1 file!) and smoothly scale up as big as you want. Need to add an admin generator to your app? No problem: run one command to install it, enable it and even configure & integrate it with sensible defaults. An hypermedia API? One command also to have everything wired for you. Whether you're new to Symfony or an old pro, you'll walk away happy for sure.

This talk presents use cases where highly connected data become bottlenecks in your applications. Recursive joins, non-maintainable sql-queries makes our developer life hard. Neo4j is a native graph database and has been built from the ground up to serve densely connected data, you will discover the foundations of such database, the use cases where it shines with real-world application examples.

David Pilato's Elasticsearch Workshop

Creating a single microservice is a well understood problem. Creating a cluster of load-balanced microservices that are resilient and self-healing is not so easy. Managing that cluster with rollouts and rollbacks, scaling individual services on demand, securely sharing secrets and configuration among services is even harder. Kubernetes, an open-source container management system, can help with this. In this talk, we will start with a simple microservice, containerize it using Docker, and scale it to a cluster of resilient microservices managed by Kubernetes. Along the way, we will learn what makes Kubernetes a great system for automating deployment, operations, and scaling of containerized applications.

Event Sourcing can look like an attractive solution for any of your applications, but does it actually pay off? What if it is all just buzzwords and no gain? We’ll look at how we implemented event sourcing in our own app, code-reviews.io: - what made us fast - what made us super slow - what made us cry This talk will give you a good idea of what kind of challenges you will encounter when approaching event sourcing for the first time.

Monitoring an entire application is not a simple task, but with the right tools it is not a hard task either. However, events like Black Friday can push your application to the limit, and even cause crashes. As the system is stressed, it generates a lot more logs, which may crash the monitoring system as well. In this talk I will walk through the best practices when using the Elastic Stack to centralize and monitor your logs. I will also share some tricks to help you with the huge increase of traffic typical in Black Fridays. - monitoring architectures - optimal bulk size - distributing the load - index and shard size - optimizing disk IO - monitoring queries - monitoring your monitoring system :P Takeaway: best practices when building a monitoring system with the Elastic Stack, advanced tuning to optimize and increase event ingestion performance.

Intent extraction is one of the most useful processes in order to build a Language Understanding Model. Email and VOC analytics, chatbots, information extraction tasks all rely on a powerful way of modelling intents and topics in conversations or documents. Those conversations and documents are so dynamic nowadays because of the amount of information that is created everyday and companies encounter a huge problem when trying to build an efficient model in order to analyze those texts. The setup processes associated are usually very long and when they work they get outdated very fast. In this talk we present how to use unsupervised AI, to extract meaningful information from big amounts of texts.

Build a real time recommendation engine from the ground up. Using a real life data set combined with a content-based and collaborative filtering to develop a multi faceted recommendation application. This training also covers how to make modeling decisions based on the types of questions being asked of the data and how to optimize your model and queries for maximum performance. Course Outline: - Introduction graph databases - Introduction to modeling a real time recommendation engine with Graph databases - How to optimize your model for maximum performance

CQRS (Command Query Responsibility Segregation) and ES (Event Sourcing) are challenging if approached for the first time, and especially if done from scratch. This full-day tutorial will lead give a basic understanding of what CQRS and ES are, including their complexities, advantages and pitfalls. We will help you modeling, designing and implementing an application relying on these architectural patterns, guiding you through: - Domain analysis via "Event Storming" basics - Architectural components involved in the CQRS setup - Architectural components involved in the ES setup - Data flow and rules of an ES system - Synchronous/Asynchronous dispatching - Potential architectural pitfalls - Implementing domain logic with aggregates - Projection design, efficient read-model implementations - Scaling the architecture - Concurrency issues - Writing CQRS+ES-friendly specifications in Gherkin, and specification-testing them with Behat