Exam Objectives Download Exam PDF Questions Answers Popular PMI Exam Guide for free, PMI-001 Cert Download400-251 pdf | Questions Answers Vendor: Cisco Exam Code: 700-020 Exam Name: Cisco Video Sales Essentials VSE Version: DemoQUESTION 1 What is a function of an endpoint? A. To act as a traffic cop for network communication. B. To provide an audio and video interface for the user. C. To join 3 or more participants in a meeting. D. To schedule calls. Correct Answer: B QUESTION 2 Which call control solution 700-020 dumps supports messaging, meeting and calling? A. Spark B. UCM C. Expressway D. HCS Correct Answer: A QUESTION 3 What is a common manufacturing industry need? A. Building guest loyalty through customer satisfaction. B. Offering more ways for students to connect to experts. C. Addressing increased global competition. D. Simplifying personal services for customers. Correct Answer: D QUESTION 4 What is a unique feature of Spark? A. Firewall traversal for premise-based solutions. B. Persistent content available to room participants. C. Advanced video routing on video-only networks. D. Support of unified communications pass4itsure with contact center. Correct Answer: B QUESTION 5 According to Gartner, how much technology spending will by outside of IT by the year 2020? A. 50% B. 75% C. 85% D. 90% Correct Answer: D QUESTION 6 What is at the center of collaboration? A. People B. PlacesC. Millennials D. Meetings Correct Answer: A QUESTION 7 What is a function of a recording solution? A. To act as a traffic cop for network communication. B. To schedule calls. C. To provide an audio and video interface for the user. D. To share lectures, training sessions, meetings and events on demand. Correct Answer: D QUESTION 8 Which management solution works with endpoints registered to UCM, VCS and Expressway? A. TMS B. CMA C. CMR D. Prime Correct Answer: A QUESTION 9 Which on-premise call control solution supports unified communications and contact center? A. Expressway B. UCM C. HCS D. Spark Correct Answer: B QUESTION 10 Which conferencing solution is designed for messaging, meeting, calling and persistent content sharing? A. CMR B. Cisco Meeting Server C. Telepresence Server D. Spark Correct Answer: B QUESTION 11 What can a Cisco solution enable an Education pass4itsure Industry customer to do? A. Let citizens join meetings, share applications, and use video. B. Accommodate evolving student learning styles through mobile video applications. C. Make experts or specialists available face-to-face even when they are not at the same location as the purchaser. D. Gain visibility into and streamline the supply chain. Correct Answer: B QUESTION 12Which endpoint provides MB6-898 dumps the highest quality and most natural meeting experience? A. MX200 B. MX800 C. SX10 D. IX5000 Correct Answer: D React.sphere.it

ReactSphere is 3-day conference dedicated to

Reactive system design

April 15-17, 2018 | Kraków, Poland Get tickets

About the conference

ReactSphere is a conference focused on Reactive Programming and Reactive System Design.

Let's dive deep into the principles of building responsive distributed systems handling huge amounts of data with near-realtime performance. Microservice Architectures, Actors, Messaging Systems, methods for domain analysis, and more will be covered during lively talks.

Agenda

Day 1 - Sunday

Day 2 - Monday

Day 3 - Tuesday

Workshop Advanced Akka Streams

This workshop is aimed at people already familiar with Akka Streams (part of Akka library). We will take a close look at some valuable but less frequently used built-in stages, substreams facility and creating custom stages and complex flows.

Host: Jan Pustelnik. Free entrance. Register here

14:15 to 18:15

Workshop on akka remoting, clustering, and supervision

The purpose of this workshop is to try out few basic, but probably most useful Akka mechanisms. We will build distributed system for decrypting hashed passwords. Input data - encrypted text - will be delivered by the external remote Akka server. Client library, which we will be implementing during this workshop, will be responsible for fetching encrypted passwords, decrypting them, and sending them back to the central server. Whole workshop is divided into few self-sufficient sections. We will start with most basic prototype, and will try to gradually make it more efficient and less error prone.

More details here

Hosts: Krzysztof Borowski & Piotr Kukiełka, Free entrance, Register here

14:15 to 17:15

Registration


8:00 to 9:00

Conference Opening


9:00 to 9:05

KEYNOTE: Present/future vision for data+AI


Presented by Anthony Stevens
Anthony Stevens IBM
9:05 to 9:35

KEYNOTE: Reactive is a Product


The Reactive Manifesto was released almost 4 years ago, and while many teams and companies have adopted its principles, many are still unsure how to go about the work to implement resilience and elasticity. Who on a team should advocate for the work, define the requirements, establish success criteria and more? And how should those individuals interact with other team members to set priorities and drive the implementations? In this talk, I will go through practices I have successfully established and enabled to address these issues, and provide a road map for you to do the same.
Jamie Allen
9:40 to 10:10

KEYNOTE: Tools of the Mind


Tools are a force multiplier, without them we would still be toggling code into machines with switches. Tooling is powerful and we use them every day to empower us. Rather than focusing on software tooling we will explore mental tooling that will help to improve your productivity, happiness and career prospects.
Rory Graves Ensime
10:15 to 10:45

A reactive architecture based on Vert.x and Kubernetes


The combination of microservices and the availability of easy to operate cloud infrastructures has changed the way we build software. Where classic 3-tier applications dominated only a few years ago we today see highly distributed microservice infrastructures. At the same time the expectations of our customers advanced at almost the same pace. Downtimes are a far more serious issue as they will drive them away to the competition. Classic application design and the way we used to build software hit there limits a while ago and new paradigms were required. This talk will show how the combination of a reactive application framework like Vert.x, a Kubernetes based infrastructure, Scala and a lot of fun give us a fully reactive architecture … and happy customers. In this talk I will introduce the core concepts of Vert.x, its event bus, the new Scala-integration and how this all plays together with Kubernetes. Expect to see a lot of code and to learn how a developer can effectively develop locally using Vert.x and Kubernetes together.
Jochen Mader Codecentric
11:00 to 11:40

How to be reactive with gRPC

gRPC is a modern RPC framework that avoids the main errors from the past (SOAP, REST, …). It is both fast and asynchronous, supports streaming and a wide variety of languages (java, c, go, js, …). Although not on the official list of programming languages, Scala is well supported thanks to the excellent ScalaPB library, which in addition offers the possibility to plug-in its own code generators. This is a great feature as it allows to develop new interfaces for gRPC (e.g akka-stream, Monix). Akka-streams (and monix) are reactive abstractions that propagates back-pressure up to the source. Unfortunately gRPC-java callbacks mechanism doesn’t seem to provide anything of this sort (see the StreamObserver interface) but if you scratch the surface you’ll see that back-pressure is actually present right at the heart of gRPC which makes it possible to build truly reactive gRPC applications in Scala.
Damien Bailly Cake Solutions
11:50 to 12:20

Monitoring Akka with Kamon 1.0


Insights into the inner workings of an application become crucial latest when performance and scalability issues are encountered. This becomes especially challenging in distributed systems, like when using Akka cluster. A popular open-source solution for monitoring on the JVM in general, and Akka in particular, is Kamon. With its recently reached 1.0 milestone, it features means for both metrics collection and tracing of Akka applications, running both standalone or distributed. This talk gives an introduction to Kamon 1.0 with a focus on its metrics features. The basic setup using Prometheus and Grafana will be described, as well as an overview over the different modules and its APIs for implementing custom metrics. The resulting setup allows to record both, automatically exposed metrics about Akka’s actor systems, as well as metrics tailored to the monitored application’s domain and service level indicators. Finally, learnings from a first-time user experience of getting started with Kamon will be reported. The example of adding instrumentation to EMnify’s mobile core application will illustrate, how easy it is to get started and how to kill the Prometheus on a daily basis.
Steffen Gebert EMnify
12:30 to 13:00

Lunch Break


13:00 to 14:00

Applying principles of chaos engineering to Serverless


The motivation of this talk is to provoke the audience to think about the failure modes that exists in their serverless architecture and how they can discover them early by applying the principles of chaos engineering. Serverless architectures have more inherent chaos and complexity than their serverful counterparts, and, we have less control over their runtime behaviour! For instance: smaller unit of deployment, means there are more of them, and each of these “units” is a boundary that needs to be hardened (for security and failure resilience) it’s more difficult to harden around the boundaries simply because there are so many more of them more intermediate services (dynamodb, kinesis, SNS, S3, API Gateway to name a few), each with their own failure modes there are more configurations overall (timeout, IAM permissions, application config, etc.) therefore more opportunities for misconfiguration
Yan Cui DAZN
14:00 to 14:40

I hate getting stuck in a jam on the highway! A story about connecting microservices.


Working on a real time bidding platform is a demanding job. Response latency is critical and high traffic volume affects how we utilize available resources. All this leads to greatest challenge – distributing work over microservices. I will present real life problems that forced us to redesign our microservice communication so that applications stay performant and resilient. I’ll also show how we learned from previous mistakes to create a small and reusable library on top of netty.io and aeron.io that aids to readily implement business features.
Paweł Kamiński Codewise
14:50 to 15:30

Stream Driven Development with Akka Streams


Akka Streams is a well-known Reactive Streams implementation that helps you build asynchronous, data-intensive apps with no predetermined data volumes. But how would you leverage its full power to design complex, Akka-backed reactive pipelines? At HomeAway we devised an approach to tackle this problem, combining elements of DDD with the abstraction power of the Akka Streams model. Here we’ll discuss useful patterns to – reason about your stream and identify its building blocks – type-drive the implementation – handle failure – instrument your application for logging and monitoring purposes
Stefano Bonetti HomeAway
15:45 to 16:25

Kotlin + Spring 5.0 Web Flux


Almost nobody likes big changes. This includes management and developers. It is often very hard to convince people to try something new. Even if the old way is pathetic, leads to bugs and does not fit to a problem. If you do not believe in that try to convince any JavaEE/ Spring team to use something else. Even though both platforms are quite dated and do not really enable writing clean code. They are even worse if you try functional programming. The way I often do is to introduce only a small improvements, to the extent that might get accepted by the team and managers. Such a trick is to use Kotlin as Java++ and Spring 5… as just a new version of Spring. After a while it can appear that the “new Java” is written totally functional, with very little or none mutability. And the new Spring works without annotations and so called beans. Eventually, we get code that is more similar to Scala/Akka-HTTP stack… that would not be ever accepted.
Jarosław Ratajski Engenius CH
16:35 to 17:25

Beyond the hype: reactive vs traditional microservices


For some time now IT media were sparkled with success stories of teams who went reactive and reaped benefits of paradigm change but in most cases it was not an apples to apples comparison – just legacy stack vs new, shiny async-based technology. In this talk we want to deliver hard, cold numbers about pros, cons, benefits and pains of selecting reactive technologies for your company’s application stack compared to traditional sync webservices. Is reactive microservices approach really worth the effort or are we all drinking the kool-aid?
Paweł Dolega, Marcin Zagórski & Łukasz Biały VirtusLab
17:40 to 18:20

After Party


18:30 to **

KEYNOTE: Reactive programming: lessons learned


Reactive programming enables amazing things. Highly scalable systems consuming just a fraction of CPU compared to ordinary applications? Sure. Responsive, low latency and high throughput? No problem. Small memory and OS footprint? Out-of-the-box. Any reason not to love reactive? I will share some of my experiences with reactive programming and systems. Where it shines and where it was an over-engineering. What are the hidden costs and common mistakes? How to convince your teammates to start the reactive journey. And more importantly: how to convince your teammates, that going reactive is a dead end. On a case-by-case basis.
Tomasz Nurkiewicz Allegro
9:00 to 9:40

Events-first microservices with Lagom


Even with microservices starting to become a commodity, a lot of implementations still fail as microliths. To ensure the autonomy of services and its development process, strong coupling between services should be limited as much as possible. The way to achieve this is to isolate the inner working of a service at cost and to switch from a commanding and synchronous to a promising and asynchronous way of communication between services. A route to success is to stop architectural design from a perspective of services with well-defined and canonical relationships and to switch to a model which is based on the production of immutable domain events. Not only does this way of architecting ensure a better match with the things that happen within your business. The focus on the timeline of facts over the structures producing them ensures far less coupling within your system. In this talk, I will share how Lagom embraces this way of thinking by pushing events-first development as a default. From the event-sourcing principles within aggregates to the message-broker functionality between services, I’ll give you the background of the elements which are in place to shift your system to an event-driven microservice architecture.
Gideon de Kok & Kenny Baas Xebia
9:55 to 10:35

From monolith to microservices – Reification and reactification


Migrating from a monolithic model to a microservices model can be challenging as we try to decouple implementation and wiring between different parts of the system. We’re going to take a look at how we can extract then encapsulate implementation and execution in an external service. From here we’ll explore different ways of communication and how we can test the whole system.
Tudor Palanga Expedia
10:45 to 11:25

Practical Reactive Streams with Monix


Stream processing is a hot topic today and it’s easy to get lost among all the possibilities. In this live coding session we will explore the Reactive Streams approach used by the Monix project – one of the Scala implementations of the Reactive Streams concepts. On an almost real-life example we’re going to walk through both the basics and some more advanced usages of the library.
Jacek Kunicki SoftwareMill
11:40 to 12:20

Things learned from using Event Sourcing and CQRS patterns


There are pros and cons of using Event Sourcing and Command Query Responsibility Segregation patterns in our projects. Poorly implemented will bring chaos, well implemented can be a rescue for our software. I will share my experience of using them in projects I was participating in so far.
Maciej Ciołek Codeheroes
12:30 to 13:00

Lunch Break


13:00 to 14:00

Alpakka – a new world of Connectors for Reactive Enterprise Integration


Connecting your programs with various upstream and downstream systems is a frequent problem. Until recently if one wanted to integrate an Akka Streams application with the world outside, the tool of choice would be the Akka Camel module. However, this frequently resulted in non-intuitive, complex and hard to test implementations. With the recent advent of Alpakka library, you can integrate in a reactive, backpressure-preserving way. In this talk we will: – introduce the Alpakka library – do a short walk through sample modules – show how to write your own integration (and make it a part of Alpakka).
Jan Pustelnik Actyx
14:00 to 14:40

Anomaly detection of monitoring data in Scala ecosystem


Machine learning for programmers could be a tricky subject. We’d like to present a system that predicts the potential user over charging problem by detecting anomalies in the monitoring data. It wouldn’t be a data scientist talk, rather a one focused on implementation details using tools from Scala ecosystem. What’s difficult in the billing system for the shared cloud infrastructure? Noisy neighbour is an effect of monopolisation of bandwidth, disk I/O, CPU and other resources. Virtual machines and applications that share the infrastructure suffer from uneven cloud network performance. In such environment, without proper analysis of real-time monitoring data, it’s not easy to distinguish a valid complaints from ungrounded grumbles. Akka Streams with Kafka, Spark and Cloudant is a nice mixture of tools that can help you build a robust streaming solution without a lot of effort in both development and maintenance phase. The presentation is dedicated to software developers, system architects and data scientists who would like to learn the quick and painless way of building reactive systems.
Rafał Bigaj & Bartłomiej Małecki IBM
14:50 to 15:30

Cloud Native Akka & Kubernetes: the holy grail to elasticity?


I have been in love with Akka since I first saw it. Akka is the most mature choice to implement the traits of the Reactive Manifesto, thanks to the Actor model. Resilience is enabled by asynchronous message passing and Actor supervision. Location transparency, message routing and the “share nothing” approach enable seamless scalability, but once our app is deployed we need to rely on some external infrastructure to automatically scale up or down our services. At this point, Akka alone is not sufficient anymore. What else do we need? I found Docker & Kubernetes to be a perfect match for clustered Akka applications running in the cloud. Thanks to the Kubernetes API, one can write infrastructure logic that complements the business logic. This leads to a general approach of infrastructure-as-code tailored to each different business case, which in turn lets companies achieve maximum efficiency and resource usage. During this talk I will cover features from both Akka and Kubernetes, plus example code in Scala: familiarity with these technologies is recommended. My example will rely on Google Cloud infrastructure.
Fabio Tiriticco Fabway
15:45 to 16:25

Asynchronous Programming: Scala.concurrent and Monix! What?


In the context of executing a task, a synchronous execution indicates that the program waits for the result of the first task before moving on to another task. In contrast, an asynchronous execution does not wait for the result of the first task and it starts executing another task immediately after the first task has begun. Both Futures & Promises, and Monix are Scala libraries that allow users to efficiently perform asynchronous operations.

This talk will introduce the Futures & Promises library in Scala.concurrent and Monix. We will walk through several examples that demonstrate how to use Futures & Promises, and Monix. In addition, the talk compares and contrasts the similarities and differences between the two libraries. Furthermore, we will discuss some best practices in debugging asynchronous systems.
Yifan Xing Northeastern University
16:35 to 17:15

Fast Data Architecture at XITE


Fast Data is emerging as a new approach to data processing. While Big Data relied mostly on batch processing, Fast Data brings us the power of streaming, where information is processed as soon as it becomes available. XITE (https://xite.com) has worked hard to embrace Fast Data and will share their experience with us.
Roman Ivanov XITE
17:30 to 18:10

Conference Closing


18:10 to 18:15

CloudSphere - a small companion event to Sphere.IT

More details here

19:15 to 21:45

FrontendSphere - a small companion event to Sphere.IT

More details here

19:15 to 21:45

Keynote speakers

Jamie Allen
Jamie Allen
Tomasz Nurkiewicz
Tomasz Nurkiewicz Allegro

Jamie Allen

Bio:
Jamie Allen has been a part of the Scala development community for over 10 years, and is formerly an employee of Typesafe/Lightbend. He is the author of Effective Akka (O’Reilly, 2013), and the co-author of Reactive Design Patterns (Manning, 2017). Jamie is a computer languages enthusiast who enjoys writing performant code that most efficiently leverages available resources.

Topic:
Reactive is a Product

Abstract:
The Reactive Manifesto was released almost 4 years ago, and while many teams and companies have adopted its principles, many are still unsure how to go about the work to implement resilience and elasticity. Who on a team should advocate for the work, define the requirements, establish success criteria and more? And how should those individuals interact with other team members to set priorities and drive the implementations? In this talk, I will go through practices I have successfully established and enabled to address these issues, and provide a road map for you to do the same.

Jamie Allen

Tomasz Nurkiewicz

Bio:
Spent half of his life on programming, for the last decade professionally in Java land. Loves back-end and data visualization. Passionate about alternative JVM languages. Disappointed with the quality of software written these days (so often by himself!), hates long methods and hidden side effects. Interested in charting, data analysis and reporting. Believes that computers were invented so that developers can automate boring and repetitive tasks. Also their own.

On a daily basis works in the e-commerce sector. Involved in open-source, DZone’s Most Valuable Blogger, used to be very active on StackOverflow. Author, trainer, conference speaker, technical reviewer, runner. Claims that code not tested automatically is not a feature but just a rumour. Wrote a book on RxJava for O’Reilly.


Topic:
Reactive programming: lessons learned

Abstract:
Reactive programming enables amazing things. Highly scalable systems consuming just a fraction of CPU compared to ordinary applications? Sure. Responsive, low latency and high throughput? No problem. Small memory and OS footprint? Out-of-the-box. Any reason not to love reactive? I will share some of my experiences with reactive programming and systems. Where it shines and where it was an over-engineering. What are the hidden costs and common mistakes? How to convince your teammates to start the reactive journey. And more importantly: how to convince your teammates, that going reactive is a dead end. On a case-by-case basis.

Tomasz Nurkiewicz Allegro

The speakers

Kenny Baas
Kenny Baas Xebia
Damien Bailly
Damien Bailly Cake Solutions
Łukasz Biały
Łukasz Biały VirtusLab
Rafał Bigaj
Rafał Bigaj IBM
Stefano Bonetti
Stefano Bonetti HomeAway
Maciej Ciołek
Maciej Ciołek Codeheroes
Yan Cui
Yan Cui DAZN
Paweł Dolega
Paweł Dolega VirtusLab
Steffen Gebert
Steffen Gebert EMnify
Paweł Kamiński
Paweł Kamiński Codewise
Gideon de Kok
Gideon de Kok Xebia
Jacek Kunicki
Jacek Kunicki SoftwareMill
Jochen Mader
Jochen Mader Codecentric
Bartłomiej Małecki
Bartłomiej Małecki IBM
Roman Ivanov
Roman Ivanov XITE
Tudor Palanga
Tudor Palanga Expedia
Jan Pustelnik
Jan Pustelnik Actyx
Jarosław Ratajski
Jarosław Ratajski Engenius CH
Fabio Tiriticco
Fabio Tiriticco Fabway
Yifan Xing
Yifan Xing Northeastern University
Marcin Zagórski
Marcin Zagórski VirtusLab

Kenny Baas

Bio:
Kenny Baas is a Software Engineer and Consultant focusing on software quality at Xebia. He mentors teams by using practices and techniques from Domain Driven Design, Behaviour Driven Development, Test Driven Development and Continuous Delivery.

He is an advocate for collaborating in open spaces. By using techniques such as Example Mapping and Event Storming, to engineer requirements and design of software along with business- and stakeholders.

With these methods, he aims to create a transparent collaborative domain space with constant and instant feedback of the software that is being built.

Besides his daily work, he also organizes meetups for Behaviour Driven Development NL and Domain Driven Design NL.

Topic:
Events-first microservices with Lagom
(Joint talk with Gideon de Kok)

Abstract:
Even with microservices starting to become a commodity, a lot of implementations still fail as microliths. To ensure the autonomy of services and its development process, strong coupling between services should be limited as much as possible. The way to achieve this is to isolate the inner working of a service at cost and to switch from a commanding and synchronous to a promising and asynchronous way of communication between services.

A route to success is to stop architectural design from a perspective of services with well-defined and canonical relationships and to switch to a model which is based on the production of immutable domain events. Not only does this way of architecting ensure a better match with the things that happen within your business. The focus on the timeline of facts over the structures producing them ensures far less coupling within your system.

In this talk, I will share how Lagom embraces this way of thinking by pushing events-first development as a default. From the event-sourcing principles within aggregates to the message-broker functionality between services, I’ll give you the background of the elements which are in place to shift your system to an event-driven microservice architecture.

Kenny Baas Xebia

Damien Bailly

Bio:
I am a senior software engineer who enjoys developing new products. I started as a consultant working with HP and Orange on telecommunication systems. I then joined a startup where I developed large-scale machine learning systems for telecom operators worldwide. Since I joined Cake Solutions I helped to build modern micro services and distributed systems.

Topic:
How to be reactive with gRPC

Abstract:
gRPC is a modern RPC framework that avoids the main errors from the past (SOAP, REST, …). It is both fast and asynchronous, supports streaming and a wide variety of languages (java, c, go, js, …).
Although not on the official list of programming languages, Scala is well supported thanks to the excellent ScalaPB library, which in addition offers the possibility to plug-in its own code generators.
This is a great feature as it allows to develop new interfaces for gRPC (e.g akka-stream, Monix).
Akka-streams (and monix) are reactive abstractions that propagates back-pressure up to the source.
Unfortunately gRPC-java callbacks mechanism doesn’t seem to provide anything of this sort (see the StreamObserver interface) but if you scratch the surface you’ll see that back-pressure is actually present right at the heart of gRPC which makes it possible to build truly reactive gRPC applications in Scala.

Damien Bailly Cake Solutions

Łukasz Biały

Bio:
Polyglot full-stack developer currently employing his enthusiasm for functional programming and quality coding at VirtusLab. Permanent learner with severe information dependency problem. Enjoys conversations about philosophy and all things related to mind’s inner workings. Loves mountains and hiking.

Topic:
Beyond the hype: reactive vs traditional microservices
(Joint talk with Paweł Dolega and Marcin Zagórski)

Abstract:
For some time now IT media were sparkled with success stories of teams who went reactive and reaped benefits of paradigm change but in most cases it was not an apples to apples comparison – just legacy stack vs new, shiny async-based technology. In this talk we want to deliver hard, cold numbers about pros, cons, benefits and pains of selecting reactive technologies for your company’s application stack compared to traditional sync webservices. Is reactive microservices approach really worth the effort or are we all drinking the kool-aid?

Łukasz Biały VirtusLab

Rafał Bigaj

Bio:
System Architect with long successful record of building and leading teams. Skilled staff trainer and motivator. Additional experience in project management and the use of agile practices. Broad and practical knowledge in the area of the distributed systems, machine learning and web application development.

Topic:
Anomaly detection of monitoring data in Scala ecosystem

Abstract:
Machine learning for programmers could be a tricky subject. We’d like to present a system that predicts the potential user over charging problem by detecting anomalies in the monitoring data. It wouldn’t be a data scientist talk, rather a one focused on implementation details using tools from Scala ecosystem.

What’s difficult in the billing system for the shared cloud infrastructure?
Noisy neighbour is an effect of monopolisation of bandwidth, disk I/O, CPU and other resources. Virtual machines and applications that share the infrastructure suffer from uneven cloud network performance.
In such environment, without proper analysis of real-time monitoring data, it’s not easy to distinguish a valid complaints from ungrounded grumbles.

Akka Streams with Kafka, Spark and Cloudant is a nice mixture of tools that can help you build a robust streaming solution without a lot of effort in both development and maintenance phase. The presentation is dedicated to software developers, system architects and data scientists who would like to learn the quick and painless way of building reactive systems.

Rafał Bigaj IBM

Stefano Bonetti

Bio:
Stefano is a Staff Software Engineer working for HomeAway in London, UK. He has been developing large scale backend systems within the cozy boundaries of the JVM for a few years, and he has recently become passionate about the Scala ecosystem – especially all things Akka. He has contributed to Akka, Akka HTTP and Alpakka codebases.

Topic:
Stream Driven Development with Akka Streams

Abstract:
Akka Streams is a well-known Reactive Streams implementation that helps you build asynchronous, data-intensive apps with no predetermined data volumes. But how would you leverage its full power to design complex, Akka-backed reactive pipelines? At HomeAway we devised an approach to tackle this problem, combining elements of DDD with the abstraction power of the Akka Streams model. Here we’ll discuss useful patterns to

– reason about your stream and identify its building blocks
– type-drive the implementation
– handle failure
– instrument your application for logging and monitoring purposes

Stefano Bonetti HomeAway

Maciej Ciołek

Bio:
Event Sourcing, CQRS and Microservices Architecture enthusiast. Crazy about Scala language. Experienced software engineer and now Co-founder & CTO at Codeheroes

Topic:
Things learned from using Event Sourcing and CQRS patterns

Abstract:
There are pros and cons of using Event Sourcing and Command Query Responsibility Segregation patterns in our projects. Poorly implemented will bring chaos, well implemented can be a rescue for our software. I will share my experience of using them in projects I was participating in so far.

Maciej Ciołek Codeheroes

Yan Cui

Bio:
Yan is an experienced engineer who has worked with AWS for near 10 years. He has been an architect and lead developer with a variety of industries ranging from investment banks, e-commence to mobile gaming. In the last 2 years he has worked extensively with AWS Lambda in production, and he has been very active in sharing his experiences and the lessons he has learnt, some of his work has even made their way into the Well-Architected whitepaper published by AWS.

Yan is polyglot in both spoken and programming languages, he is fluent in both English and Mandarin, and counts C#, F#, Scala, Node.js and Erlang amongst programming languages that he has worked with professionally. Although he enjoys learning different programming languages and paradigms, he still holds F# as his undisputed favourite.

Yan is a regular speaker at user groups and conferences internationally, and he is also the author of AWS Lambda in Motion and a co-author of F# Deep Dives. In his spare time he keeps an active blog where he shares his thoughts on topics such as AWS, serverless, functional programming and chaos engineering.

Topic:
Applying principles of chaos engineering to Serverless

Abstract:
The motivation of this talk is to provoke the audience to think about the failure modes that exists in their serverless architecture and how they can discover them early by applying the principles of chaos engineering. Serverless architectures have more inherent chaos and complexity than their serverful counterparts, and, we have less control over their runtime behaviour! For instance: smaller unit of deployment, means there are more of them, and each of these “units” is a boundary that needs to be hardened (for security and failure resilience) it’s more difficult to harden around the boundaries simply because there are so many more of them more intermediate services (dynamodb, kinesis, SNS, S3, API Gateway to name a few), each with their own failure modes there are more configurations overall (timeout, IAM permissions, application config, etc.) therefore more opportunities for misconfiguration

Yan Cui DAZN

Paweł Dolega

Bio:
Head of Cloud & Reactive Systems / Partner @ VirtusLab

Software engineer / manager / entrepreneur. Worked in international corporations and small local software houses (two of which I co-founded). These days my weapon of choice is mostly Lightbend stack (Scala / Akka / Play / Spark) though I am trying to remain flexible and not be too orthodox.
Far more important than actual technology — I am really passionate about technological challenges and problems that technology is trying to solve. I like to work on things that matter.
Last but not least, infrequent conference speaker.

Topic:
Beyond the hype: reactive vs traditional microservices
(Joint talk with Łukasz Biały and Marcin Zagórski)

Abstract:
For some time now IT media were sparkled with success stories of teams who went reactive and reaped benefits of paradigm change but in most cases it was not an apples to apples comparison – just legacy stack vs new, shiny async-based technology. In this talk we want to deliver hard, cold numbers about pros, cons, benefits and pains of selecting reactive technologies for your company’s application stack compared to traditional sync webservices. Is reactive microservices approach really worth the effort or are we all drinking the kool-aid?

Paweł Dolega VirtusLab

Steffen Gebert

Bio:
Steffen codes at EMnify, a mobile virtual network operator (MVNO) running a custom-built mobile core network for the Internet of Things. He is eager about applying continuous delivery to this Akka-based environment and currently paving the road for it. Before joining EMnify in 2017, he was a researcher at the University of Würzburg and received his PhD for his thesis on software-based networks.

Topic:
Monitoring Akka with Kamon 1.0

Abstract:
Insights into the inner workings of an application become crucial latest when performance and scalability issues are encountered. This becomes especially challenging in distributed systems, like when using Akka cluster. A popular open-source solution for monitoring on the JVM in general, and Akka in particular, is Kamon. With its recently reached 1.0 milestone, it features means for both metrics collection and tracing of Akka applications, running both standalone or distributed. This talk gives an introduction to Kamon 1.0 with a focus on its metrics features. The basic setup using Prometheus and Grafana will be described, as well as an overview over the different modules and its APIs for implementing custom metrics. The resulting setup allows to record both, automatically exposed metrics about Akka’s actor systems, as well as metrics tailored to the monitored application’s domain and service level indicators. Finally, learnings from a first-time user experience of getting started with Kamon will be reported. The example of adding instrumentation to EMnify’s mobile core application will illustrate, how easy it is to get started and how to kill the Prometheus on a daily basis.

Steffen Gebert EMnify

Paweł Kamiński

Bio:
For last couple of years I’ve been working on real time bidding platform which introduces many architectural, scale and performance related problems. Even though I still try to stay passionate about what I’m doing and share my knowledge and learn from others at the same time.

Topic:
I hate getting stuck in a jam on the highway! A story about connecting microservices.

Abstract:
Working on a real time bidding platform is a demanding job. Response latency is critical and high traffic volume affects how we utilize available resources. All this leads to greatest challenge – distributing work over microservices.

I will present real life problems that forced us to redesign our microservice communication so that applications stay performant and resilient. I’ll also show how we learned from previous mistakes to create a small and reusable library on top of netty.io and aeron.io that aids to readily implement business features.

Paweł Kamiński Codewise

Gideon de Kok

Bio:
Having built software over the full range of the stack; from embedded systems, telephony systems, to end-user focused applications and data-processing architectures, Gideon learned the importance of building responsive, resilient, elastic and decoupled systems the hard way. Backed by this experience, Gideon helps organisations in building software in redesigned architectures which enable a more scalable, agile and sustainable way of software development.

A larger part of that focus lies in the design, implementation and creation of awareness of truly modular and autonomous services. Not only to improve overall reactive traits of that system, but to improve alignment within a business by separating and forming teams and functionality directly around the domains they try to model. Call it microservices, call it self-contained services, call it modular design, DDD or agile software architectures; Gideon’s focus is on helping organisations in mapping business and IT in the most optimal form.

Topic:
Events-first microservices with Lagom
(Joint talk with Kenny Baas)

Abstract:
Even with microservices starting to become a commodity, a lot of implementations still fail as microliths. To ensure the autonomy of services and its development process, strong coupling between services should be limited as much as possible. The way to achieve this is to isolate the inner working of a service at cost and to switch from a commanding and synchronous to a promising and asynchronous way of communication between services.

A route to success is to stop architectural design from a perspective of services with well-defined and canonical relationships and to switch to a model which is based on the production of immutable domain events. Not only does this way of architecting ensure a better match with the things that happen within your business. The focus on the timeline of facts over the structures producing them ensures far less coupling within your system.

In this talk, I will share how Lagom embraces this way of thinking by pushing events-first development as a default. From the event-sourcing principles within aggregates to the message-broker functionality between services, I’ll give you the background of the elements which are in place to shift your system to an event-driven microservice architecture.

Gideon de Kok Xebia

Jacek Kunicki

Bio:
I’m a passionate software engineer living in the JVM land – mainly, but not limited to. I also tend to play with electronics and hardware. When sharing my knowlegde, I always keep in mind that a working example is worth a thousand words.

Topic:
Practical Reactive Streams with Monix

Abstract:
Stream processing is a hot topic today and it’s easy to get lost among all the possibilities. In this live coding session we will explore the Reactive Streams approach used by the Monix project – one of the Scala implementations of the Reactive Streams concepts. On an almost real-life example we’re going to walk through both the basics and some more advanced usages of the library.

Jacek Kunicki SoftwareMill

Jochen Mader

Bio:
Grew up as C64-nerd, got into Basic, C and Assembly. Found the JVM and fell in love. Since then I’ve been constantly wandering through the world of IT, always focusing on highly available distributed systems. Today I am happy to be a part of the nerd herd at codecentric. I spent the past few years working with a bunch of very creative and fun people in Scala-heavy projects using Akka, Vert.x, Spark, … . Oh, and I joined the Vert.x-team in 2017 as maintainer for the Scala-stack. That’s where most of my non-working-coding-time goes.

Topic:
A reactive architecture based on Vert.x and Kubernetes

Abstract:
The combination of microservices and the availability of easy to operate cloud infrastructures has changed the way we build software. Where classic 3-tier applications dominated only a few years ago we today see highly distributed microservice infrastructures. At the same time the expectations of our customers advanced at almost the same pace. Downtimes are a far more serious issue as they will drive them away to the competition. Classic application design and the way we used to build software hit there limits a while ago and new paradigms were required.
This talk will show how the combination of a reactive application framework like Vert.x, a Kubernetes based infrastructure, Scala and a lot of fun give us a fully reactive architecture … and happy customers.
In this talk I will introduce the core concepts of Vert.x, its event bus, the new Scala-integration and how this all plays together with Kubernetes.
Expect to see a lot of code and to learn how a developer can effectively develop locally using Vert.x and Kubernetes together.

Jochen Mader Codecentric

Bartłomiej Małecki

Bio:
Seasoned software engineer at IBM / IBM Master Inventor – recently (last two years) enjoying scala/akka/kafka/spark

Topic:
Anomaly detection of monitoring data in Scala ecosystem
(Joint talk with Rafał Bigaj)

Abstract:
Machine learning for programmers could be a tricky subject. We’d like to present a system that predicts the potential user over charging problem by detecting anomalies in the monitoring data. It wouldn’t be a data scientist talk, rather a one focused on implementation details using tools from Scala ecosystem.

What’s difficult in the billing system for the shared cloud infrastructure?
Noisy neighbour is an effect of monopolisation of bandwidth, disk I/O, CPU and other resources. Virtual machines and applications that share the infrastructure suffer from uneven cloud network performance.
In such environment, without proper analysis of real-time monitoring data, it’s not easy to distinguish a valid complaints from ungrounded grumbles.

Akka Streams with Kafka, Spark and Cloudant is a nice mixture of tools that can help you build a robust streaming solution without a lot of effort in both development and maintenance phase. The presentation is dedicated to software developers, system architects and data scientists who would like to learn the quick and painless way of building reactive systems.

Bartłomiej Małecki IBM

Roman Ivanov

Bio:
Roman is a Solutions Architect with strong Scala background now focusing on Data and Machine Learning systems with a goal to bring scalability, efficiency and speed.

Topic:
Fast Data Architecture at XITE

Abstract:
Fast Data is emerging as a new approach to data processing. While Big Data relied mostly on batch processing, Fast Data brings us the power of streaming, where information is processed as soon as it becomes available. XITE (https://xite.com) has worked hard to embrace Fast Data and will share their experience with us.

Roman Ivanov XITE

Tudor Palanga

Bio:
Tudor is a Software Consultant based in London with more than 15 years of software development experience. After working for a while as a Java engineer for some well known clients (Oracle, BNP Paribas, Sony Playstation Network) he decided to steer his career to Scala, working for the last year and a half at Expedia/Hotels.com. He’s passionate about writing good quality software, microservice architecture and functional programing.

Topic:
From monolith to microservices – Reification and reactification

Abstract:
Migrating from a monolithic model to a microservices model can be challenging as we try to decouple implementation and wiring between different parts of the system. We’re going to take a look at how we can extract then encapsulate implementation and execution in an external service. From here we’ll explore different ways of communication and how we can test the whole system.

Tudor Palanga Expedia

Jan Pustelnik

Bio:
Software Engineer at Actyx by day, sporadic Akka and Dotty projects contributor by night. Interested in how software works on low level, he does not find big frameworks appealing. This is the main reason why he loves Scala, a very expressive language that allows one to build right abstractions quickly without losing control over details. Jan is an active member of JUG Łódź and occasional conference speaker. In his spare time he loves to dust-off some old issue of computer science journal only to find out that everything has already been invented before he even was born.

Topic:
Alpakka – a new world of Connectors for Reactive Enterprise Integration

Abstract:
Connecting your programs with various upstream and downstream systems is a frequent problem. Until recently if one wanted to integrate an Akka Streams application with the world outside, the tool of choice would be the Akka Camel module. However, this frequently resulted in non-intuitive, complex and hard to test implementations. With the recent advent of Alpakka library, you can integrate in a reactive, backpressure-preserving way.

In this talk we will:
– introduce the Alpakka library
– do a short walk through sample modules
– show how to write your own integration (and make it a part of Alpakka).

Jan Pustelnik Actyx

Jarosław Ratajski

Bio:
JVM Developer with quite functional heart

Topic:
2 small steps for a team

Abstract:
Kotlin + Spring 5.0 Web Flux

Almost nobody likes big changes. This includes management and developers. It is often very hard to convince people to try something new. Even if the old way is pathetic, leads to bugs and does not fit to a problem. If you do not believe in that try to convince any JavaEE/ Spring team to use something else. Even though both platforms are quite dated and do not really enable writing clean code. They are even worse if you try functional programming.

The way I often do is to introduce only a small improvements, to the extent that might get accepted by the team and managers. Such a trick is to use Kotlin as Java++ and Spring 5… as just a new version of Spring. After a while it can appear that the “new Java” is written totally functional, with very little or none mutability. And the new Spring works without annotations and so called beans. Eventually, we get code that is more similar to Scala/Akka-HTTP stack… that would not be ever accepted.

Jarosław Ratajski Engenius CH

Fabio Tiriticco

Bio:
Reactive Developer & Architect in Amsterdam, I am in love with anything reactive & streaming, especially if built with Scala, Akka and the rest of their wonderful ecosystem.
I love to help communities grow and I founded myself the Reactive Amsterdam meetup which has been very successful over the last couple of years, with great numbers and sponsors. My biggest passion beside tech is bicycle touring – the biggest adventure so far cycling from Amsterdam to Rome, my home town. Oh, I run a meetup about that too!

Topic:
Cloud Native Akka & Kubernetes: the holy grail to elasticity?

Abstract:
I have been in love with Akka since I first saw it. Akka is the most mature choice to implement the traits of the Reactive Manifesto, thanks to the Actor model. Resilience is enabled by asynchronous message passing and Actor supervision. Location transparency, message routing and the “share nothing” approach enable seamless scalability, but once our app is deployed we need to rely on some external infrastructure to automatically scale up or down our services. At this point, Akka alone is not sufficient anymore. What else do we need?

I found Docker & Kubernetes to be a perfect match for clustered Akka applications running in the cloud. Thanks to the Kubernetes API, one can write infrastructure logic that complements the business logic. This leads to a general approach of infrastructure-as-code tailored to each different business case, which in turn lets companies achieve maximum efficiency and resource usage.

During this talk I will cover features from both Akka and Kubernetes, plus example code in Scala: familiarity with these technologies is recommended. My example will rely on Google Cloud infrastructure.

Fabio Tiriticco Fabway

Yifan Xing

Bio:
Yifan is a student at Northeastern University. She built a back-end message queue system for the open source project Shared Health Research Information Network (SHRINE) at Harvard Medical School. The system uses concepts of parallel processing/multi-threading, non-blocking asynchronous, distributed systems, etc. Yifan is also involved in bringing diversity into the tech field. She is currently organizing ScalaBridge – Boston, and the first workshop is planned for summer 2018! Please contact her if you want to be involved.

Topic:
Asynchronous Programming: Scala.concurrent and Monix! What?

Abstract:
In the context of executing a task, a synchronous execution indicates that the program waits for the result of the first task before moving on to another task. In contrast, an asynchronous execution does not wait for the result of the first task and it starts executing another task immediately after the first task has begun. Both Futures & Promises, and Monix are Scala libraries that allow users to efficiently perform asynchronous operations.

This talk will introduce the Futures & Promises library in Scala.concurrent and Monix. We will walk through several examples that demonstrate how to use Futures & Promises, and Monix. In addition, the talk compares and contrasts the similarities and differences between the two libraries. Furthermore, we will discuss some best practices in debugging asynchronous systems.

Yifan Xing Northeastern University

Marcin Zagórski

Bio:
Scala developer at VirtusLab. Feels best with Lightbend stack, but worked with variety of different technologies in many kinds of projects – from start ups to corporate scala. Excited about reactive stuff.

Topic:
Beyond the hype: reactive vs traditional microservices
(Joint talk with Paweł Dolega and Łukasz Biały)

Abstract:
For some time now IT media were sparkled with success stories of teams who went reactive and reaped benefits of paradigm change but in most cases it was not an apples to apples comparison – just legacy stack vs new, shiny async-based technology. In this talk we want to deliver hard, cold numbers about pros, cons, benefits and pains of selecting reactive technologies for your company’s application stack compared to traditional sync webservices. Is reactive microservices approach really worth the effort or are we all drinking the kool-aid?

Marcin Zagórski VirtusLab

Other sphere.it events

Scala.sphere.it is a unique event devoted to important topic for every Scala Software Developer – Dev Tools.

Visit scala.sphere.it

abc

Data.sphere.it is a conference devoted to data-centric systems and the technologies making them tick. Whether it is data engineering or AI application challenges – they all fit well in.

Visit data.sphere.it

Get <b>your pass</b>

Get your pass

You can register for your tickets today. The tickets also let you attend both sister events happening at the same time and venue (Scala.sphere.it & Data.sphere.it)

Get tickets

Practical info

Sponsorship

Please take a look at Sponsorship Offer

Getting around

From airport take taxi or train.
For checking public communication you can use jakdojade.pl

Main venue

The Opera of Kraków
Lubicz 48
31-512 Kraków

Day of practice

There will be several workshops, hackathons and training on 15th of April. More details soon

The afterparty

We invite you to Browar Lubicz

We are powered by

Organizer

Platinum Sponsor

Partners

Silver Sponsors

Media

Community Partners



Would you like to become a sponsor?

Code of Conduct

The following Code of Conduct is inspired by that from other prominent conferences such as ScalaDays or Scala eXchange.

ReactSphere is dedicated to providing a harassment-free experience for everyone, regardless of gender, gender identity and expression, sexual orientation, disability, physical appearance, body size, race, nationality, age or religion. We do not tolerate harassment of participants in any form. Please show respect for those around you. This applies to both in-person and online behavior.

All communication should be appropriate for a technical audience,

including people of many different backgrounds. Sexual language, innuendo, and imagery is not appropriate for any conference venue, including talks.

If you are being harassed, notice that someone else is being harassed, or have any other concerns, please contact a member of staff immediately. If an individual engages in harassing behaviour, the React.sphere.it staff may take any action they deem appropriate, including warning the offender or expulsion from the event.
We expect all attendees to follow above rules during our Conferences.