Akka HTTP offers a general toolkit for providing and consuming HTTP-based services. The Akka HTTP modules implement a full server and client-side HTTP stack on the top of Akka Actor and Akka Streams
Building REST API using Akka HTTP with ScalaKnoldus Inc.
Akka HTTP is a toolkit for building REST APIs using Scala. It provides a server-side API with routing directives to define routes and handle requests asynchronously in a non-blocking way. Tests can be written using the testkit module to test routes efficiently. Akka HTTP picks up where the low-level server API leaves off, offering higher-level functionality like routing, content negotiation, and static content serving through its routing DSL.
Alpakka:Intergating Akka-Streams with different technologyKnoldus Inc.
This session is focused on Alpakka. In this, I'm going to explain how Alpakka makes it easy to do enterprise-level integrations with Akka-Streams and how it makes streaming data from different outer sources much easier.
With the advent of “big data”, it has become inevitable to analyze huge volumes of data in real-time to make sense out of it. For this to happen seamlessly, the streaming of that data is necessary. This is where Reactive Streams step in.
Akka Streams is built on top of the Reactive Streams interface. This webinar will be an introduction to Akka Streams and how it simplifies the aspect of back-pressure in real-time streaming.
Here’s an outline of the webinar -
~ Introduction to the problem set
~ How do Akka Streams help simplify the problem of back-pressure?
~ Basic terminologies of Akka Streams
~ Live demo of a real-life problem being solved with Akka Streams
An Open Source Notebook based tool that supports Data ingestion, collaboration and Analytics. Offers visualization with modern UI and other interesting features including GitHub integration, cron schedules, importing and exporting notebooks and many more.
This document discusses Typesafe's Reactive Platform, which includes tools for monitoring, orchestrating, and improving the resilience of reactive applications. It provides an overview of the platform and its commercial features, and then focuses on two aspects in more depth: improving fault tolerance through Akka's split brain resolver strategies and system orchestration using ConductR to deploy and manage reactive microservices applications across clusters. The document encourages readers to get started with the platform through a free developer sandbox and contacting Typesafe for additional help and services.
This document provides an overview of reactive programming concepts like state, time, sync vs async operations, futures and promises. It discusses different approaches to reactive programming in Java like using CompletableFuture, JDeferred and RxJava. It also covers functional programming concepts, data streams, reactive Spring and the future of reactive programming in Java 9 and beyond.
An introduction to reactive programming concepts and basics. I aim here to show what's reactive programming, why it's used and show some frameworks and benchmarks that support it.
The document discusses new features in Java 8 including default methods in interfaces, lambda expressions, and streams. Default methods allow interfaces to include method implementations. Lambda expressions allow treating functionality as a method argument and code as data. Streams provide utilities for functional-style operations on collections of values and include intermediate and terminal operations.
Building REST API using Akka HTTP with ScalaKnoldus Inc.
Akka HTTP is a toolkit for building REST APIs using Scala. It provides a server-side API with routing directives to define routes and handle requests asynchronously in a non-blocking way. Tests can be written using the testkit module to test routes efficiently. Akka HTTP picks up where the low-level server API leaves off, offering higher-level functionality like routing, content negotiation, and static content serving through its routing DSL.
Alpakka:Intergating Akka-Streams with different technologyKnoldus Inc.
This session is focused on Alpakka. In this, I'm going to explain how Alpakka makes it easy to do enterprise-level integrations with Akka-Streams and how it makes streaming data from different outer sources much easier.
With the advent of “big data”, it has become inevitable to analyze huge volumes of data in real-time to make sense out of it. For this to happen seamlessly, the streaming of that data is necessary. This is where Reactive Streams step in.
Akka Streams is built on top of the Reactive Streams interface. This webinar will be an introduction to Akka Streams and how it simplifies the aspect of back-pressure in real-time streaming.
Here’s an outline of the webinar -
~ Introduction to the problem set
~ How do Akka Streams help simplify the problem of back-pressure?
~ Basic terminologies of Akka Streams
~ Live demo of a real-life problem being solved with Akka Streams
An Open Source Notebook based tool that supports Data ingestion, collaboration and Analytics. Offers visualization with modern UI and other interesting features including GitHub integration, cron schedules, importing and exporting notebooks and many more.
This document discusses Typesafe's Reactive Platform, which includes tools for monitoring, orchestrating, and improving the resilience of reactive applications. It provides an overview of the platform and its commercial features, and then focuses on two aspects in more depth: improving fault tolerance through Akka's split brain resolver strategies and system orchestration using ConductR to deploy and manage reactive microservices applications across clusters. The document encourages readers to get started with the platform through a free developer sandbox and contacting Typesafe for additional help and services.
This document provides an overview of reactive programming concepts like state, time, sync vs async operations, futures and promises. It discusses different approaches to reactive programming in Java like using CompletableFuture, JDeferred and RxJava. It also covers functional programming concepts, data streams, reactive Spring and the future of reactive programming in Java 9 and beyond.
An introduction to reactive programming concepts and basics. I aim here to show what's reactive programming, why it's used and show some frameworks and benchmarks that support it.
The document discusses new features in Java 8 including default methods in interfaces, lambda expressions, and streams. Default methods allow interfaces to include method implementations. Lambda expressions allow treating functionality as a method argument and code as data. Streams provide utilities for functional-style operations on collections of values and include intermediate and terminal operations.
The document discusses Project Reactor, a library for building asynchronous and non-blocking applications in Java or Kotlin. It explains the differences between blocking and non-blocking code, provides examples of using Project Reactor, and highlights some gotchas. Benchmarking results show that a non-blocking Dropwizard application using Project Reactor can handle over 12 times as many requests per second as a blocking version. The document also includes links to code samples on GitHub that demonstrate concepts like combining different publishers, exception handling, and caching.
Making Scala Faster: 3 Expert Tips For Busy Development TeamsLightbend
This document provides information about the author and discusses ways to improve Scala compilation performance. The author has worked on Scala tooling and is the co-founder of Triplequote. They discuss how build time differs from compilation time due to pre-processing steps. They warn that type classes and macros can significantly increase code size and slow compilation. Whitebox macros are type-checked three times while blackbox macros only participate in type inference. They recommend monitoring compilation to identify bottlenecks like macro expansion or implicit resolution. Finally, they note that the Scala compiler is single-threaded, but parallelization using Scala Hydra can improve compilation speed.
The document discusses reactive programming and provides examples using RxJS. It defines reactive programming as working with asynchronous data streams. Streams can represent events like user inputs or API responses. Key concepts discussed include:
- Observables represent streams of data that can be subscribed to. Common stream operations like map, filter, and scan can transform streams.
- An example demonstrates creating a stream for a "Who to follow" API, making a request on startup and refresh, and rendering responses.
- Other operators like merge, startWith, and combineLatest are used to combine multiple streams of events and responses.
Building High-Throughput, Low-Latency Pipelines in Kafkaconfluent
William Hill is one of the UK’s largest, most well-established gaming companies with a global presence across 9 countries with over 16,000 employees. In recent years the gaming industry and in particular sports betting, has been revolutionised by technology. Customers now demand a wide range of events and markets to bet on both pre-game and in-play 24/7. This has driven out a business need to process more data, provide more updates and offer more markets and prices in real time.
At William Hill, we have invested in a completely new trading platform using Apache Kafka. We process vast quantities of data from a variety of feeds, this data is fed through a variety of odds compilation models, before being piped out to UI apps for use by our trading teams to provide events, markets and pricing data out to various end points across the whole of William Hill. We deal with thousands of sporting events, each with sometimes hundreds of betting markets, each market receiving hundreds of updates. This scales up to vast numbers of messages flowing through our system. We have to process, transform and route that data in real time. Using Apache Kafka, we have built a high throughput, low latency pipeline, based on Cloud hosted Microservices. When we started, we were on a steep learning curve with Kafka, Microservices and associated technologies. This led to fast learnings and fast failings.
In this session, we will tell the story of what we built, what went well, what didn’t go so well and what we learnt. This is a story of how a team of developers learnt (and are still learning) how to use Kafka. We hope that you will be able to take away lessons and learnings of how to build a data processing pipeline with Apache Kafka.
How can you make different pieces of your unit of work consistent in the distributed setup of your micro-service application?
You associate the term transaction probably with a database, but the data source can be anything including a database in the micro-service world.
The MicroProfile Long Running Actions specification is based on sagas and the OASIS LRA transaction model specification. It defines the framework to guarantee the eventual consistency requirement using compensating actions for example.
This session will explain you the challenges and concepts of the MP LRA framework.
Gatling can be used to load test REST APIs by writing Scala simulation scripts. The scripts define test scenarios by chaining together the steps of invoking APIs concurrently. Feeders can inject runtime values. Tests are run by executing the Scala scripts from sbt or triggered from Jenkins. Gatling generates test reports in the target directory with results like response times and errors.
Control and monitor_microservices_with_microprofileRudy De Busscher
Microservices architecture has many benefits. But it comes at a cost. Running microservices and monitoring what’s going on is tedious. That’s why MicroProfile adopts monitoring as a first-class concept. In this session, learn how MicroProfile runtimes collect metrics and how to seamlessly collect them with tools like Prometheus and Grafana. Learn how MicroProfile makes it easy to connect information about interrelated service calls, how to gather the information and analyze system bottlenecks, how to deploy and scale MicroProfile applications with Kubernetes and how to react to their health status to detect and automatically recover from failures.
Taking Akka Streams & Akka Http to Large Scale Production ApplicationsAkara Sucharitakul
This document discusses using Akka Streams and Akka HTTP for large scale production applications. It covers why Akka Streams is useful for high performance stream processing. Operationalizing services requires managing the service lifecycle, monitoring pipelines, and ensuring resiliency. Common requirements for production services include managing the service lifecycle, logging, monitoring, and implementing resiliency through techniques like circuit breakers and timeouts. The squbs project provides tools for operationalizing Akka HTTP services at scale through components for lifecycle management, monitoring integration, and resiliency patterns.
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.
Apache Apex connector with Kafka 0.9 consumer APIApache Apex
Meetup presentation: Recently added support in Apache Apex Malhar for the new Kafka 0.9 consumer API. We cover how the new API has simplified certain aspects of the connector, performance and scalability considerations when consuming data from Kafka with Apache Apex, interoperability with MapR streams and plans for future enhancements.
This document discusses building a fault-tolerant Kafka cluster on AWS to handle 2.5 billion requests per day. It covers choosing AWS instance types and broker counts, spreading brokers across availability zones, configuring replication and partitioning, automating fault tolerance, adding metrics and alerts, and testing the cluster's resilience. Key decisions include broker placement, topic partitioning, Zookeeper ensemble sizing, and automation to dynamically reassign partitions and change configurations in response to failures or added capacity.
Stream data from Apache Kafka for processing with Apache ApexApache Apex
Meetup presentation: How Apache Apex consumes from Kafka topics for real-time time processing and analytics. Learn about features of the Apex Kafka Connector, which is one of the most popular operators in the Apex Malhar operator library, and powers several production use cases. We explain the advanced features this operator provides for high throughput, low latency ingest and how it enables fault tolerant topologies with exactly once processing semantics.
A brief introduction to Apache Kafka and describe its usage as a platform for streaming data. It will introduce some of the newer components of Kafka that will help make this possible, including Kafka Connect, a framework for capturing continuous data streams, and Kafka Streams, a lightweight stream processing library.
Reactive programming is quite a popular topic these days. For a long time, reactive programming was constrained to interactive user interface designs. With the advancement of hardware (multi-core CPU’s) and the internet, the scale, complexity, and responsiveness of software began to rise which led to reactive programming being regarded as a major programming paradigm.
Read more from here: https://blog.lftechnology.com/introduction-to-reactive-programming-part-1-5b7c63685586
By: Subash Poudel (Software Engineer @ Leapfrog Technology, Inc.)
Apache Kafka is an open-source message broker project developed by the Apache Software Foundation written in Scala. The project aims to provide a unified, high-throughput, low-latency platform for handling real-time data feeds.
This is the first part of the presentation.
Here is the 2nd part of this presentation:-
http://www.slideshare.net/knoldus/introduction-to-apache-kafka-part-2
Reactive Micro Services with Java seminarGal Marder
Abstract –
Micro services is the current architectural trend. In this seminar, we'll go over the concepts behind a good micro-service implementation and see how to implement it with available Java frameworks.
Target Audience
Java developers, team leaders, project managers.
Prerequisites
Java knowledge
Contents:
Overview of Micro-service architecture principles.
- Technical stacks:
- The Spring Stack (Spring Boot & Cloud)
- Lagom
- Akka and Play
- Vertx
- Complementaries
- Discovery
- Configuration
- Monitoring
Introducing Confluent labs Parallel Consumer client | Anthony Stubbes, ConfluentHostedbyConfluent
Consuming messages in parallel is what Apache Kafka® is all about, so you may well wonder, why would we want anything else? It turns out that, in practice, there are a number of situations where Kafka’s partition-level parallelism gets in the way of optimal design.
This session will go over some of these types of situations that can benefit from parallel message processing within a single application instance (aka slow consumers or competing consumers), and then introduce the new Parallel Consumer labs project from Confluent, which can improve functionality and massively improve performance in such situations.
It will cover the
- Different ordering modes of the client
- Relative performance improvements
- Usage with other components like Kafka Streams
- An introduction to the internal architecture of the project
- How it can achieve all this in a reassignment friendly manner
In this session, we will learn about Akka Http, its modules. After then, we will uncover the high-level server API in Akka HTTP and its modules and finally will go through a Demo as well.
Understanding Akka WebSockets A Comprehensive Guide.pptxKnoldus Inc.
Dive into the fundamentals of WebSockets and discover how Akka brings a new dimension to real-time communication. This Session provides a beginner-friendly exploration of what WebSockets are and how Akka a powerful toolkit for building concurrent and distributed applications, enhances their functionality.
The document discusses Project Reactor, a library for building asynchronous and non-blocking applications in Java or Kotlin. It explains the differences between blocking and non-blocking code, provides examples of using Project Reactor, and highlights some gotchas. Benchmarking results show that a non-blocking Dropwizard application using Project Reactor can handle over 12 times as many requests per second as a blocking version. The document also includes links to code samples on GitHub that demonstrate concepts like combining different publishers, exception handling, and caching.
Making Scala Faster: 3 Expert Tips For Busy Development TeamsLightbend
This document provides information about the author and discusses ways to improve Scala compilation performance. The author has worked on Scala tooling and is the co-founder of Triplequote. They discuss how build time differs from compilation time due to pre-processing steps. They warn that type classes and macros can significantly increase code size and slow compilation. Whitebox macros are type-checked three times while blackbox macros only participate in type inference. They recommend monitoring compilation to identify bottlenecks like macro expansion or implicit resolution. Finally, they note that the Scala compiler is single-threaded, but parallelization using Scala Hydra can improve compilation speed.
The document discusses reactive programming and provides examples using RxJS. It defines reactive programming as working with asynchronous data streams. Streams can represent events like user inputs or API responses. Key concepts discussed include:
- Observables represent streams of data that can be subscribed to. Common stream operations like map, filter, and scan can transform streams.
- An example demonstrates creating a stream for a "Who to follow" API, making a request on startup and refresh, and rendering responses.
- Other operators like merge, startWith, and combineLatest are used to combine multiple streams of events and responses.
Building High-Throughput, Low-Latency Pipelines in Kafkaconfluent
William Hill is one of the UK’s largest, most well-established gaming companies with a global presence across 9 countries with over 16,000 employees. In recent years the gaming industry and in particular sports betting, has been revolutionised by technology. Customers now demand a wide range of events and markets to bet on both pre-game and in-play 24/7. This has driven out a business need to process more data, provide more updates and offer more markets and prices in real time.
At William Hill, we have invested in a completely new trading platform using Apache Kafka. We process vast quantities of data from a variety of feeds, this data is fed through a variety of odds compilation models, before being piped out to UI apps for use by our trading teams to provide events, markets and pricing data out to various end points across the whole of William Hill. We deal with thousands of sporting events, each with sometimes hundreds of betting markets, each market receiving hundreds of updates. This scales up to vast numbers of messages flowing through our system. We have to process, transform and route that data in real time. Using Apache Kafka, we have built a high throughput, low latency pipeline, based on Cloud hosted Microservices. When we started, we were on a steep learning curve with Kafka, Microservices and associated technologies. This led to fast learnings and fast failings.
In this session, we will tell the story of what we built, what went well, what didn’t go so well and what we learnt. This is a story of how a team of developers learnt (and are still learning) how to use Kafka. We hope that you will be able to take away lessons and learnings of how to build a data processing pipeline with Apache Kafka.
How can you make different pieces of your unit of work consistent in the distributed setup of your micro-service application?
You associate the term transaction probably with a database, but the data source can be anything including a database in the micro-service world.
The MicroProfile Long Running Actions specification is based on sagas and the OASIS LRA transaction model specification. It defines the framework to guarantee the eventual consistency requirement using compensating actions for example.
This session will explain you the challenges and concepts of the MP LRA framework.
Gatling can be used to load test REST APIs by writing Scala simulation scripts. The scripts define test scenarios by chaining together the steps of invoking APIs concurrently. Feeders can inject runtime values. Tests are run by executing the Scala scripts from sbt or triggered from Jenkins. Gatling generates test reports in the target directory with results like response times and errors.
Control and monitor_microservices_with_microprofileRudy De Busscher
Microservices architecture has many benefits. But it comes at a cost. Running microservices and monitoring what’s going on is tedious. That’s why MicroProfile adopts monitoring as a first-class concept. In this session, learn how MicroProfile runtimes collect metrics and how to seamlessly collect them with tools like Prometheus and Grafana. Learn how MicroProfile makes it easy to connect information about interrelated service calls, how to gather the information and analyze system bottlenecks, how to deploy and scale MicroProfile applications with Kubernetes and how to react to their health status to detect and automatically recover from failures.
Taking Akka Streams & Akka Http to Large Scale Production ApplicationsAkara Sucharitakul
This document discusses using Akka Streams and Akka HTTP for large scale production applications. It covers why Akka Streams is useful for high performance stream processing. Operationalizing services requires managing the service lifecycle, monitoring pipelines, and ensuring resiliency. Common requirements for production services include managing the service lifecycle, logging, monitoring, and implementing resiliency through techniques like circuit breakers and timeouts. The squbs project provides tools for operationalizing Akka HTTP services at scale through components for lifecycle management, monitoring integration, and resiliency patterns.
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.
Apache Apex connector with Kafka 0.9 consumer APIApache Apex
Meetup presentation: Recently added support in Apache Apex Malhar for the new Kafka 0.9 consumer API. We cover how the new API has simplified certain aspects of the connector, performance and scalability considerations when consuming data from Kafka with Apache Apex, interoperability with MapR streams and plans for future enhancements.
This document discusses building a fault-tolerant Kafka cluster on AWS to handle 2.5 billion requests per day. It covers choosing AWS instance types and broker counts, spreading brokers across availability zones, configuring replication and partitioning, automating fault tolerance, adding metrics and alerts, and testing the cluster's resilience. Key decisions include broker placement, topic partitioning, Zookeeper ensemble sizing, and automation to dynamically reassign partitions and change configurations in response to failures or added capacity.
Stream data from Apache Kafka for processing with Apache ApexApache Apex
Meetup presentation: How Apache Apex consumes from Kafka topics for real-time time processing and analytics. Learn about features of the Apex Kafka Connector, which is one of the most popular operators in the Apex Malhar operator library, and powers several production use cases. We explain the advanced features this operator provides for high throughput, low latency ingest and how it enables fault tolerant topologies with exactly once processing semantics.
A brief introduction to Apache Kafka and describe its usage as a platform for streaming data. It will introduce some of the newer components of Kafka that will help make this possible, including Kafka Connect, a framework for capturing continuous data streams, and Kafka Streams, a lightweight stream processing library.
Reactive programming is quite a popular topic these days. For a long time, reactive programming was constrained to interactive user interface designs. With the advancement of hardware (multi-core CPU’s) and the internet, the scale, complexity, and responsiveness of software began to rise which led to reactive programming being regarded as a major programming paradigm.
Read more from here: https://blog.lftechnology.com/introduction-to-reactive-programming-part-1-5b7c63685586
By: Subash Poudel (Software Engineer @ Leapfrog Technology, Inc.)
Apache Kafka is an open-source message broker project developed by the Apache Software Foundation written in Scala. The project aims to provide a unified, high-throughput, low-latency platform for handling real-time data feeds.
This is the first part of the presentation.
Here is the 2nd part of this presentation:-
http://www.slideshare.net/knoldus/introduction-to-apache-kafka-part-2
Reactive Micro Services with Java seminarGal Marder
Abstract –
Micro services is the current architectural trend. In this seminar, we'll go over the concepts behind a good micro-service implementation and see how to implement it with available Java frameworks.
Target Audience
Java developers, team leaders, project managers.
Prerequisites
Java knowledge
Contents:
Overview of Micro-service architecture principles.
- Technical stacks:
- The Spring Stack (Spring Boot & Cloud)
- Lagom
- Akka and Play
- Vertx
- Complementaries
- Discovery
- Configuration
- Monitoring
Introducing Confluent labs Parallel Consumer client | Anthony Stubbes, ConfluentHostedbyConfluent
Consuming messages in parallel is what Apache Kafka® is all about, so you may well wonder, why would we want anything else? It turns out that, in practice, there are a number of situations where Kafka’s partition-level parallelism gets in the way of optimal design.
This session will go over some of these types of situations that can benefit from parallel message processing within a single application instance (aka slow consumers or competing consumers), and then introduce the new Parallel Consumer labs project from Confluent, which can improve functionality and massively improve performance in such situations.
It will cover the
- Different ordering modes of the client
- Relative performance improvements
- Usage with other components like Kafka Streams
- An introduction to the internal architecture of the project
- How it can achieve all this in a reassignment friendly manner
In this session, we will learn about Akka Http, its modules. After then, we will uncover the high-level server API in Akka HTTP and its modules and finally will go through a Demo as well.
Understanding Akka WebSockets A Comprehensive Guide.pptxKnoldus Inc.
Dive into the fundamentals of WebSockets and discover how Akka brings a new dimension to real-time communication. This Session provides a beginner-friendly exploration of what WebSockets are and how Akka a powerful toolkit for building concurrent and distributed applications, enhances their functionality.
Understanding Akka WebSockets A Comprehensive GuideKnoldus Inc.
Dive into the fundamentals of WebSockets and discover how Akka brings a new dimension to real-time communication. This Session provides a beginner-friendly exploration of what WebSockets are and how Akka a powerful toolkit for building concurrent and distributed applications, enhances their functionality.
Introduction to Kafka Streams - Knolx.pdfKnoldus Inc.
"In this session we will uncover the concepts of
Kafka, the API that Kafka offers, followed by a basic introduction to Kafka
streams and then its use cases."
This document provides an overview of Akka HTTP, a library for building HTTP-based services using Scala and Akka. It describes the common abstractions used in Akka HTTP like HTTP requests, responses, entities, and marshalling/unmarshalling. It also explains the low-level and high-level APIs, with the low-level API providing basic request handling functionality and the high-level API using directives and routing DSL for defining routes in a more flexible way.
Reactive Streams 1.0.0 is now live, and so are our implementations in Akka Streams 1.0 and Slick 3.0.
Reactive Streams is an engineering collaboration between heavy hitters in the area of streaming data on the JVM. With the Reactive Streams Special Interest Group, we set out to standardize a common ground for achieving statically-typed, high-performance, low latency, asynchronous streams of data with built-in non-blocking back pressure—with the goal of creating a vibrant ecosystem of interoperating implementations, and with a vision of one day making it into a future version of Java.
Akka (recent winner of “Most Innovative Open Source Tech in 2015”) is a toolkit for building message-driven applications. With Akka Streams 1.0, Akka has incorporated a graphical DSL for composing data streams, an execution model that decouples the stream’s staged computation—it’s “blueprint”—from its execution (allowing for actor-based, single-threaded and fully distributed and clustered execution), type safe stream composition, an implementation of the Reactive Streaming specification that enables back-pressure, and more than 20 predefined stream “processing stages” that provide common streaming transformations that developers can tap into (for splitting streams, transforming streams, merging streams, and more).
Slick is a relational database query and access library for Scala that enables loose-coupling, minimal configuration requirements and abstraction of the complexities of connecting with relational databases. With Slick 3.0, Slick now supports the Reactive Streams API for providing asynchronous stream processing with non-blocking back-pressure. Slick 3.0 also allows elegant mapping across multiple data types, static verification and type inference for embedded SQL statements, compile-time error discovery, and JDBC support for interoperability with all existing drivers.
The session will be about Twitter's RPC Library, Finagle. We well see why Finagle is a powerful library for asynchronous programming and will have a working implementation of simple use case.
Integrating Apache Kafka Into Your Environmentconfluent
Watch this talk here: https://www.confluent.io/online-talks/integrating-apache-kafka-into-your-environment-on-demand
Integrating Apache Kafka with other systems in a reliable and scalable way is a key part of an event streaming platform. This session will show you how to get streams of data into and out of Kafka with Kafka Connect and REST Proxy, maintain data formats and ensure compatibility with Schema Registry and Avro, and build real-time stream processing applications with Confluent KSQL and Kafka Streams.
This session is part 4 of 4 in our Fundamentals for Apache Kafka series.
As the world is growing, so is the data. And analysis of this data has become important. But how will you do it? How will you work with the data whose size is unknown to you? A solution to this scenario is Akka-Streams and here I’m going to discuss it.
In this session, you will get to know the basics of Akka-Streams just to get you started. So, let’s begin !!
The document provides an overview of Akka HTTP, streams, and routes. It discusses core concepts like streams, elements, back-pressure, sources, sinks, flows, and runnable graphs. It explains that routes define the request handling logic and are assembled into routing trees. Routes can complete requests, reject them, or perform asynchronous processing and return route results.
Apache Kafka is an open-source stream-processing software platform that is used as a messaging queue. It runs as a cluster of servers that can store streams of records in categories called topics. Producers write data to topics and consumers read from topics. The records in topics are organized into partitions which allow for parallelism and scalability. Kafka supports very high throughput, is elastically scalable, has low operational overhead and aims to provide high availability.
Understanding Akka Streams, Back Pressure, and Asynchronous ArchitecturesLightbend
The term 'streams' has been getting pretty overloaded recently–it's hard to know where to best use different technologies with streams in the name. In this talk by noted hAkker Konrad Malawski, we'll disambiguate what streams are and what they aren't, taking a deeper look into Akka Streams (the implementation) and Reactive Streams (the standard).
You'll be introduced to a number of real life scenarios where applying back-pressure helps to keep your systems fast and healthy at the same time. While the focus is mainly on the Akka Streams implementation, the general principles apply to any kind of asynchronous, message-driven architectures.
Apache Kafka is an open source distributed streaming platform used for building real-time data pipelines and applications. It allows for publishing and subscribing to streams of records, storing streams of records in a fault-tolerant way, and processing streams of records as they occur. Kafka has a producer-broker-consumer architecture and four core APIs. It provides advantages such as fault tolerance, scalability, and integration with stream processing systems. However, it also has limitations such as requiring coding and expertise to customize. Major companies like Apple, Netflix, and Walmart use Kafka.
Build Real-Time Streaming ETL Pipelines With Akka Streams, Alpakka And Apache...Lightbend
Things were easier when all our data used to be offline, analyzed overnight in batches. Now our data is online, in motion, and generated constantly. For architects, developers and their businesses, this means that there is an urgent need for tools and applications that can deliver real-time (or near real-time) streaming ETL capabilities.
In this session by Konrad Malawski, author, speaker and Senior Akka Engineer at Lightbend, you will learn how to build these streaming ETL pipelines with Akka Streams, Alpakka and Apache Kafka, and why they matter to enterprises that are increasingly turning to streaming Fast Data applications.
When it comes to cross-microservice communication, we must build an API, and the most significant criterion is that they all agree on the same type of exchange data, data format, and error format. We may now use REST/SOAP/Binary format for this, but we must also consider the endpoints, which appears to be a little tricky.
Your life will be much easier now that we can quickly connect services and share data via gRPC very easily. So, in this session, we will learn about gRPC and then I will demonstrate Akka gRPC and its features live.
When it comes to cross-microservice communication, we must build an API, and the most significant criterion is that they all agree on the same type of exchange data, data format, and error format. We may now use REST/SOAP/Binary format for this, but we must also consider the endpoints, which appears to be a little tricky.
Your life will be much easier now that we can quickly connect services and share data via gRPC very easily. So, in this session, we will learn about gRPC and then I will demonstrate Akka gRPC and its features live.
Getting Data In and Out of Flink - Understanding Flink and Its Connector Ecos...HostedbyConfluent
This document discusses Flink's connector ecosystem and how to get data in and out of Flink. It describes Flink's layered APIs, including Flink SQL, Table API, DataStream API, and ProcessFunction. It also covers Flink's source and sink interfaces, including the unified source and sink interfaces, hybrid sources, and watermark alignment. The document provides guidance on when to write custom connectors versus leveraging Flink's async I/O capabilities. It notes that Source- and SinkFunction are being deprecated and encourages contributing to existing connectors or building new ones.
This document provides an overview of reactive programming concepts including Reactive Streams and implementations like Akka and Akka Streams. It discusses:
- Non-blocking processing with asynchronous event loops and back pressure to prevent OutOfMemoryErrors.
- Use cases for Reactive Streams like managing uneven producer/consumer rates, ordering requirements, and efficient resource usage.
- Key aspects of Reactive Streams including the Publisher, Subscriber, and Subscription interfaces.
- How Akka implements the actor model for building concurrent, distributed applications and provides features like ordered message delivery, location transparency, and high-level components.
- How Akka Streams implements Reactive Streams for building data pipelines
Over 100 million subscribers from over 190 countries enjoy the Netflix service. This leads to over a trillion events, amounting to 3 PB, flowing through the Keystone infrastructure to help improve customer experience and glean business insights. The self-serve Keystone stream processing service processes these messages in near real-time with at-least once semantics in the cloud. This enables the users to focus on extracting insights, and not worry about building out scalable infrastructure. I’ll share the details about this platform, and our experience building it.
Terratest - Automation testing of infrastructureKnoldus Inc.
TerraTest is a testing framework specifically designed for testing infrastructure code written with HashiCorp's Terraform. It helps validate that your Terraform configurations create the desired infrastructure, and it can be used for both unit testing and integration testing.
Getting Started with Apache Spark (Scala)Knoldus Inc.
In this session, we are going to cover Apache Spark, the architecture of Apache Spark, Data Lineage, Direct Acyclic Graph(DAG), and many more concepts. Apache Spark is a multi-language engine for executing data engineering, data science, and machine learning on single-node machines or clusters.
Secure practices with dot net services.pptxKnoldus Inc.
Securing .NET services is paramount for protecting applications and data. Employing encryption, strong authentication, and adherence to best coding practices ensures resilience against potential threats, enhancing overall cybersecurity posture.
Distributed Cache with dot microservicesKnoldus Inc.
A distributed cache is a cache shared by multiple app servers, typically maintained as an external service to the app servers that access it. A distributed cache can improve the performance and scalability of an ASP.NET Core app, especially when the app is hosted by a cloud service or a server farm. Here we will look into implementation of Distributed Caching Strategy with Redis in Microservices Architecture focusing on cache synchronization, eviction policies, and cache consistency.
Introduction to gRPC Presentation (Java)Knoldus Inc.
gRPC, which stands for Remote Procedure Call, is an open-source framework developed by Google. It is designed for building efficient and scalable distributed systems. gRPC enables communication between client and server applications by defining a set of services and message types using Protocol Buffers (protobuf) as the interface definition language. gRPC provides a way for applications to call methods on a remote server as if they were local procedures, making it a powerful tool for building distributed and microservices-based architectures.
Using InfluxDB for real-time monitoring in JmeterKnoldus Inc.
Explore the integration of InfluxDB with JMeter for real-time performance monitoring. This session will cover setting up InfluxDB to capture JMeter metrics, configuring JMeter to send data to InfluxDB, and visualizing the results using Grafana. Learn how to leverage this powerful combination to gain real-time insights into your application's performance, enabling proactive issue detection and faster resolution.
Intoduction to KubeVela Presentation (DevOps)Knoldus Inc.
KubeVela is an open-source platform for modern application delivery and operation on Kubernetes. It is designed to simplify the deployment and management of applications in a Kubernetes environment. KubeVela is a modern software delivery platform that makes deploying and operating applications across today's hybrid, multi-cloud environments easier, faster and more reliable. KubeVela is infrastructure agnostic, programmable, yet most importantly, application-centric. It allows you to build powerful software, and deliver them anywhere!
Stakeholder Management (Project Management) PresentationKnoldus Inc.
A stakeholder is someone who has an interest in or who is affected by your project and its outcome. This may include both internal and external entities such as the members of the project team, project sponsors, executives, customers, suppliers, partners and the government. Stakeholder management is the process of managing the expectations and the requirements of these stakeholders.
Introduction To Kaniko (DevOps) PresentationKnoldus Inc.
Kaniko is an open-source tool developed by Google that enables building container images from a Dockerfile inside a Kubernetes cluster without requiring a Docker daemon. Kaniko executes each command in the Dockerfile in the user space using an executor image, which runs inside a container, such as a Kubernetes pod. This allows building container images in environments where the user doesn’t have root access, like a Kubernetes cluster.
Efficient Test Environments with Infrastructure as Code (IaC)Knoldus Inc.
In the rapidly evolving landscape of software development, the need for efficient and scalable test environments has become more critical than ever. This session, "Streamlining Development: Unlocking Efficiency through Infrastructure as Code (IaC) in Test Environments," is designed to provide an in-depth exploration of how leveraging IaC can revolutionize your testing processes and enhance overall development productivity.
Exploring Terramate DevOps (Presentation)Knoldus Inc.
Terramate is a code generator and orchestrator for Terraform that enhances Terraform's capabilities by adding features such as code generation, stacks, orchestration, change detection, globals, and more . It's primarily designed to help manage Terraform code at scale more efficiently . Terramate is particularly useful for managing multiple Terraform stacks, providing support for change detection and code generation 2. It allows you to create relationships between stacks to improve your understanding and control over your infrastructure . One of the key features of Terramate is its ability to detect changes at both the stack and module level. This capability allows you to identify which stacks and resources have been altered and selectively determine where you should execute commands.
Clean Code in Test Automation Differentiating Between the Good and the BadKnoldus Inc.
This session focuses on the principles of writing clean, maintainable, and efficient code in the context of test automation. The session will highlight the characteristics that distinguish good test automation code from bad, ultimately leading to more reliable and scalable testing frameworks.
Integrating AI Capabilities in Test AutomationKnoldus Inc.
Explore the integration of artificial intelligence in test automation. Understand how AI can enhance test planning, execution, and analysis, leading to more efficient and reliable testing processes. Explore the cutting-edge integration of Artificial Intelligence (AI) capabilities in Test Automation, a transformative approach shaping the future of software testing. This session will delve into practical applications, benefits, and considerations associated with infusing AI into test automation workflows.
State Management with NGXS in Angular.pptxKnoldus Inc.
NGXS is a state management pattern and library for Angular. NGXS acts as a single source of truth for your application's state - providing simple rules for predictable state mutations. In this session we will go through the main for components of NGXS -Store, Actions, State, and Select.
Authentication in Svelte using cookies.pptxKnoldus Inc.
Svelte streamlines authentication with cookies, offering a secure and seamless user experience. Effortlessly manage sessions by storing tokens in cookies, ensuring persistent logins. With Svelte's simplicity, implement robust authentication mechanisms, enhancing user security and interaction.
OAuth2 Implementation Presentation (Java)Knoldus Inc.
The OAuth 2.0 authorization framework is a protocol that allows a user to grant a third-party web site or application access to the user's protected resources, without necessarily revealing their long-term credentials or even their identity. It is commonly used in scenarios such as user authentication in web and mobile applications and enables a more secure and user-friendly authorization process.
Supply chain security with Kubeclarity.pptxKnoldus Inc.
Kube clarity is a comprehensive solution designed to enhance supply chain security within Kubernetes environments. Kube clarity enables organizations to identify and mitigate potential security threats throughout the software development and deployment process.
Mastering Web Scraping with JSoup Unlocking the Secrets of HTML ParsingKnoldus Inc.
In this session, we will delve into the world of web scraping with JSoup, an open-source Java library. Here we are going to learn how to parse HTML effectively, extract meaningful data, and navigate the Document Object Model (DOM) for powerful web scraping capabilities.
Akka gRPC Essentials A Hands-On IntroductionKnoldus Inc.
Dive into the fundamental aspects of Akka gRPC and learn to leverage its power in building compact and efficient distributed systems. This session aims to equip attendees with the essential skills and knowledge to leverage Akka and gRPC effectively in building robust, scalable, and distributed applications.
Entity Core with Core Microservices.pptxKnoldus Inc.
How Developers can use Entity framework(ORM) which provides a structured and consistent way for microservices to interact with their respective database, prompting independence, scaliblity and maintainiblity in a distributed system, and also provide a high-level abstraction for data access.
Enchancing adoption of Open Source Libraries. A case study on Albumentations.AIVladimir Iglovikov, Ph.D.
Presented by Vladimir Iglovikov:
- https://www.linkedin.com/in/iglovikov/
- https://x.com/viglovikov
- https://www.instagram.com/ternaus/
This presentation delves into the journey of Albumentations.ai, a highly successful open-source library for data augmentation.
Created out of a necessity for superior performance in Kaggle competitions, Albumentations has grown to become a widely used tool among data scientists and machine learning practitioners.
This case study covers various aspects, including:
People: The contributors and community that have supported Albumentations.
Metrics: The success indicators such as downloads, daily active users, GitHub stars, and financial contributions.
Challenges: The hurdles in monetizing open-source projects and measuring user engagement.
Development Practices: Best practices for creating, maintaining, and scaling open-source libraries, including code hygiene, CI/CD, and fast iteration.
Community Building: Strategies for making adoption easy, iterating quickly, and fostering a vibrant, engaged community.
Marketing: Both online and offline marketing tactics, focusing on real, impactful interactions and collaborations.
Mental Health: Maintaining balance and not feeling pressured by user demands.
Key insights include the importance of automation, making the adoption process seamless, and leveraging offline interactions for marketing. The presentation also emphasizes the need for continuous small improvements and building a friendly, inclusive community that contributes to the project's growth.
Vladimir Iglovikov brings his extensive experience as a Kaggle Grandmaster, ex-Staff ML Engineer at Lyft, sharing valuable lessons and practical advice for anyone looking to enhance the adoption of their open-source projects.
Explore more about Albumentations and join the community at:
GitHub: https://github.com/albumentations-team/albumentations
Website: https://albumentations.ai/
LinkedIn: https://www.linkedin.com/company/100504475
Twitter: https://x.com/albumentations
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdfMalak Abu Hammad
Discover how MongoDB Atlas and vector search technology can revolutionize your application's search capabilities. This comprehensive presentation covers:
* What is Vector Search?
* Importance and benefits of vector search
* Practical use cases across various industries
* Step-by-step implementation guide
* Live demos with code snippets
* Enhancing LLM capabilities with vector search
* Best practices and optimization strategies
Perfect for developers, AI enthusiasts, and tech leaders. Learn how to leverage MongoDB Atlas to deliver highly relevant, context-aware search results, transforming your data retrieval process. Stay ahead in tech innovation and maximize the potential of your applications.
#MongoDB #VectorSearch #AI #SemanticSearch #TechInnovation #DataScience #LLM #MachineLearning #SearchTechnology
Unlocking Productivity: Leveraging the Potential of Copilot in Microsoft 365, a presentation by Christoforos Vlachos, Senior Solutions Manager – Modern Workplace, Uni Systems
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdfPaige Cruz
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
Full-RAG: A modern architecture for hyper-personalizationZilliz
Mike Del Balso, CEO & Co-Founder at Tecton, presents "Full RAG," a novel approach to AI recommendation systems, aiming to push beyond the limitations of traditional models through a deep integration of contextual insights and real-time data, leveraging the Retrieval-Augmented Generation architecture. This talk will outline Full RAG's potential to significantly enhance personalization, address engineering challenges such as data management and model training, and introduce data enrichment with reranking as a key solution. Attendees will gain crucial insights into the importance of hyperpersonalization in AI, the capabilities of Full RAG for advanced personalization, and strategies for managing complex data integrations for deploying cutting-edge AI solutions.
20 Comprehensive Checklist of Designing and Developing a WebsitePixlogix Infotech
Dive into the world of Website Designing and Developing with Pixlogix! Looking to create a stunning online presence? Look no further! Our comprehensive checklist covers everything you need to know to craft a website that stands out. From user-friendly design to seamless functionality, we've got you covered. Don't miss out on this invaluable resource! Check out our checklist now at Pixlogix and start your journey towards a captivating online presence today.
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/building-and-scaling-ai-applications-with-the-nx-ai-manager-a-presentation-from-network-optix/
Robin van Emden, Senior Director of Data Science at Network Optix, presents the “Building and Scaling AI Applications with the Nx AI Manager,” tutorial at the May 2024 Embedded Vision Summit.
In this presentation, van Emden covers the basics of scaling edge AI solutions using the Nx tool kit. He emphasizes the process of developing AI models and deploying them globally. He also showcases the conversion of AI models and the creation of effective edge AI pipelines, with a focus on pre-processing, model conversion, selecting the appropriate inference engine for the target hardware and post-processing.
van Emden shows how Nx can simplify the developer’s life and facilitate a rapid transition from concept to production-ready applications.He provides valuable insights into developing scalable and efficient edge AI solutions, with a strong focus on practical implementation.
In the rapidly evolving landscape of technologies, XML continues to play a vital role in structuring, storing, and transporting data across diverse systems. The recent advancements in artificial intelligence (AI) present new methodologies for enhancing XML development workflows, introducing efficiency, automation, and intelligent capabilities. This presentation will outline the scope and perspective of utilizing AI in XML development. The potential benefits and the possible pitfalls will be highlighted, providing a balanced view of the subject.
We will explore the capabilities of AI in understanding XML markup languages and autonomously creating structured XML content. Additionally, we will examine the capacity of AI to enrich plain text with appropriate XML markup. Practical examples and methodological guidelines will be provided to elucidate how AI can be effectively prompted to interpret and generate accurate XML markup.
Further emphasis will be placed on the role of AI in developing XSLT, or schemas such as XSD and Schematron. We will address the techniques and strategies adopted to create prompts for generating code, explaining code, or refactoring the code, and the results achieved.
The discussion will extend to how AI can be used to transform XML content. In particular, the focus will be on the use of AI XPath extension functions in XSLT, Schematron, Schematron Quick Fixes, or for XML content refactoring.
The presentation aims to deliver a comprehensive overview of AI usage in XML development, providing attendees with the necessary knowledge to make informed decisions. Whether you’re at the early stages of adopting AI or considering integrating it in advanced XML development, this presentation will cover all levels of expertise.
By highlighting the potential advantages and challenges of integrating AI with XML development tools and languages, the presentation seeks to inspire thoughtful conversation around the future of XML development. We’ll not only delve into the technical aspects of AI-powered XML development but also discuss practical implications and possible future directions.
Alt. GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using ...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
GraphSummit Singapore | The Future of Agility: Supercharging Digital Transfor...Neo4j
Leonard Jayamohan, Partner & Generative AI Lead, Deloitte
This keynote will reveal how Deloitte leverages Neo4j’s graph power for groundbreaking digital twin solutions, achieving a staggering 100x performance boost. Discover the essential role knowledge graphs play in successful generative AI implementations. Plus, get an exclusive look at an innovative Neo4j + Generative AI solution Deloitte is developing in-house.
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?Speck&Tech
ABSTRACT: A prima vista, un mattoncino Lego e la backdoor XZ potrebbero avere in comune il fatto di essere entrambi blocchi di costruzione, o dipendenze di progetti creativi e software. La realtà è che un mattoncino Lego e il caso della backdoor XZ hanno molto di più di tutto ciò in comune.
Partecipate alla presentazione per immergervi in una storia di interoperabilità, standard e formati aperti, per poi discutere del ruolo importante che i contributori hanno in una comunità open source sostenibile.
BIO: Sostenitrice del software libero e dei formati standard e aperti. È stata un membro attivo dei progetti Fedora e openSUSE e ha co-fondato l'Associazione LibreItalia dove è stata coinvolta in diversi eventi, migrazioni e formazione relativi a LibreOffice. In precedenza ha lavorato a migrazioni e corsi di formazione su LibreOffice per diverse amministrazioni pubbliche e privati. Da gennaio 2020 lavora in SUSE come Software Release Engineer per Uyuni e SUSE Manager e quando non segue la sua passione per i computer e per Geeko coltiva la sua curiosità per l'astronomia (da cui deriva il suo nickname deneb_alpha).
Climate Impact of Software Testing at Nordic Testing DaysKari Kakkonen
My slides at Nordic Testing Days 6.6.2024
Climate impact / sustainability of software testing discussed on the talk. ICT and testing must carry their part of global responsibility to help with the climat warming. We can minimize the carbon footprint but we can also have a carbon handprint, a positive impact on the climate. Quality characteristics can be added with sustainability, and then measured continuously. Test environments can be used less, and in smaller scale and on demand. Test techniques can be used in optimizing or minimizing number of tests. Test automation can be used to speed up testing.
Essentials of Automations: The Art of Triggers and Actions in FMESafe Software
In this second installment of our Essentials of Automations webinar series, we’ll explore the landscape of triggers and actions, guiding you through the nuances of authoring and adapting workspaces for seamless automations. Gain an understanding of the full spectrum of triggers and actions available in FME, empowering you to enhance your workspaces for efficient automation.
We’ll kick things off by showcasing the most commonly used event-based triggers, introducing you to various automation workflows like manual triggers, schedules, directory watchers, and more. Plus, see how these elements play out in real scenarios.
Whether you’re tweaking your current setup or building from the ground up, this session will arm you with the tools and insights needed to transform your FME usage into a powerhouse of productivity. Join us to discover effective strategies that simplify complex processes, enhancing your productivity and transforming your data management practices with FME. Let’s turn complexity into clarity and make your workspaces work wonders!
1. Presented By: Mohd Alimuddin
Software Trainee Intern
Akka HTTP with
Scala
2. Lack of etiquette and manners is a huge turn off.
KnolX Etiquettes
Punctuality
Respect Knolx session timings, you
are requested not to join sessions
after a 5 minutes threshold post
the session start time.
Feedback
Make sure to submit a constructive
feedback for all sessions as it is
very helpful for the presenter.
Silent Mode
Keep your mobile devices in silent
mode, feel free to move out of
session in case you need to attend
an urgent call.
Avoid Disturbance
Avoid unwanted chit chat during
the session.
3. Our Agenda
What is Akka HTTP?
02 What is Akka and Akka Actors?
03 What is Akka Streams?
Marshalling & Unmarshalling
05
Low-Level API
01
04
05
High-Level API
06
07 Demo
4. What is Akka HTTP?
● Akka HTTP is a suite of libraries whose focuses is on HTTP integration of an
application.
● Akka HTTP is based on Akka actors and Akka streams.
● It is fully asynchronous and non blocking.
● Akka HTTP is not a framework but a toolkit which means it can be used on the
top of other framework such as Play and Lagom.
5. What is Akka and Akka Actors?
● Akka is an free and open source toolkit which is used to make highly
concurrent, distributed and fault tolerant applications on JVM.
● Akka uses actor model system which first introduced by Carl Eddie Hewitt in
1973.
● Actors represents computation unit which encapsulates its state and
application logic.
● Each actors uses asynchronous messages to interact with other actors and
actors uses mailbox to process all the messages.
6. Akka Actors
● Messages are handled by Message Handler and are extracted from the
mailbox in order of FIFO.
● Actors guarantees the message order is always maintained.
● Actors guarantees the messages are never duplicated.
7. What is Akka streams ?
● Akka streams implements Reactive streams using Akka actors concurrent
model.
● Akka streams has three major components Source, Flow and Sink which are
equivalent of Publisher, Processor and Subscriber.
● Source emits element or data asynchronously
● Flow transform elements, can perform computations
● Sink receives elements
Source
Flow
Sink
8. Marshalling and Unmarshalling
● In Akka HTTP, marshalling means the conversion of an object of type T into a
lower-level target, e.g a MessageEntity or HttpRequest or HttpResponse.
Marshalling is also known as Serialization or Pickling.
● In Akka HTTP, unmarshalling means the conversion of a lower-level source
object e.g MessageEntity or HttpRequest or HttpResponse into a instance of
type T. Unmarshalling is also known as Deserialization or Unpickling
9. Low-Level API
● The low-level Akka HTTP server API allows for handling connections or individual
request by accepting HTTP Requests and answering them by producing HTTP
Responses.
● This is provided by the akka-http-core module.
● Low Level API based simply on mapping request to response.
10. High-Level API
● Low Level API becomes uneasy to handle when we need to create a large
number of routes and complex applications. To solve this we use High-Level
API.
● High-Level API can be divided into two important parts-
● Directives
● Routes
11. Directives & Routes
● A Directives is a small building block used for creating arbitrary complex
route structures.
● Routes are highly specialized functions that take a RequestContext and
eventually complete it which happens asynchronously.
● Each Routes is composed of one or more Directives that handles one specific
kind of request.
type Route = RequestContext => Future[RouteResult]