Concurrency in Scala - the Akka way

Over the past few years, web-applications have started to play an increasingly important role in our lives. We expect them to be always available and the data to be always fresh. This shift into the realm of real-time data processing is now transitioning to physical devices, and Gartner predicts that the Internet of Things will grow to an installed base of 26 billion units by 2020. Reactive web-applications are an answer to the new requirements of high-availability and resource efficiency brought by this rapid evolution. On the JVM, a set of new languages and tools has emerged that enable the development of entirely asynchronous request and data handling pipelines. At the same time, container-less application frameworks are gaining increasing popularity over traditional deployment mechanisms. This talk is going to give you an introduction into one of the most trending reactive web-application stack on the JVM, involving the Scala programming language, the concurrency toolkit Akka and the web-application framework Play. It will show you how functional programming techniques enable asynchronous programming, and how those technologies help to build robust and resilient web-applications.

Johan Andrén presented on building reactive distributed systems with Akka. He provided an overview of Akka clustering and distributed data types. He discussed how Akka actors map to distributed systems and Akka's support for eventual consistency through gossip. He also covered distributed pub/sub messaging, cluster singletons that introduce a single point of failure, and cluster sharding to shard actors across nodes.

The document summarizes a presentation about the book "Akka Concurrency" by Derek Wyatt. It provides an overview of the book's content including chapters on actors, testing, routing messages, dataflow concurrency and examples of stateful actors and using the finite state machine pattern. It also notes that while the book provides an exhaustive overview of Akka, it is based on an older version of Akka and does not cover newer features like clustering and persistence.

The document discusses Apache Kafka and provides an introduction to key concepts like consumer groups, producer/consumer APIs, and throughput guarantees. It explains how Kafka can be used for both queuing and publish-subscribe models using consumer groups. Code examples are given for Kafka producers and consumers in Scala and Java along with throughput benchmarks showing Kafka's ability to support millions of messages per second.

The document discusses the problems with using Akka actors and proposes solutions using FSM and futures instead of actors for some cases. It describes issues with actors like lack of type safety, mutable state leading to complex code, and difficult debugging. FSMs are presented as a better solution by enforcing state transitions and logging. Futures are also suggested for cases without need for location transparency or real-time data flow that actors provide. The conclusion is that Akka requires a new mindset and can cause headaches if overused, so it's best to only use actors when truly needed.

The document introduces Akka, an open-source toolkit for building distributed, concurrent applications on the JVM. It provides a programming model called the actor model that makes it easier to build scalable and fault-tolerant systems. Actors process messages asynchronously and avoid shared state, providing a simpler approach to concurrency than traditional threads and locks. Akka allows actors to be distributed across a network, enabling applications to scale out elastically.

There are many programming languages that can be used on the JVM (Java, Scala, Groovy, Kotlin, ...). In this session, we'll outline the main differences between them and discuss advantages and disadvantages for each.

This document provides an overview of Akka and Akka Cluster, frameworks for building distributed and fault-tolerant applications using actors. It discusses concurrency paradigms like message passing actors, Akka's implementation of the actor model, clustering with Akka Cluster, and using CRDTs for distributed shared state. It also previews demos of building a web crawler application and clustering it across nodes with Akka Cluster.

This document introduces Failsafe, which provides latency and fault tolerance capabilities for distributed systems. It discusses how Failsafe compares to Hystrix and how it is used at Coupang. Key features of Failsafe include retry policies, circuit breakers, fallbacks, and asynchronous execution. Event listeners and policy composition patterns are also covered.

Java 9 is just around the corner. In this session, we'll describe the new modularization support (Jigsaw), new JDK tools, enhanced APIs and many performance improvements that were added to the new version.

During the talk, we will build a simple web app using Lift and then introduce Akka ( http://akkasource.org) to help scale it. Specifically, we will demonstrate Remote Actors, "Let it crash" fail over, and Dispatcher. Other Scala oriented tools we will use include sbt and ENSIME mode for emacs.

Everybody wants scalable systems. However, writing non-blocking applications in Java is not an easy task. In this session, we'll go over 3 different frameworks for managing multi-treading and concurrency support (Akka, Vertx and Quasar).

ave time learning on your own. Start Building with React, MongoDB, Express, & Node. The MERN Stack. Learning a new JavaScript framework is difficult. You can spend weeks learning new concepts. If an online example doesn’t work, you may spend countless hours Googling, searching Stack Overflow and blogs for the solution. Take the fast track and learn from an experienced Senior Software Engineer and professional instructor! About this Course  This highly interactive course features a large amount of student labs and hands-on coding. You will be taught how to assemble the complete stack required to build a modern web app using React.js, MongoDB (a NoSQL database) and Express (a framework for web application servers). This course will also cover many other tools that go into building a complete web application: React Router, React-Bootstrap, Redux, Babel, and Webpack.  What You Will Learn • How to use modern JavaScript features • Webpack • Node & Express • Reading and writing data to a MongoDB database • Babel • React • State Management with Redux • Mongoose • And More!

This presentation covers how to build a chatbot - step by step. It covers Facebook, integration using AWS Lex and AWS Lambda

Building data pipelines shouldn't be so hard, you just need to choose the right tools for the task. We will review Akka and Spark streaming, how they work and how to use them and when.

This document provides an overview of the Scala programming language. Some key points: - Scala runs on the Java Virtual Machine and was created by Martin Odersky at EPFL. - It has been around since 2003 and the current stable release is 2.7.7. Release 2.8 beta 1 is due out soon. - Scala combines object-oriented and functional programming. It has features like pattern matching, actors, XML literals, and more that differ from Java. Everything in Scala is an object.

Futures allow asynchronous and non-blocking operations in Scala. They represent a value that may be available in the future. Promises allow producing values for futures - a promise can be used to complete a future with a value. Futures can be composed using methods like map, flatMap, and recover to build asynchronous workflows. Callbacks allow non-blocking handling of future results.

Akka is a toolkit and runtime for building highly concurrent, distributed, and resilient message-driven applications on the JVM. This slides is for my lecture in #zconf 2016. I introduced actor model and some features provided in Akka.

Scala traits training by Sanjeev Kumar @Kick Start Scala traits & Play, organized by Knoldus Software LLP in New Delhi

Slides from my talk at the Junction (Jan 24, 2013) Single-core performance has hit a ceiling, and building web-scale multi-core applications using imperative programming models is nightmarishly difficult. Parallel programming creates a new set of challenges, best practices and design patterns. Scala is designed to enable building scalable systems, elegantly blending functional and object oriented paradigms into an expressive and concise language, while retaining interoperability with Java. Scala is the fastest growing JVM programming language, being rapidly adopted by leading companies such as Twitter, LinkedIn and FourSquare. This presentation provides a comprehensive overview of the language, which managed to increase type safety while feeling more dynamic, being more concise and improving readability at the same time. We will see how Scala simplifies real life problems by empowering the developer with powerful functional programming primitives, without giving up on the object oriented paradigm. The overview includes tools for multi-core programming in Scala, the type system, collection framework and domain-specific languages. We’ll explore the power of compile-time meta-programming, which is made possible by the newly released Scala 2.10, and get a glimpse into what to expect from 2.11 in 2014. We will also see how Scala helps overcome the inherent limitations of Java, such as type erasure, array covariance and boxing overhead. Multiple examples emphasize how Scala pushes the JVM harder than any other mainstream language through the infinite number of boilerplate busters, increased type safety and productivity boosters from a Java developer’s perspective.

This document provides an introduction to the Scala programming language for Java programmers. It discusses Scala's motivation as a scalable and more productive alternative to Java. Key features covered include static typing, object-oriented and functional programming, traits, pattern matching, and actors. Examples are provided to illustrate concepts like functions as first-class values, partially applied functions, and collection operations. The document concludes by mentioning additional Scala concepts and providing references for further reading.