Japanese subtitles by Yugo Maede-san, thank you very much. Japanese subtitled version of the "How Reactive Streams and Akka Streams change the JVM Ecosystem". http://www.slideshare.net/ktoso/how-reactive-streams-akka-streams-change-the-jvm-ecosystem
End to End Akka Streams / Reactive Streams - from Business to SocketKonrad Malawski
The Reactive Streams specification, along with its TCK and various implementations such as Akka Streams, is coming closer and closer with the inclusion of the RS types in JDK 9. Using an example Twitter-like streaming service implementation, this session shows why this is a game changer in terms of how you can design reactive streaming applications by connecting pipelines of back-pressured asynchronous processing stages. The presentation looks at the example from two perspectives: a raw implementation and an implementation addressing a high-level business need.
Reactive Streams are a cross-company initiative first ignited by Lightbend in 2013, soon to be joined by RxJava and other implementations focused on solving a very similar problem: asynchronous non-blocking stream processing, with guaranteed over-flow protection. Fast forward to 2016 and now these interfaces are part of JSR-266 and proposed for JDK9.
In this talk we'll first disambiguate what the word Stream means in this context (as it's been overloaded recently by various different meanings), then look at how its protocol works and how one might use it in the real world showing examples using existing implementations.
We'll also have a peek into the future, to see what the next steps for such collaborative protocols and the JDK ecosystem are in general.
Akka-chan's Survival Guide for the Streaming WorldKonrad Malawski
In this talk we dive into the various kinds of "Streaming", what it actually means, where to use which technology and specifically take a look at Akka Streams and their specific use case and strengths.
End to End Akka Streams / Reactive Streams - from Business to SocketKonrad Malawski
The Reactive Streams specification, along with its TCK and various implementations such as Akka Streams, is coming closer and closer with the inclusion of the RS types in JDK 9. Using an example Twitter-like streaming service implementation, this session shows why this is a game changer in terms of how you can design reactive streaming applications by connecting pipelines of back-pressured asynchronous processing stages. The presentation looks at the example from two perspectives: a raw implementation and an implementation addressing a high-level business need.
Reactive Streams are a cross-company initiative first ignited by Lightbend in 2013, soon to be joined by RxJava and other implementations focused on solving a very similar problem: asynchronous non-blocking stream processing, with guaranteed over-flow protection. Fast forward to 2016 and now these interfaces are part of JSR-266 and proposed for JDK9.
In this talk we'll first disambiguate what the word Stream means in this context (as it's been overloaded recently by various different meanings), then look at how its protocol works and how one might use it in the real world showing examples using existing implementations.
We'll also have a peek into the future, to see what the next steps for such collaborative protocols and the JDK ecosystem are in general.
Akka-chan's Survival Guide for the Streaming WorldKonrad Malawski
In this talk we dive into the various kinds of "Streaming", what it actually means, where to use which technology and specifically take a look at Akka Streams and their specific use case and strengths.
Reactive Streams: Handling Data-Flow the Reactive WayRoland Kuhn
Building on the success of Reactive Extensions—first in Rx.NET and now in RxJava—we are taking Observers and Observables to the next level: by adding the capability of handling back-pressure between asynchronous execution stages we enable the distribution of stream processing across a cluster of potentially thousands of nodes. The project defines the common interfaces for interoperable stream implementations on the JVM and is the result of a collaboration between Twitter, Netflix, Pivotal, RedHat and Typesafe. In this presentation I introduce the guiding principles behind its design and show examples using the actor-based implementation in Akka.
This is a work in progress of a talk for the Scala User Group in Tokyo.
It touches on basics and some ideas behind Reactive Streams as well as the implementation shipped by Akka.
Akka Streams (0.7) talk for the Tokyo Scala User Group, hosted by Dwango.
Akka streams are an reactive streams implementation which allows for asynchronous back-pressured processing of data in complext pipelines. This talk aims to highlight the details about how reactive streams work as well as some of the ideas behind akka streams.
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.
Akka A to Z: A Guide To The Industry’s Best Toolkit for Fast Data and Microse...Lightbend
Microservices. Streaming data. Event Sourcing and CQRS. Concurrency, routing, self-healing, persistence, clustering… You get the picture. The Akka toolkit makes all of this simple for Java and Scala developers at Amazon, LinkedIn, Starbucks, Verizon and others. So how does Akka provide all these features out of the box?
Join Hugh McKee, Akka expert and Developer Advocate at Lightbend, on an illustrated journey that goes deep into how Akka works–from individual Akka actors to fully distributed clusters across multiple datacenters.
Akka Revealed: A JVM Architect's Journey From Resilient Actors To Scalable Cl...Lightbend
By now, you’ve probably heard of Akka, the JVM toolkit for building scalable, resilient and resource efficient applications in Java or Scala. With over 12 open-source and commercial modules in the toolkit, Akka takes developers from actors on a single JVM, all the way out to network partition healing and clusters of servers distributed across fleets of JVMs. But with such a broad range of features, how can Architects and Developers grok Akka from a high-level perspective?
In this technical webinar by Hugh McKee, O’Reilly author and Developer Advocate at Lightbend, we introduce Akka from A to Z, starting with a tour from the humble actor and finishing all the way at the clustered systems level. Specifically, we will review:
*How Akka Actors behave, create systems, and manage supervision and routing
*The way Akka embraces Reactive Streams with Akka Streams and Alpakka
*How various components of the Akka toolkit provide out-of-the-box solutions for distributed data, distributed persistence, pub-sub, and ES/CQRS
*How Akka works with microservices, and brings this functionality into Lagom and Play Frameworks
*Looking at Akka clusters, how Akka is used to build distributed clustered systems incorporate clusters within clusters
*What’s needed to orchestrate and deploy complete Reactive Systems
Putting the 'I' in IoT - Building Digital Twins with Akka MicroservicesLightbend
In this webinar with Hugh McKee, Developer Advocate for Akka Platform, we’ll look at “What on Earth”, a demo exploring how Akka Microservices serves as an ideal solution for high-scale digital twinning for IoT.
For the full presentation, including video, visit: https://www.lightbend.com/blog/iot-building-digital-twins-with-akka-microservices
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.
Slides from my madlab presentation on Akka Streams & Reactive Kafka (October 2015), full slides and source here:
https://github.com/markglh/AkkaStreams-Madlab-Slides
Journey into Reactive Streams and Akka StreamsKevin Webber
Are streams just collections? What's the difference between Java 8 streams and Reactive Streams? How do I implement Reactive Streams with Akka? Pub/sub, dynamic push/pull, non-blocking, non-dropping; these are some of the other concepts covered. We'll also discuss how to leverage streams in a real-world application.
Akka Streams are an implementation of the Reactive Streams specification (http://reactive-streams.org/), a joint effort that aims at standardizing the exchange of streams of data across asynchronous boundaries in a fully non-blocking way while providing flow control and mediating back pressure. In this presentation we go into the details of what this new abstraction can be used for and what the guiding principles are behind its development. We then focus on one prominent use-case which is the upcoming Akka HTTP module: a fully stream-enabled, reactive HTTP server and client implementation.
Streaming Microservices With Akka Streams And Kafka StreamsLightbend
One of the most frequent questions that we get asked at Lightbend is “what’s the difference between Akka Streams and Kafka Streams?” After all, there is only a 1 letter difference between these two technologies, so how different could they be?
Well, as we see in this presentation, they are actually quite different. Both tools are part of the streaming Fast Data stack, but were created with entirely different technological approaches in mind. For example, While Akka Streams emerged as a dataflow-centric abstraction for the Akka Actor model, designed for general-purpose microservices, very low-latency event processing, and supports a wider class of application problems and third-party integrations via Alpakka, Kafka Streams is purpose-built for reading data from Kafka topics, processing it, and writing the results to new topics in a Kafka-centric way.
In this webinar by Dr. Dean Wampler, VP of Fast Data Engineering at Lightbend, we will:
* Discuss the strengths and weaknesses of Kafka Streams and Akka Streams for particular design needs in data-centric microservices
* Contrast them with Spark Streaming and Flink, which provide richer analytics over potentially huge data sets
* Help you map these streaming engines to your specific use cases, so you confidently pick the right ones for your jobs
Reactive Streams: Handling Data-Flow the Reactive WayRoland Kuhn
Building on the success of Reactive Extensions—first in Rx.NET and now in RxJava—we are taking Observers and Observables to the next level: by adding the capability of handling back-pressure between asynchronous execution stages we enable the distribution of stream processing across a cluster of potentially thousands of nodes. The project defines the common interfaces for interoperable stream implementations on the JVM and is the result of a collaboration between Twitter, Netflix, Pivotal, RedHat and Typesafe. In this presentation I introduce the guiding principles behind its design and show examples using the actor-based implementation in Akka.
This is a work in progress of a talk for the Scala User Group in Tokyo.
It touches on basics and some ideas behind Reactive Streams as well as the implementation shipped by Akka.
Akka Streams (0.7) talk for the Tokyo Scala User Group, hosted by Dwango.
Akka streams are an reactive streams implementation which allows for asynchronous back-pressured processing of data in complext pipelines. This talk aims to highlight the details about how reactive streams work as well as some of the ideas behind akka streams.
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.
Akka A to Z: A Guide To The Industry’s Best Toolkit for Fast Data and Microse...Lightbend
Microservices. Streaming data. Event Sourcing and CQRS. Concurrency, routing, self-healing, persistence, clustering… You get the picture. The Akka toolkit makes all of this simple for Java and Scala developers at Amazon, LinkedIn, Starbucks, Verizon and others. So how does Akka provide all these features out of the box?
Join Hugh McKee, Akka expert and Developer Advocate at Lightbend, on an illustrated journey that goes deep into how Akka works–from individual Akka actors to fully distributed clusters across multiple datacenters.
Akka Revealed: A JVM Architect's Journey From Resilient Actors To Scalable Cl...Lightbend
By now, you’ve probably heard of Akka, the JVM toolkit for building scalable, resilient and resource efficient applications in Java or Scala. With over 12 open-source and commercial modules in the toolkit, Akka takes developers from actors on a single JVM, all the way out to network partition healing and clusters of servers distributed across fleets of JVMs. But with such a broad range of features, how can Architects and Developers grok Akka from a high-level perspective?
In this technical webinar by Hugh McKee, O’Reilly author and Developer Advocate at Lightbend, we introduce Akka from A to Z, starting with a tour from the humble actor and finishing all the way at the clustered systems level. Specifically, we will review:
*How Akka Actors behave, create systems, and manage supervision and routing
*The way Akka embraces Reactive Streams with Akka Streams and Alpakka
*How various components of the Akka toolkit provide out-of-the-box solutions for distributed data, distributed persistence, pub-sub, and ES/CQRS
*How Akka works with microservices, and brings this functionality into Lagom and Play Frameworks
*Looking at Akka clusters, how Akka is used to build distributed clustered systems incorporate clusters within clusters
*What’s needed to orchestrate and deploy complete Reactive Systems
Putting the 'I' in IoT - Building Digital Twins with Akka MicroservicesLightbend
In this webinar with Hugh McKee, Developer Advocate for Akka Platform, we’ll look at “What on Earth”, a demo exploring how Akka Microservices serves as an ideal solution for high-scale digital twinning for IoT.
For the full presentation, including video, visit: https://www.lightbend.com/blog/iot-building-digital-twins-with-akka-microservices
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.
Slides from my madlab presentation on Akka Streams & Reactive Kafka (October 2015), full slides and source here:
https://github.com/markglh/AkkaStreams-Madlab-Slides
Journey into Reactive Streams and Akka StreamsKevin Webber
Are streams just collections? What's the difference between Java 8 streams and Reactive Streams? How do I implement Reactive Streams with Akka? Pub/sub, dynamic push/pull, non-blocking, non-dropping; these are some of the other concepts covered. We'll also discuss how to leverage streams in a real-world application.
Akka Streams are an implementation of the Reactive Streams specification (http://reactive-streams.org/), a joint effort that aims at standardizing the exchange of streams of data across asynchronous boundaries in a fully non-blocking way while providing flow control and mediating back pressure. In this presentation we go into the details of what this new abstraction can be used for and what the guiding principles are behind its development. We then focus on one prominent use-case which is the upcoming Akka HTTP module: a fully stream-enabled, reactive HTTP server and client implementation.
Streaming Microservices With Akka Streams And Kafka StreamsLightbend
One of the most frequent questions that we get asked at Lightbend is “what’s the difference between Akka Streams and Kafka Streams?” After all, there is only a 1 letter difference between these two technologies, so how different could they be?
Well, as we see in this presentation, they are actually quite different. Both tools are part of the streaming Fast Data stack, but were created with entirely different technological approaches in mind. For example, While Akka Streams emerged as a dataflow-centric abstraction for the Akka Actor model, designed for general-purpose microservices, very low-latency event processing, and supports a wider class of application problems and third-party integrations via Alpakka, Kafka Streams is purpose-built for reading data from Kafka topics, processing it, and writing the results to new topics in a Kafka-centric way.
In this webinar by Dr. Dean Wampler, VP of Fast Data Engineering at Lightbend, we will:
* Discuss the strengths and weaknesses of Kafka Streams and Akka Streams for particular design needs in data-centric microservices
* Contrast them with Spark Streaming and Flink, which provide richer analytics over potentially huge data sets
* Help you map these streaming engines to your specific use cases, so you confidently pick the right ones for your jobs
The things we don't see – stories of Software, Scala and AkkaKonrad Malawski
Opening keynote for Scalapeno, Tel Aviv 2016.
The talk focuses and explains the things we don't often see explicitly and/or don't notice when doing our daily work, yet make up a large part of the ecosystem and maturity of the ecoststem as a whole. We also dive into some of the more confusing bits around using the same word about different things in software
Event sourcing and Domain Driven Design are techniques that allow you to model your business more truthfully - by expressing it via commands, events and aggregates etc. The new akka-persistence module, included in Akka since the 2.3 release is aimed at easing implementing event sourced applications. Turns out the actor model and events as messages fit in here perfectly. During this session we'll discover how to build reactive, event sourcing based apps using the new abstractions provided, and investigate how to implement your own journals to back these persistent event sourced actors.
Distributed Consensus A.K.A. "What do we eat for lunch?"Konrad Malawski
Distributed Consensus is everywhere! Even if not obvious at first, most apps nowadays are distributed systems, and these sometimes have to "agree on a value", this is where consensus algorithms come in. In this session we'll look at the general problem and solve a few example cases using the RAFT algorithm implemented using Akka's Actor and Cluster modules.
Akka persistence == event sourcing in 30 minutesKonrad Malawski
Akka 2.3 introduces akka-persistence, a wonderful way of implementing event-sourced applications. Let's give it a shot and see how DDD and Akka are a match made in heaven :-)
This talk was delivered at JavaOne 2013, together with Andrzej Grzesik. We mention the new Date APIs, changes to Collections as well as Streams APIs and of course... Lambdas!
Janab e Zainab Ki Shakhsiyat (Hindi) - By: Syed ul Ulema Syed Ali Naqi Naqvi ...Jamal Mirza
Janab e Zainab Ki Shakhsiyat - By: Syed ul Ulema Syed Ali Naqi Naqvi t.s.
" Aap Hazrat Ali Bin Abi Talib a.s. aur Janab e Fatima Zehra s.a. ki badi Beiti aur Paighambar e Islam ki badi Nawasi thiiN. Iss haisiyat se aap Karbala ke waaqaey meiN Hazrat Imam Hussain a.s. ke baad sabse zyada mashoor shakhsiyat thiiN. .. .. "
Short lightning talk about the HBase plugin for Akka Persistence and how it's how key design was specifically tuned for increasing numeric sequential idenfitiers, so that the cluster can be utilised properly.
https://github.com/ktoso/akka-persistence-hbase
Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/2jtXmQR.
Konrad Malawski explains what the word Stream means, then looks at how its protocol works and how one might use it in the real world showing examples using existing implementations. He also peeks into the future, to see what the next steps for such collaborative protocols and the JDK ecosystem are in general. Filmed at qconsf.com.
Konrad Malawski works at Akka @Lightbend & Reactive Streams Committer, where he participated in the Reactive Streams initiative and implemented its Technology Compatibility Kit. He maintains a number of Scala tools (such as sbt-jmh), and frequently speaks on distributed systems and concurrency topics at conferences. He also holds number of titles, including Java One RockStar 2015.
Sviluppare applicazioni nell'era dei "Big Data" con Scala e Spark - Mario Car...Codemotion
Scala è un linguaggio di programmazione general purpose multi-paradigma pensato per realizzare applicazioni ad alte prestazioni che girano all'interno della Java Virtual Machine. Spark è il framework "Big Data", basato su Scala, più flessibile e performante disponibile oggi sul mercato. Durante il talk verrà introdotto il linguaggio Scala e verranno mostrate le potenzialità legate al suo utilizzo nell'ambito dello sviluppo di applicazioni web di ultima generazione compresa la possibilità di processamento parallelo di grandi quantità di dati attraverso l'utilizzo del framework Spark.
The aim of the EU FP 7 Large-Scale Integrating Project LarKC is to develop the Large Knowledge Collider (LarKC, for short, pronounced “lark”), a platform for massive distributed incomplete reasoning that will remove the scalability barriers of currently existing reasoning systems for the Semantic Web. The LarKC platform is available at larkc.sourceforge.net. This talk, is part of a tutorial for early users of the LarKC platform, and introduces the platform and the project in general.
In this article I am going to present some of the most useful Scala libraries and frameworks which help ASSIST Software engineers to develop highly scalable applications that support concurrency and non-blocking.
Openstack - An introduction/Installation - Presented at Dr Dobb's conference...Rahul Krishna Upadhyaya
Slide was presented at Dr. Dobb's Conference in Bangalore.
Talks about Openstack Introduction in general
Projects under Openstack.
Contributing to Openstack.
This was presented jointly by CB Ananth and Rahul at Dr. Dobb's Conference Bangalore on 12th Apr 2014.
Sviluppare applicazioni nell'era dei "Big Data" con Scala e Spark - Mario Car...Codemotion
Scala è un linguaggio di programmazione general purpose multi-paradigma pensato per realizzare applicazioni ad alte prestazioni che girano all'interno della Java Virtual Machine. Spark è il framework "Big Data", basato su Scala, più flessibile e performante disponibile oggi sul mercato. Durante il talk verrà introdotto il linguaggio Scala e verranno mostrate le potenzialità legate al suo utilizzo nell'ambito dello sviluppo di applicazioni web di ultima generazione compresa la possibilità di processamento parallelo di grandi quantità di dati attraverso l'utilizzo del framework Spark.
OpenStack Training | OpenStack Tutorial For Beginners | OpenStack Certificati...Edureka!
This Edureka "OpenStack Training" tutorial will help you understand all the basics of OpenStack. We have demonstrated the OpenStack Deployment at PayPal using Cinder which will familiarize you with the Real-life applications of OpenStack. Below are the topics covered in this tutorial:
1. What is OpenStack?
2. OpenStack Architecture
3. OpenStack Components
4. PayPal Case Study
5. PayPal OpenStack System
6. EBay Implementation Model
7. Cinder Deployment at PayPal
Building a Reactive System with Akka - Workshop @ O'Reilly SAConf NYCKonrad Malawski
Intense 3 hour workshop covering Akka Actors, Cluster, Streams, HTTP and more. Including very advanced patterns.
Presented with Henrik Engstrom at O'Reilly Software Architecture Conference in New York City in 2017
Akka and Kubernetes, the beginning of a beautiful relationshipHugh McKee
One of the best features of Akka is Akka Cluster. Akka cluster allows for building distributed applications, where one application or service spans multiple nodes. From its initial release in 2013, Akka Cluster needed a node management system to manage the Akka nodes and to provide a resilient and elastic platform. With Kubernetes Akka finally has the node management system that is has been waiting for. Akka Cluster has been designed to gracefully handle nodes leaving and joining a running cluster while continuing to run. Kubernetes adds and removes nodes as needed to increase capacity or to recover from failures. In effect, there is a perfect symbiosis between Akka Cluster and Kubernetes. In this talk, we will look at and demonstrate how Akka Java Cluster and Kubernetes work together and how together they form a beautiful relationship.
Similar to [Japanese] How Reactive Streams and Akka Streams change the JVM Ecosystem @ Reactive Shinjuku (20)
Builder.ai Founder Sachin Dev Duggal's Strategic Approach to Create an Innova...Ramesh Iyer
In today's fast-changing business world, Companies that adapt and embrace new ideas often need help to keep up with the competition. However, fostering a culture of innovation takes much work. It takes vision, leadership and willingness to take risks in the right proportion. Sachin Dev Duggal, co-founder of Builder.ai, has perfected the art of this balance, creating a company culture where creativity and growth are nurtured at each stage.
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
Accelerate your Kubernetes clusters with Varnish CachingThijs Feryn
A presentation about the usage and availability of Varnish on Kubernetes. This talk explores the capabilities of Varnish caching and shows how to use the Varnish Helm chart to deploy it to Kubernetes.
This presentation was delivered at K8SUG Singapore. See https://feryn.eu/presentations/accelerate-your-kubernetes-clusters-with-varnish-caching-k8sug-singapore-28-2024 for more details.
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
Essentials of Automations: Optimizing FME Workflows with ParametersSafe Software
Are you looking to streamline your workflows and boost your projects’ efficiency? Do you find yourself searching for ways to add flexibility and control over your FME workflows? If so, you’re in the right place.
Join us for an insightful dive into the world of FME parameters, a critical element in optimizing workflow efficiency. This webinar marks the beginning of our three-part “Essentials of Automation” series. This first webinar is designed to equip you with the knowledge and skills to utilize parameters effectively: enhancing the flexibility, maintainability, and user control of your FME projects.
Here’s what you’ll gain:
- Essentials of FME Parameters: Understand the pivotal role of parameters, including Reader/Writer, Transformer, User, and FME Flow categories. Discover how they are the key to unlocking automation and optimization within your workflows.
- Practical Applications in FME Form: Delve into key user parameter types including choice, connections, and file URLs. Allow users to control how a workflow runs, making your workflows more reusable. Learn to import values and deliver the best user experience for your workflows while enhancing accuracy.
- Optimization Strategies in FME Flow: Explore the creation and strategic deployment of parameters in FME Flow, including the use of deployment and geometry parameters, to maximize workflow efficiency.
- Pro Tips for Success: Gain insights on parameterizing connections and leveraging new features like Conditional Visibility for clarity and simplicity.
We’ll wrap up with a glimpse into future webinars, followed by a Q&A session to address your specific questions surrounding this topic.
Don’t miss this opportunity to elevate your FME expertise and drive your projects to new heights of efficiency.
Connector Corner: Automate dynamic content and events by pushing a buttonDianaGray10
Here is something new! In our next Connector Corner webinar, we will demonstrate how you can use a single workflow to:
Create a campaign using Mailchimp with merge tags/fields
Send an interactive Slack channel message (using buttons)
Have the message received by managers and peers along with a test email for review
But there’s more:
In a second workflow supporting the same use case, you’ll see:
Your campaign sent to target colleagues for approval
If the “Approve” button is clicked, a Jira/Zendesk ticket is created for the marketing design team
But—if the “Reject” button is pushed, colleagues will be alerted via Slack message
Join us to learn more about this new, human-in-the-loop capability, brought to you by Integration Service connectors.
And...
Speakers:
Akshay Agnihotri, Product Manager
Charlie Greenberg, Host
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
Slack (or Teams) Automation for Bonterra Impact Management (fka Social Soluti...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on the notifications, alerts, and approval requests using Slack for Bonterra Impact Management. The solutions covered in this webinar can also be deployed for Microsoft Teams.
Interested in deploying notification automations for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
Dev Dives: Train smarter, not harder – active learning and UiPath LLMs for do...UiPathCommunity
💥 Speed, accuracy, and scaling – discover the superpowers of GenAI in action with UiPath Document Understanding and Communications Mining™:
See how to accelerate model training and optimize model performance with active learning
Learn about the latest enhancements to out-of-the-box document processing – with little to no training required
Get an exclusive demo of the new family of UiPath LLMs – GenAI models specialized for processing different types of documents and messages
This is a hands-on session specifically designed for automation developers and AI enthusiasts seeking to enhance their knowledge in leveraging the latest intelligent document processing capabilities offered by UiPath.
Speakers:
👨🏫 Andras Palfi, Senior Product Manager, UiPath
👩🏫 Lenka Dulovicova, Product Program Manager, UiPath
8. Reactive Streams - story: 2013’s impls
~2013:
Reactive Programming
becoming widely adopted on JVM.
- Play introduced “Iteratees”
- Akka (2009) had Akka-IO (TCP etc.)
- Ben starts work on RxJava
http://blogs.msdn.com/b/rxteam/archive/2009/11/17/announcing-reactive-extensions-rx-for-net-silverlight.aspx
http://infoscience.epfl.ch/record/176887/files/DeprecatingObservers2012.pdf - Ingo Maier, Martin Odersky
https://github.com/ReactiveX/RxJava/graphs/contributors
https://github.com/reactor/reactor/graphs/contributors
https://medium.com/@viktorklang/reactive-streams-1-0-0-interview-faaca2c00bec#.69st3rndy
Teams discuss need for back-pressure
in simple user API.
Play’s Iteratee / Akka’s NACK in IO.
}
2013年には Reactive Programming が JVM 上で広く採用されるようになりました。
Play,Akkaのチームは簡潔なユーザAPIによる背圧制御の必要性を議論していました。
9. Reactive Streams - story: 2013’s impls
Play Iteratees – pull back-pressure, difficult API
http://blogs.msdn.com/b/rxteam/archive/2009/11/17/announcing-reactive-extensions-rx-for-net-silverlight.aspx
http://infoscience.epfl.ch/record/176887/files/DeprecatingObservers2012.pdf - Ingo Maier, Martin Odersky
https://github.com/ReactiveX/RxJava/graphs/contributors
https://github.com/reactor/reactor/graphs/contributors
https://medium.com/@viktorklang/reactive-streams-1-0-0-interview-faaca2c00bec#.69st3rndy
Akka-IO – NACK back-pressure; low-level IO (Bytes); messaging API
RxJava – no back-pressure, nice API
Play の Iteratee は pull 型の背圧制御でAPIが難しく、Akka-IO は NACK 背圧制御で
低レベルI/OとメッセージングAPI, RxJava は背圧制御はないが優れたAPIでした。
10. Reactive Streams - Play’s Iteratees
def fold[B](
done: (A, Input[E]) => Promise[B],
cont: (Input[E] => Iteratee[E, A]) => Promise[B],
error: (String, Input[E]) => Promise[B]
): Promise[B]
// an iteratee that consumes chunkes of String and produces an Int
Iteratee[String,Int]
https://www.playframework.com/documentation/2.0/Iteratees
Feb 2013
Iteratees solved the back-pressure problem,
but were hard to use.
Iteratee & Enumeratee – Haskell inspired.
Play / Akka teams looking for common concept.
2013年2月, Play の Iteratee は背圧制御の問題を解決しましたが使いづらく、
Play/Akkaのチームは共通のコンセプトを探していました。
11. Reactive Streams - expert group founded
October 2013
Roland Kuhn (Akka) and Erik Meijer (Rx .NET) meet in Lausanne,
while recording “Principles of Reactive Programming” Coursera Course.
Viktor Klang (Akka), Erik Meijer, Ben Christensen (RxJava)
and Marius Eriksen (Twitter) meet at Twitter HQ.
The term “reactive non-blocking asynchronous back-pressure” gets coined.
2013年10月, Roland Kuhn(Akka)、Erik Meijer (Rx .NET) らにより"リアクティブ
ノンブロッキング非同期背圧制御"という言葉が造り出されました。
12. Reactive Streams - expert group founded
October 2013
Roland Kuhn (Akka) and Erik Meijer (Rx .NET) meet in Lausanne,
while recording “Principles of Reactive Programming” Coursera Course.
Viktor Klang (Akka), Erik Meijer, Ben Christensen (RxJava)
and Marius Eriksen (Twitter) meet at Twitter HQ.
The term “reactive non-blocking asynchronous back-pressure” gets coined.
Goals:
- asynchronous
- never block (waste)
- safe (back-threads pressured)
- purely local abstraction
- allow synchronous impls.
Also, for our examples today:
- compatible with TCP
非同期、ブロックしない、安全、純粋にローカルのような抽象化、同期の実装も許すこ
とをゴールとしました。また、今日の前例にならいTCPとの互換性も目指しました。
13. Reactive Streams - expert group founded
October 2013
Roland Kuhn (Akka) and Erik Meijer (Rx .NET) meet in Lausanne,
while recording “Principles of Reactive Programming” Coursera Course.
Viktor Klang (Akka), Erik Meijer, Ben Christensen (RxJava)
and Marius Eriksen (Twitter) meet at Twitter HQ.
The term “reactive non-blocking asynchronous back-pressure” gets coined.
December 2013
Stephane Maldini & Jon Brisbin (Pivotal Reactor) contacted by Viktor.
Sephane Maldini と Jon Brisbin (Pival Reactor) がViktor にコン
タクトしました。
14. Reactive Streams - expert group founded
October 2013
Roland Kuhn (Akka) and Erik Meijer (Rx .NET) meet in Lausanne,
while recording “Principles of Reactive Programming” Coursera Course.
Viktor Klang (Akka), Erik Meijer, Ben Christensen (RxJava)
and Marius Eriksen (Twitter) meet at Twitter HQ.
The term “reactive non-blocking asynchronous back-pressure” gets coined.
December 2013
Stephane Maldini & Jon Brisbin (Pivotal Reactor) contacted by Viktor.
Soon after, the “Reactive Streams” expert group is formed.
Also joining the efforts: Doug Lea (Oracle), EndreVarga (Akka), Johannes Rudolph &
Mathias Doenitz (Spray), and many others, including myself join the effort soon after.
まもなく "Reactive Streams" エキスパートグループが創設されました。
Doug Lea(Oracle)や、私自身も含めた多くの人々が参画しました。
15. October 2013
Roland Kuhn (Akka) and Erik Meijer (Rx .NET) meet in Lausanne,
while recording “Principles of Reactive Programming” Coursera Course.
Viktor Klang (Akka), Erik Meijer, Ben Christensen (RxJava)
and Marius Eriksen (Twitter) meet at Twitter HQ.
The term “reactive non-blocking asynchronous back-pressure” gets coined.
December 2013
Stephane Maldini & Jon Brisbin (Pivotal Reactor) contacted by Viktor.
Soon after, the “Reactive Streams” expert group is formed.
Also joining the efforts: Doug Lea (Oracle), EndreVarga (Akka), Johannes Rudolph &
Mathias Doenitz (Spray), and many others, including myself join the effort soon after.
Reactive Streams - expert group founded
I ended up implementing much of the TCK.
Please use it, let me know if it needs improvements :-)
私はTCK(Technology Compatibility Kit) の大部分の実装を終えました。
ぜひ使ってみて、もし改良が必要なら教えてください :-)
16. Reactive Streams - story: 2013’s impls
2014–2015:
Reactive Streams Spec & TCK
development, and implementations.
1.0 released on April 28th 2015,
with 5+ accompanying implementations.
2015
Proposed to be included with JDK9 by Doug Lea
via JEP-266 “More Concurrency Updates”
http://hg.openjdk.java.net/jdk9/jdk9/jdk/file/6e50b992bef4/src/java.base/share/classes/java/util/concurrent/Flow.java
2014-2015に Reactive Streams の仕様とTCKが開発・実装され、
2015年4月28日に 1.0 が5つ以上の実装と共にリリースされました。
17. 2014–2015:
Reactive Streams Spec & TCK
development, and implementations.
1.0 released on April 28th 2015,
with 5+ accompanying implementations.
2015
Proposed to be included with JDK9 by Doug Lea
via JEP-266 “More Concurrency Updates”
http://hg.openjdk.java.net/jdk9/jdk9/jdk/file/6e50b992bef4/src/java.base/share/classes/java/util/concurrent/Flow.java
Reactive Streams - story: 2013’s impls
Doug Lea により、これを JDK9 に含めることが
JEP-266 "More Concurrency Updates" を通じて提案されました。
18. in a few words:
• Toolkit for building scalable distributed / concurrent apps.
• High Performance Actor Model implementation
• “share nothing” – messaging instead of sharing state
• millions of msgs, per actor, per second
• Supervision trees – built-in and mandatory
• Clustering and Http built-in
A
B
BarFoo
C
B
E
A
D
C
/Foo
/Foo/A
/Foo/A/B
/Foo/A/D
Guardian System Actor
Name resolution—like a file-system
akka はスケーラブルな分散/並行アプリを構築するためのツールキットです。高性能な
Actorモデルの実装で、Supervisionツリー、クラスタリング/Httpを組込んでいます。
31. What if the buffer overflows?
Push + NACK model
もしバッファがオーバーフローしたら何が起こるでしょう?
32. Use bounded buffer,
drop messages + require re-sending
Push + NACK model
大きさが限られたバッファを使い、
メッセージを廃棄し、再送を要求します。
33. Kernel does this!
Routers do this!
(TCP)
Use bounded buffer,
drop messages + require re-sending
Push + NACK model
カーネルがこれを行います! ルーターがこれを行います! (TCP)
34. Increase buffer size…
Well, while you have memory available!
Push + NACK model
バッファサイズを増やしてみましょう...
そう、使用できるメモリがある限りは!
38. Telling the Publisher to slow down / stop sending…
NACKing
Publisher にスローダウンするか、送信を止めるよう知らせます...
39. NACK did not make it in time,
because M was in-flight!
NACKing
NACK は間に合いませんでした、
メッセージが飛んできている最中だったからです!
40. What if…
We don’t need to back-pressure, because:
speed(publisher) < speed(subscriber)
We need low-overhead for “happy case”
もしも、publisher のスピード < subscrber のスピードであれば、
背圧制御は必要ありません。
43. Just push – not safe when Slow Subscriber
Just pull – too slow when Fast Subscriber
Reactive Streams: “dynamic push/pull”
push だけだと、Subscriberが低速な時には、安全ではありません。
pull だけだと、Subscriberが高速な時には、遅すぎます。
44. Solution:
Dynamic adjustment
Just push – not safe when Slow Subscriber
Just pull – too slow when Fast Subscriber
Reactive Streams: “dynamic push/pull”
解決策は、動的な調整です。
45. Slow Subscriber sees it’s buffer can take 3 elements.
Publisher will never blow up its buffer.
Reactive Streams: “dynamic push/pull”
低速なSubscriberはバッファに3要素入れられることがわかります。
Publsherはバッファをあふれさせることは決してありません。
46. Fast Publisher will send at-most 3 elements.
This is pull-based-backpressure.
Reactive Streams: “dynamic push/pull”
高速なPublisherは、高々3つの要素を送ります。
これがpullベースの背圧制御です。
47. Fast Subscriber can issue more Request(n),
before more data arrives!
Reactive Streams: “dynamic push/pull”
高速なSubscriberは、データが到着する前に、
より多くのリクエストを発行することができます!
48. Fast Subscriber can issue more Request(n),
before more data arrives.
Publisher can accumulate demand.
Reactive Streams: “dynamic push/pull”
高速なSubscriberは、需要を蓄積することができます。
49. Publisher accumulates total demand per subscriber.
Reactive Streams: accumulate demand
Publisherはsubscriberごとに需要の合計を蓄積します。
50. Total demand of elements is safe to publish.
Subscriber’s buffer will not overflow.
Reactive Streams: accumulate demand
需要の合計分の要素をpublishしても安全です。
Subscriberのバッファはオーバーフローしないでしょう。
51. http://reactive-streams.org
We want to make different implementations
co-operate with each other.
Reactive Streams: Inter Op
私たちは、異なる実装がお互いに協力できるようにしたいのです。
52. http://reactive-streams.org
We want to make different implementations
co-operate with each other.
Reactive Streams: Inter Op
私たちは、異なる実装がお互いに協力できるようにしたいのです。
53. RS is NOT a “daily use”, “end-user” API.
It’s an SPI - Service Provider Interface.
Reactive Streams: Inter-Op
https://en.wikipedia.org/wiki/Service_provider_interface
Service Provider Interface (SPI) is an API intended to be
implemented or extended by a third party.
RS は "毎日使用する", "エンドユーザ向けの" API ではなく、サードパーティにより
実装される、または拡張される SPI (Service Provider Interface) です。
54. EmbeddedApp.fromHandler(new Handler {
override def handle(ctx: Context): Unit = {
// RxJava Observable
val intObs = Observable.from((1 to 10).asJava)
// Reactive Streams Publisher
val intPub = RxReactiveStreams.toPublisher(intObs)
// Akka Streams Source
val stringSource = Source(intPub).map(_.toString)
// Reactive Streams Publisher
val stringPub = stringSource.runWith(Sink.fanoutPublisher(1, 1))
// Reactor Stream
val linesStream = Streams.create(stringPub).map[String](
new reactor.function.Function[String, String] {
override def apply(in: String) = in + "n"
})
// and now render the HTTP response (RatPack)
ctx.render(ResponseChunks.stringChunks(linesStream))
}
}).test(new Consumer[TestHttpClient] {
Reactive Streams: Inter-Op
https://en.wikipedia.org/wiki/Service_provider_interface
55. EmbeddedApp.fromHandler(new Handler {
override def handle(ctx: Context): Unit = {
// RxJava Observable
val intObs = Observable.from((1 to 10).asJava)
// Reactive Streams Publisher
val intPub = RxReactiveStreams.toPublisher(intObs)
// Akka Streams Source
val stringSource = Source(intPub).map(_.toString)
// Reactive Streams Publisher
val stringPub = stringSource.runWith(Sink.fanoutPublisher(1, 1))
// Reactor Stream
val linesStream = Streams.create(stringPub).map[String](
new reactor.function.Function[String, String] {
override def apply(in: String) = in + "n"
})
// and now render the HTTP response (RatPack)
ctx.render(ResponseChunks.stringChunks(linesStream))
}
}).test(new Consumer[TestHttpClient] {
Reactive Streams: Inter-Op
https://en.wikipedia.org/wiki/Service_provider_interface
61. Akka HTTP
Joint effort of Spray and Akka teams.
Complete HTTP Server/Client implementation.
Soon prod ready, developed ~1.5 years.
Learns from Spray’s 3-4 years history.
Since the beginning with
streaming as first class citizen.
Akka HTTP は、SprayとAkkaチームが協力して開発した、完全なHTTPサーバ/クライアント
実装です。1年半かけて開発されており、間もなく業務に耐えうるレベルになるでしょう。
62. It’s turtles buffers all the way down!
親亀の上に子亀、子亀の上に孫亀がのるかのように、バッファの
次にバッファ、その次にまたバッファ... と無数につらなります!
75. Pipelining
// Takes a scoop of batter and creates a pancake with one side cooked
val fryingPan1: Flow[ScoopOfBatter, HalfCookedPancake, Unit] =
Flow[ScoopOfBatter].map { batter => HalfCookedPancake() }
// Finishes a half-cooked pancake
val fryingPan2: Flow[HalfCookedPancake, Pancake, Unit] =
Flow[HalfCookedPancake].map { halfCooked => Pancake() }
// With the two frying pans we can fully cook pancakes
val pancakeChef: Flow[ScoopOfBatter, Pancake, Unit] =
Flow[ScoopOfBatter].via(fryingPan1).via(fryingPan2)
82. 10/26/2015 spray-can: add websockets support (client & server) · Issue #134 · spray/spray
Pull requests Issues GistThis repository Search
2,092 496197Watch Star Forkspray / spray
and others
Labels
Milestone
akka-http
Assignee
No one assigned
111 participants
spray-can: add websockets support (client & server) #134
Closed sirthias opened this issue on Sep 4, 2012 · 129 comments
New issue
Feature
Notifications
You’re not receiving
notifications from this
thread.
Subscribe
Ownersirthias commented on Sep 4, 2012
No description provided.
analytically commented on Oct 23, 2012
+1
tommcp commented on Nov 1, 2012
+1
t3hnar commented on Nov 10, 2012
+1
alexbool commented on Nov 10, 2012
+1
olger commented on Nov 16, 2012
+1
pjean commented on Nov 29, 2012
+1
edgurgel commented on Nov 29, 2012
+1
zerni commented on Dec 10, 2012
+1
Bathtor commented on Dec 10, 2012
+1
WebSockets
A.K.A.
“Spray’s single most upvoted
feature request ever”
98 * “+1”
WebSockets は、"Spray のこれまでの機能リクエストのなかで、
単独で最も票を集めた機能" としても知られています。
83. Spray’s most requested feature ever:
WebSockets
path("ws") {
val handler: Flow[Message, Message] = ???
handleWebsocketMessages(handler)
}
84. Spray’s most requested feature ever:
WebSockets
path("ws") {
val handler: Flow[Message, Message] = ???
handleWebsocketMessages(handler)
}
85. Spray’s most requested feature ever:
WebSockets
path("ws") {
val handler = Flow.fromSinkAndSource(
Sink.ignore,
Source.single(TextMessage("Hello World!”)))
handleWebsocketMessages(handler)
}
88. JEP-266 – soon…!
public final class Flow {
private Flow() {} // uninstantiable
@FunctionalInterface
public static interface Publisher<T> {
public void subscribe(Subscriber<? super T> subscriber);
}
public static interface Subscriber<T> {
public void onSubscribe(Subscription subscription);
public void onNext(T item);
public void onError(Throwable throwable);
public void onComplete();
}
public static interface Subscription {
public void request(long n);
public void cancel();
}
public static interface Processor<T,R> extends Subscriber<T>, Publisher<R> {
}
}
JEP-266 がまもなく...!
90. Roadmap Update: Streams & HTTP
Already pretty mature and complete implementation.
WebSockets!
Play 2.5 (2.5+) uses Akka Streams.
(Scala || Java) DSL == same power.
Last phases of polishing up APIs and features.
2.4.2 release in coming weeks.
Akka 2.4 requires JDK8.
(that’s about time to do so!)
StreamsとHTTPの最新ロードマップ
既に十分成熟しており、実装が完了しました。
91. • Reactive Platform
• Remoting / Cluster: Docker networking support
• Cluster: Split Brain Resolver (beta)
• Akka Persistence: Cross-Scala-version snapshot deserializer
• Java 6: Extended LTS
• Akka 2.4.2 (released this month, binary compatible with 2.3)
• Akka Streams becomes non experimental in 2.4.2!
• Cluster Tools promoted to stable!
• Persistence promoted to stable!
• Persistence Queries (experimental)
• Akka Typed (experimental)
• Distributed Data (experimental)
Roadmap Update: Akka
Akka の最新ロードマップ
92. Links
• The projects:
• akka.io
• typesafe.com/products/typesafe-reactive-platform
• reactive-streams.org
• Viktor Klang’s interview with all RS founding members
• Akka HTTP in depth with Mathias and Johannes @ Scala.World
• Akka User - mailing list:
• https://groups.google.com/group/akka-user
• Community chat:
• http://gitter.im/akka/akka
93. Thanks!
onNext(Q/A)
(Now’s the time to ask things!)
ktoso @ typesafe.com
twitter: ktosopl
github: ktoso
team blog: letitcrash.com
home: akka.io