Vert.x is an asynchronous event-driven framework that addresses some of the shortcomings of Node.js. It uses a polyglot approach that allows programming in multiple languages instead of just JavaScript. It leverages the multi-threaded JVM to allow both vertical and horizontal scaling. An event bus provides a distributed communication system across processes and into the browser. Worker verticles allow blocking operations to run off the main event loop threads. Shared immutable data structures enable safe sharing of state across instances.
Introducción a la programación reactiva con Vert.x. Esta presentación la utilicé en una charla para desarrolladores https://www.meetup.com/es-ES/Software-Crafters-Alicante/events/264365511/
Best practices for choosing identity solutions for applications + workloads -...Amazon Web Services
Identity requirements for consumer-facing applications differ significantly from those for workforce applications and cloud resources. Learn the best practices for choosing the right identity platform on AWS for your consumer-facing applications and for centrally managing access to all your business applications and AWS resources. Come learn about the proper use cases for implementing single sign-on (SSO) and Amazon Cognito, security best practices, and configuration guidance.
An application path to production does not end with a deployment, even if you are using Kubernetes (K8s) as your application deployment platform. Reliable BCDR (backup and disaster recovery) plan and framework is a must for any production-ready system.
This presentation accompanies meetups and webinars in which Oleg Chunikhin, CTO at Kublr, shows how Velero BCDR framework works and demonstrates how it can be used to backup and recover realistic applications running on Kubernetes in different clouds and environments.
What is covered:
- general notions of Kubernetes applications BCDR
- Velero BCDR framework
- demo Velero BCDR for stateful applications running on AWS and Azure clouds
- demo Velero BCDR using Strimzi / Kafka cluster and ArgoCD CI/CD manager as example application
GitOps & the deployment branching models
DevOps D-day Marseille 2021:
GitOps is starting to be a well-known approach to delivering your software, but it does not provide a framework for representing different target environments or a solution for propagating changes from stage to stage. So what are the solutions to describe the Dev, QA or Production environment and especially how to propagate changes from one environment to another in an efficient, automated and secure way in a GitOps framework?
Introducción a la programación reactiva con Vert.x. Esta presentación la utilicé en una charla para desarrolladores https://www.meetup.com/es-ES/Software-Crafters-Alicante/events/264365511/
Best practices for choosing identity solutions for applications + workloads -...Amazon Web Services
Identity requirements for consumer-facing applications differ significantly from those for workforce applications and cloud resources. Learn the best practices for choosing the right identity platform on AWS for your consumer-facing applications and for centrally managing access to all your business applications and AWS resources. Come learn about the proper use cases for implementing single sign-on (SSO) and Amazon Cognito, security best practices, and configuration guidance.
An application path to production does not end with a deployment, even if you are using Kubernetes (K8s) as your application deployment platform. Reliable BCDR (backup and disaster recovery) plan and framework is a must for any production-ready system.
This presentation accompanies meetups and webinars in which Oleg Chunikhin, CTO at Kublr, shows how Velero BCDR framework works and demonstrates how it can be used to backup and recover realistic applications running on Kubernetes in different clouds and environments.
What is covered:
- general notions of Kubernetes applications BCDR
- Velero BCDR framework
- demo Velero BCDR for stateful applications running on AWS and Azure clouds
- demo Velero BCDR using Strimzi / Kafka cluster and ArgoCD CI/CD manager as example application
GitOps & the deployment branching models
DevOps D-day Marseille 2021:
GitOps is starting to be a well-known approach to delivering your software, but it does not provide a framework for representing different target environments or a solution for propagating changes from stage to stage. So what are the solutions to describe the Dev, QA or Production environment and especially how to propagate changes from one environment to another in an efficient, automated and secure way in a GitOps framework?
Overview of kubernetes and its use as a DevOps cluster management framework.
Problems with deployment via kube-up.sh and improving kubernetes on AWS via custom cloud formation template.
As serverless architectures become more popular, AWS customers need a framework of patterns to help them deploy their workloads without managing servers or operating systems.
What Is Docker? | What Is Docker And How It Works? | Docker Tutorial For Begi...Simplilearn
This presentation on Docker will help you understand DevOps tools, why Docker is needed, Docker vs Virtual Machine, what is Docker, how does a Docker work and components of Docker. Docker is a tool which is used to automate the deployment of the application in lightweight containers so that applications can work efficiently in different environments. A container is a software package that consists of all the dependencies required to run an application. Until now we have been running applications on virtual machines. Every virtual machine used to be the base of our application but now with the advent of Docker and containerization technologies, each application is run in a container like logical space. Now, let us get started and learn what exactly is Docker.
Below topics are explained in this Docker presentation:
1. DevOps and its tools
2. What is Docker?
3. How does Docker work?
4. What are the components of Docker?
Simplilearn's DevOps Certification Training Course will prepare you for a career in DevOps, the fast-growing field that bridges the gap between software developers and operations. You’ll become an expert in the principles of continuous development and deployment, automation of configuration management, inter-team collaboration and IT service agility, using modern DevOps tools such as Git, Docker, Jenkins, Puppet and Nagios. DevOps jobs are highly paid and in great demand, so start on your path today.
Why learn DevOps?
Simplilearn’s DevOps training course is designed to help you become a DevOps practitioner and apply the latest in DevOps methodology to automate your software development lifecycle right out of the class. You will master configuration management; continuous integration deployment, delivery and monitoring using DevOps tools such as Git, Docker, Jenkins, Puppet and Nagios in a practical, hands-on and interactive approach. The DevOps training course focuses heavily on the use of Docker containers, a technology that is revolutionizing the way apps are deployed in the cloud today and is a critical skillset to master in the cloud age.
Who should take this course?
DevOps career opportunities are thriving worldwide. DevOps was featured as one of the 11 best jobs in America for 2017, according to CBS News, and data from Payscale.com shows that DevOps Managers earn as much as $122,234 per year, with DevOps engineers making as much as $151,461. DevOps jobs are the third-highest tech role ranked by employer demand on Indeed.com but have the second-highest talent deficit.
1. This DevOps training course will be of benefit for the following professional roles:
2. Software Developers
3. Technical Project Managers
4. Architects
5. Operations Support
6. Deployment engineers
7. IT managers
8. Development managers
Learn more at: https://www.simplilearn.com/
Kubernetes와 Kubernetes on OpenStack 환경의 비교와 그 구축방법에 대해서 알아봅니다.
1. 클라우드 동향
2. Kubernetes vs Kubernetes on OpenStack
3. Kubernetes on OpenStack 구축 방벙
4. Kubernetes on OpenStack 운영 방법
D. Andreadis, Red Hat: Concepts and technical overview of QuarkusUni Systems S.M.S.A.
Dimitris Andreadis, Director of Engineering and Manager of the Quarkus Team at Red Hat, discusses the History, Concepts and Technical Overview of Quarkus framework. The webinar was delivered on June 25, 2020
Quarkus offers a great development experience. In this session, I’ll introduce you to the power of Quarkus Live Coding and tools that are useful to developers for debugging, deploying, and testing Quarkus applications.
YouTube Link: https://youtu.be/xuH81XGWeGQ
** Microservices Architecture Training: https://www.edureka.co/microservices-architecture-training**
This Edureka's PPT on Microservices Design Patterns talks about the top design patterns you can use to build applications.
Follow us to never miss an update in the future.
YouTube: https://www.youtube.com/user/edurekaIN
Instagram: https://www.instagram.com/edureka_learning/
Facebook: https://www.facebook.com/edurekaIN/
Twitter: https://twitter.com/edurekain
LinkedIn: https://www.linkedin.com/company/edureka
Castbox: https://castbox.fm/networks/505?country=in
Vert.x Event Driven Non Blocking Reactive ToolkitBrian S. Paskin
A beginning guide to Vert.x, the main elements, and the main features, like Event Loop, Verticles, and Event Bus. Includes a link to a GitHub repository with samples.
www.opitz-consulting.com
How do Angular and React compare? Can we compare them at all? Actually, it's like comparing apples to oranges, but even so, we have to compare them. As it turns out, both frameworks are a nice example of co-evolution. They aren't as different as they used to be a few years ago. After showing the key concepts of both frameworks, our experts Dr. Marius Hofmeister and Stephan Rauh presented a small list of criteria helping to decide when to use which at iJS Conference in Munich on 25/10/17.
Overview of kubernetes and its use as a DevOps cluster management framework.
Problems with deployment via kube-up.sh and improving kubernetes on AWS via custom cloud formation template.
As serverless architectures become more popular, AWS customers need a framework of patterns to help them deploy their workloads without managing servers or operating systems.
What Is Docker? | What Is Docker And How It Works? | Docker Tutorial For Begi...Simplilearn
This presentation on Docker will help you understand DevOps tools, why Docker is needed, Docker vs Virtual Machine, what is Docker, how does a Docker work and components of Docker. Docker is a tool which is used to automate the deployment of the application in lightweight containers so that applications can work efficiently in different environments. A container is a software package that consists of all the dependencies required to run an application. Until now we have been running applications on virtual machines. Every virtual machine used to be the base of our application but now with the advent of Docker and containerization technologies, each application is run in a container like logical space. Now, let us get started and learn what exactly is Docker.
Below topics are explained in this Docker presentation:
1. DevOps and its tools
2. What is Docker?
3. How does Docker work?
4. What are the components of Docker?
Simplilearn's DevOps Certification Training Course will prepare you for a career in DevOps, the fast-growing field that bridges the gap between software developers and operations. You’ll become an expert in the principles of continuous development and deployment, automation of configuration management, inter-team collaboration and IT service agility, using modern DevOps tools such as Git, Docker, Jenkins, Puppet and Nagios. DevOps jobs are highly paid and in great demand, so start on your path today.
Why learn DevOps?
Simplilearn’s DevOps training course is designed to help you become a DevOps practitioner and apply the latest in DevOps methodology to automate your software development lifecycle right out of the class. You will master configuration management; continuous integration deployment, delivery and monitoring using DevOps tools such as Git, Docker, Jenkins, Puppet and Nagios in a practical, hands-on and interactive approach. The DevOps training course focuses heavily on the use of Docker containers, a technology that is revolutionizing the way apps are deployed in the cloud today and is a critical skillset to master in the cloud age.
Who should take this course?
DevOps career opportunities are thriving worldwide. DevOps was featured as one of the 11 best jobs in America for 2017, according to CBS News, and data from Payscale.com shows that DevOps Managers earn as much as $122,234 per year, with DevOps engineers making as much as $151,461. DevOps jobs are the third-highest tech role ranked by employer demand on Indeed.com but have the second-highest talent deficit.
1. This DevOps training course will be of benefit for the following professional roles:
2. Software Developers
3. Technical Project Managers
4. Architects
5. Operations Support
6. Deployment engineers
7. IT managers
8. Development managers
Learn more at: https://www.simplilearn.com/
Kubernetes와 Kubernetes on OpenStack 환경의 비교와 그 구축방법에 대해서 알아봅니다.
1. 클라우드 동향
2. Kubernetes vs Kubernetes on OpenStack
3. Kubernetes on OpenStack 구축 방벙
4. Kubernetes on OpenStack 운영 방법
D. Andreadis, Red Hat: Concepts and technical overview of QuarkusUni Systems S.M.S.A.
Dimitris Andreadis, Director of Engineering and Manager of the Quarkus Team at Red Hat, discusses the History, Concepts and Technical Overview of Quarkus framework. The webinar was delivered on June 25, 2020
Quarkus offers a great development experience. In this session, I’ll introduce you to the power of Quarkus Live Coding and tools that are useful to developers for debugging, deploying, and testing Quarkus applications.
YouTube Link: https://youtu.be/xuH81XGWeGQ
** Microservices Architecture Training: https://www.edureka.co/microservices-architecture-training**
This Edureka's PPT on Microservices Design Patterns talks about the top design patterns you can use to build applications.
Follow us to never miss an update in the future.
YouTube: https://www.youtube.com/user/edurekaIN
Instagram: https://www.instagram.com/edureka_learning/
Facebook: https://www.facebook.com/edurekaIN/
Twitter: https://twitter.com/edurekain
LinkedIn: https://www.linkedin.com/company/edureka
Castbox: https://castbox.fm/networks/505?country=in
Vert.x Event Driven Non Blocking Reactive ToolkitBrian S. Paskin
A beginning guide to Vert.x, the main elements, and the main features, like Event Loop, Verticles, and Event Bus. Includes a link to a GitHub repository with samples.
www.opitz-consulting.com
How do Angular and React compare? Can we compare them at all? Actually, it's like comparing apples to oranges, but even so, we have to compare them. As it turns out, both frameworks are a nice example of co-evolution. They aren't as different as they used to be a few years ago. After showing the key concepts of both frameworks, our experts Dr. Marius Hofmeister and Stephan Rauh presented a small list of criteria helping to decide when to use which at iJS Conference in Munich on 25/10/17.
Vert.x – The problem of real-time data bindingAlex Derkach
As the popularity of any event-driven application increases, the number of concurrent connections may increase. Applications that employ thread-per-client architecture, frustrate scalability by exhausting a server’s memory with excessive allocations and by exhausting a server’s CPU with excessive context-switching. One of obvious solutions, is exorcising blocking operations from such applications. Vert.x is event driven and non blocking toolkit, which may help you to achive this goal. In this talk, we are going to cover it’s core features and develop a primitive application using WebSockets, RxJava and Vert.x.
Building microservices with vert.x 3.0Agraj Mangal
Building Microservices is considered fad these days & with Vert.x 3.0 toolkit, it has never been simpler to build a Microservice in your favorite language
Vert.X: Microservices Were Never So Easy (Clement Escoffier)Red Hat Developers
Vert.x 3 is a framework to create reactive applications on the Java Virtual Machine. Vert.x 3 takes the JVM to new levels of performance yet having a small API. It lets you build scalable microservice-based applications transparently distributed and packaged as a single jar file. Due to this simplicity, deploying and managing Vert.x applications on OpenShift 3 is a breeze, upload your jar and Vert.x internal cluster manager will connect all your pods in single distributed network. Several examples are shown during the talk and demonstrate how Vert.x can simplify DevOps daily job when working together with OpenShift 3.
Vert.x using Groovy - Simplifying non-blocking codesascha_klein
The possibilities and advantages of non-blocking IO are great.
But as you have to hassle with callbacks all over the place you have to think differently.
Sometimes simple constructs we are used to are getting ugly or really hard to realize.
A little bit of Groovy-magic can help out to simplify life and make your code more look like you are used to.
This session wants to show experiences creating a vert.x-based application and the solutions we used to smooth up our code.
This talk gives an overview of the Postgres community, the Postgres database, and several add-on tools for Postgres. It is intended to provide a guide for someone wanting to do full time Postgres administration.
Development with Vert.x: an event-driven application framework for the JVMDavid Wu
For a long time JVM developers have been sitting out watching web developers write agile and performant applications with frameworks such as node.js. Fortunately this is no longer the case. Vert.x is a powerful, bleeding edge event-driven application framework for the JVM. It features native support for non-blocking I/O and concurrency. It has a distributed event bus that that allows real-time communication between client and server. In addition to including out-of-the-box modules for easy development, vert.x has a module system that enables code reuse. To be even more cool, vert.x is polyglot, supporting components written in different languages such as Javascript, Ruby, and Python. In this speech I will give an overview of the vert.x framework and some of the caveats that you should be aware of.
Using Mikko Koppanen's PHP ZMQ extension we will look at how you can easily distribute work to background processes, provide flexible service brokering for your next service oriented architecture, and manage caches efficiently and easily with just PHP and the ZeroMQ libraries. Whether the problem is asynchronous communication, message distribution, process management or just about anything, ZeroMQ can help you build an architecture that is more resilient, more scalable and more flexible, without introducing unnecessary overhead or requiring a heavyweight queue manager node.
Alvaro Videla, Building a Distributed Data Ingestion System with RabbitMQTanya Denisyuk
In this talk I am going to show how to build a system that can ingest data produced at separate geo located areas (think AWS and it’s many regions) and replicate it to a central cluster where it can be further processed and analysed. I will present an example of how to build a system like this one by using RabbitMQ Federation to replicate data across AWS Regions and RabbitMQ support for many protocols to produce/consume data.
To help with scalability I am going to show an interesting way to implement sharded queues with RabbitMQ by using the Consistent Hash Exchange.
Go Reactive: Event-Driven, Scalable, Resilient & Responsive SystemsJonas Bonér
The demands and expectations for applications have changed dramatically in recent years. Applications today are deployed on a wide range of infrastructure; from mobile devices up to thousands of nodes running in the cloud—all powered by multi-core processors. They need to be rich and collaborative, have a real-time feel with millisecond response time and should never stop running. Additionally, modern applications are a mashup of external services that need to be consumed and composed to provide the features at hand.
We are seeing a new type of applications emerging to address these new challenges—these are being called Reactive Applications. In this talk we will discuss four key traits of Reactive; Event-Driven, Scalable, Resilient and Responsive—how they impact application design, how they interact, their supporting technologies and techniques, how to think when designing and building them—all to make it easier for you and your team to Go Reactive.
Spark Summit - Watson Analytics for Social Media: From single tenant Hadoop t...Behar Veliqi
- WHAT IS WATSON ANALYTICS FOR SOCIAL MEDIA
- PREVIOUS ARCHITECTURE ON HADOOP
- THOUGHT PROCESS TOWARDS MULTITENANCY
- NEW ARCHITECTURE ON TOP OF APACHE SPARK
- LESSONS LEARNED
Here is the presentation I did at Trifork GeekNights, January 12+13.
The talk is about my journey into Erlang land, how we need to start thinking about threads and processes in a new way, and some aspects of the work I have done towards implementing Erlang on the JVM platform.
Follow-up discussion either at my blog: http://javalimit.com/ or at http://groups.google.com/group/erjang
Seminar about docker and its containerization capabilities during the "Aggiornamento Agile" event of Club degli Sviluppatori in January 2015, in Bari (Italy)
UPDATED OCTOBER 2015: Unikernels are small, fast, easily deployable, and very secure application stacks. Lacking a traditional operating system layer, they provide a new way of looking at the cloud which goes beyond the methodologies used by Docker and other container technologies.
This is an update of the deck as delivered by Russell Pavlicek. This includes some ground-breaking work done in the Rump Kernel project to bring web servers, database, and scripting language into the world of Unikernels.
Deck result of the Ohio Linuxfest 2015 in Columbus, OH.
All software architectures have to deal with stress. Its simply the way the world works! Stressors come from multiple directions, including changes in the marketplace, business models, and customer demand, as well as infrastructure failures, improper or unexpected inputs, and bugs. As software architects, one of our jobs is to create solutions that meet both business and quality requirements while appropriately handling stress. We typically approach stressors by trying to create solutions that are robust. Robust systems can continue functioning properly in the presence of internal and external challenges, but they also have one or more breaking points. When we pass a robust system's known threshold for a particular type of stress, it will fail. When a system encounters an unknown unknown challenge, it will usually not be robust! Recent years have seen new approaches, including resilient, antifragile, and evolutionary architectures. All of these approaches emphasize the notion of adapting to changing conditions in order to not only survive stress but sometimes to benefit from it. In this presentation, we'll examine the theory and practice behind these architectural approaches.
Cloud Foundry: The Best Place to Run MicroservicesMatt Stine
A magical tour through the Industrial Revolution, Complex Adaptive Systems, and Turtles All the Way Down, with shout outs to Cloud Foundry, BOSH, and Spring Boot.
Lattice: A Cloud-Native Platform for Your Spring ApplicationsMatt Stine
As presented at SpringOne2GX 2015 in Washington, DC.
Lattice is a cloud-native application platform that enables you to run your applications in containers like Docker, on your local machine via Vagrant. Lattice includes features like:
Cluster scheduling
HTTP load balancing
Log aggregation
Health management
Lattice does this by packaging a subset of the components found in the Cloud Foundry elastic runtime. The result is an open, single-tenant environment suitable for rapid application development, similar to Kubernetes and Mesos Applications developed using Lattice should migrate unchanged to full Cloud Foundry deployments.
Lattice can be used by Spring developers to spin up powerful micro-cloud environments on their desktops, and can be useful for developing and testing cloud-native application architectures. Lattice already has deep integration with Spring Cloud and Spring XD, and you’ll have the opportunity to see deep dives into both at this year’s SpringOne 2GX. This session will introduce the basics:
Installing Lattice
Lattice’s Architecture
How Lattice Differs from Cloud Foundry
How to Package and Run Your Spring Apps on Lattice
Microservice architectures have generated quite a bit of hype in recent months, and practitioners across our industry have vigorously debated the definition, purpose, and effectiveness of these architectures.
In this session, Matt Stine will cut through the Microservices hype and examine some very practical considerations:
• Not an End in Themselves: Microservices are really all about helping us achieve continuous delivery
• Systems over Services: Microservices are less about the services themselves and more about the systems we can assemble using them. Boilerplate patterns for configuration, integration, and fault tolerance are keys.
• Operationalized Architecture: Microservices aren’t a free lunch. You have to pay for them with strong DevOps sauce.
• It’s About the Data: Bounded contexts with API’s are great until you need to ask really big questions. How do we effectively wrangle all of the data at once?
Along the way, we’ll see how open source technology efforts such as Cloud Foundry, Spring Cloud, Netflix OSS, Spring XD, and Hadoop can help us with many of these considerations.
Deploying Microservices to Cloud FoundryMatt Stine
As presented at Cloud Foundry Summit 2015 in Santa Clara, CA.
Now that you have Cloud Foundry, what are you going to do with it?
This presentation will show using Spring Cloud on Cloud Foundry to quickly leverage common microservice patterns, including distributed configuration management, service discovery, intelligent routing, load balancing, and fault tolerance.
Using Spring Cloud on Cloud Foundry, developers can take advantage of the cloud native microservice architectures pioneered by those building the web at places like Twitter, LinkedIn, and Netflix. In many cases they can do so running the same code with Spring Cloud wrapping the same battle-tested open source components those companies are running in production.
Cloud Foundry Diego: Modular and Extensible Substructure for MicroservicesMatt Stine
The Diego project was originally conceived as a rewrite of the Droplet Execution Agent (DEA) component of the Cloud Foundry elastic runtime, the component responsible for scheduling, starting, stopping, and scaling applications in Linux containers. Since Diego’s inception, this development effort has been guided by core principles such as simplicity, loose coupling, high cohesion, separation of concerns, and seeking the right abstractions.
These guiding principles have resulted in an extremely modular platform that provides a welcome home for your microservices. Microservices are loosely coupled, independently deployable applications whose individual scopes are guided by the concept of bounded contexts. Martin Fowler has described well the operational maturity required to employ microservices architectures, memorably stating “you must be this tall to ride the microservices ride,” with the capability to do rapid deployment and basic monitoring. Diego’s opinionated automation and health checking provide a great platform for operating microservices. At the same time, this platform has clean abstractions that support useful extension points.
In this presentation we'll explore the Diego architecture, highlight Diego’s role as the new core of the Cloud Foundry elastic runtime, and illustrated how Diego is being used as a component in other platforms such as Lattice and Spring XD. We'll also look at how Diego's abstractions provided an easy road to adding alternative backends for other platforms like core Windows/.NET support to Cloud Foundry. Finally, we'll discover how Diego's abstractions are providing the Spring Cloud project with a clear road to providing tighter integration between the Netflix OSS stack of services and Cloud Foundry, with a goal of enabling support for polyglot cloud-native application architectures.
Building Distributed Systems with Netflix OSS and Spring CloudMatt Stine
As presented at: http://www.meetup.com/Pivotal-Open-Source-Hub/events/219264521/
With the advent of microservice and cloud-native application architectures, building distributed systems is becoming increasingly common for the enterprise Java developer. Fortunately many of the innovators in the space, including Twitter, LinkedIn, and Netflix, have embraced the JVM as they’ve built increasingly complex systems, with Netflix open-sourcing much of its toolkit for constructing these systems at NetflixOSS.
Spring Cloud provides tools for developers to quickly build some of the common patterns in distributed systems. Many of these patterns are provided via wrapping the battle-tested components found at NetflixOSS.
A Recovering Java Developer Learns to GoMatt Stine
As presented at OSCON 2014.
The Go programming language has emerged as a favorite tool of DevOps and cloud practitioners alike. In many ways, Go is more famous for what it doesn’t include than what it does, and co-author Rob Pike has said that Go represents a “less is more” approach to language design.
The Cloud Foundry engineering teams have steadily increased their use of Go for building components, starting with the Router, and progressing through Loggregator, the CLI, and more recently the Health Manager. As a “recovering-Java-developer-turned-DevOps-junkie” focused on helping our customers and community succeed with Cloud Foundry, it became very clear to me that I needed to add Go to my knowledge portfolio.
This talk will introduce Go and its distinctives to Java developers looking to add Go to their toolkits. We’ll cover Go vs. Java in terms of:
* type systems
* modularity
* programming idioms
* object-oriented constructs
* concurrency
Cloud Foundry and Microservices: A Mutualistic Symbiotic RelationshipMatt Stine
As delivered to the Cloud Foundry Summit 2014 in San Francisco, CA:
With businesses built around software now disrupting multiple industries that appeared to have stable leaders, the need has emerged for enterprises to create "software factories" built around the following principles:
* Streaming customer feedback directly into rapid, iterative cycles of application development
* Horizontally scaling applications to meet user demand
* Compatibility with an enormous diversity of clients, with mobility (smartphones, tablets, etc.) taking the lead
* Continuous delivery of value, shrinking the cycle time from concept to cash
Infrastructure has taken the lead in adapting to meet these needs with the move to the cloud, and Platform as a Service (PaaS) has raised the level of abstraction to a focus on an ecosystem of applications and services. However, most applications are still developed as if we're living in the previous generation of both business and infrastructure: the monolithic application. Microservices - small, loosely coupled applications that follow the Unix philosophy of "doing one thing well" - represent the application development side of enabling rapid, iterative development, horizontal scale, polyglot clients, and continuous delivery. They also enable us to scale application development and eliminate long term commitments to a single technology stack.
While microservices are simple, they are certainly not easy. It's recently been said that "microservices are not a free lunch". Interestingly enough, if you look at the concerns expressed here about microservices, you'll find that they are exactly the challenges that a PaaS is intended to address. So while microservices do not necessarily imply cloud (and vice versa), there is in fact a symbiotic relationship between the two, with each approach somehow compensating for the limitations of the other, much like the practices of eXtreme Programming.
UiPath Test Automation using UiPath Test Suite series, part 4DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 4. In this session, we will cover Test Manager overview along with SAP heatmap.
The UiPath Test Manager overview with SAP heatmap webinar offers a concise yet comprehensive exploration of the role of a Test Manager within SAP environments, coupled with the utilization of heatmaps for effective testing strategies.
Participants will gain insights into the responsibilities, challenges, and best practices associated with test management in SAP projects. Additionally, the webinar delves into the significance of heatmaps as a visual aid for identifying testing priorities, areas of risk, and resource allocation within SAP landscapes. Through this session, attendees can expect to enhance their understanding of test management principles while learning practical approaches to optimize testing processes in SAP environments using heatmap visualization techniques
What will you get from this session?
1. Insights into SAP testing best practices
2. Heatmap utilization for testing
3. Optimization of testing processes
4. Demo
Topics covered:
Execution from the test manager
Orchestrator execution result
Defect reporting
SAP heatmap example with demo
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
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.
Kubernetes & AI - Beauty and the Beast !?! @KCD Istanbul 2024Tobias Schneck
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
Encryption in Microsoft 365 - ExpertsLive Netherlands 2024Albert Hoitingh
In this session I delve into the encryption technology used in Microsoft 365 and Microsoft Purview. Including the concepts of Customer Key and Double Key Encryption.
Transcript: Selling digital books in 2024: Insights from industry leaders - T...BookNet Canada
The publishing industry has been selling digital audiobooks and ebooks for over a decade and has found its groove. What’s changed? What has stayed the same? Where do we go from here? Join a group of leading sales peers from across the industry for a conversation about the lessons learned since the popularization of digital books, best practices, digital book supply chain management, and more.
Link to video recording: https://bnctechforum.ca/sessions/selling-digital-books-in-2024-insights-from-industry-leaders/
Presented by BookNet Canada on May 28, 2024, with support from the Department of Canadian Heritage.
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
Neuro-symbolic is not enough, we need neuro-*semantic*Frank van Harmelen
Neuro-symbolic (NeSy) AI is on the rise. However, simply machine learning on just any symbolic structure is not sufficient to really harvest the gains of NeSy. These will only be gained when the symbolic structures have an actual semantics. I give an operational definition of semantics as “predictable inference”.
All of this illustrated with link prediction over knowledge graphs, but the argument is general.
Generating a custom Ruby SDK for your web service or Rails API using Smithyg2nightmarescribd
Have you ever wanted a Ruby client API to communicate with your web service? Smithy is a protocol-agnostic language for defining services and SDKs. Smithy Ruby is an implementation of Smithy that generates a Ruby SDK using a Smithy model. In this talk, we will explore Smithy and Smithy Ruby to learn how to generate custom feature-rich SDKs that can communicate with any web service, such as a Rails JSON API.
Key Trends Shaping the Future of Infrastructure.pdfCheryl Hung
Keynote at DIGIT West Expo, Glasgow on 29 May 2024.
Cheryl Hung, ochery.com
Sr Director, Infrastructure Ecosystem, Arm.
The key trends across hardware, cloud and open-source; exploring how these areas are likely to mature and develop over the short and long-term, and then considering how organisations can position themselves to adapt and thrive.
Key Trends Shaping the Future of Infrastructure.pdf
Vert.x
1. Vert.x:
This ain’t your Dad’s Node!
Matt Stine
Tim Fox
Enterprise Java/Cloud Consultant
Father of Vert.x
matt.stine@gmail.com
http://mattstine.com
Twitter: @mstine
27. Node: Up and Running
Example 3-11: Using cluster to distribute work
28. Solution #2:
The
JVM
James Gosling
Father of Java
29. The Verticle
- Unit of Deployment
Verticle
- Script/Java Class
30. Vert.x Instance
How it works it works it works it works
How How How
Event loop Event loop Event loop Event loop
Event Loops
App registers App registers App registers App registers trigger Events trigger Events trigger Events trigg
Events
handlers handlers handlers handlershandlers handlers handlers handlers
• Handlers executed synchronously executed synchronously
• Handlers executed synchronously executed synchronously
• Handlers • Handlers
– on a single threada single threada single threada single thread
– on – on – on
• Use handlersUse handlersUse handlersUse handlers to pass messages
• to pass messages messages messages
• to pass • to pass
• Inter/intra application comms
• Inter/intra application comms
• Inter/intra application comms
• Inter/intra application comms
– EventBus with EventBus with EventBus with EventBus with messages
– messages – messages – messages
– Safe shared data structuresdata structuresdata structuresdata structures
– Safe shared – Safe shared – Safe shared
Verticle 9 9 9
Runtime.availableProcessors() == 4
31. Vert.x Instance
How it works it works it works it works
How How How
Event loop Event loop Event loop Event loop
Event Loops
App registers App registers App registers App registers trigger Events trigger Events trigger Events trigg
Events
handlers handlers handlers handlershandlers handlers handlers handlers
• Handlers executed synchronously executed synchronously
• Handlers executed synchronously executed synchronously
• Handlers • Handlers
– on a single threada single threada single threada single thread
– on – on – on
• Use handlersUse handlersUse handlersUse handlers to pass messages
• to pass messages messages messages
• to pass • to pass
vertx run • Inter/intra application comms
• Inter/intra application comms
• Inter/intra application comms
• Inter/intra application comms
HelloWorld with EventBus with EventBus with EventBus with messages
– EventBus – messages – messages – messages
– Safe shared data structuresdata structuresdata structuresdata structures
– Safe shared – Safe shared – Safe shared
-instances 4 Verticle Verticle Verticle Verticle 9 9 9
Runtime.availableProcessors() == 4
32. Concurrency
• Verticle instance assigned thread/event loop.
• Verticle instance ALWAYS executes on
assigned thread.
• Verticles have isolated classloaders and
cannot share global state (static members,
global variables, etc.)
• Can write all code assuming single
threading.
33. Tony Hoare
Father of CSP
(http://dl.acm.org/citation.cfm?
doid=359576.359585)
Problem #3:
Interprocess
Communication
35. Solution #3.1:
The
Event
Bus
Alan Kay
Father of Smalltalk
36. How it works it works it works it works
How How How
Event loop Event loop Event loop Event loop
App registers App registers App registers App registers trigger Events trigger Events trigger Events trigger
Events
handlers handlers handlers handlershandlers handlers handlers handlers
• Handlers executed synchronously executed synchronously
• Handlers executed synchronously executed synchronously
• Handlers • Handlers
– on a single threada single threada single threada single thread
– on – on – on
• Use handlersUse handlersUse handlersUse handlers to pass messages
• to pass messages messages messages
• to pass • to pass
• Inter/intra application comms
• Inter/intra application comms
• Inter/intra application comms
• Inter/intra application comms
– EventBus with EventBus with EventBus with EventBus with messages
– messages – messages – messages
– Safe shared data structuresdata structuresdata structuresdata structures
– Safe shared – Safe shared – Safe shared
Verticle Verticle Verticle Verticle 9 9 9 9
Event Bus
37. Addressing
• Simply a String
• Dot-style namespacing recommended
• e.g. “messages.inbound.A”
46. Distributed Vert.x
orks it works it works it works
How How How How it works it works it works it works
How How How How it works it works it works it works
How How How
Event loop Event loop Event loop Event loop Event loop Event loop Event loop Event loop Event loop Event loop Event loop Event loop
rs App registers App registers App registers trigger Events trigger Events trigger Events trigger registers App registers trigger Events trigger Events trigger Events trigger registers App registers trigger Events trigger Events trigger
Events App registers App registers App Events App registers App registers App Events
handlers handlers handlershandlers handlers handlers
handlers handlers
handlers handlers handlershandlers handlers handlers
handlers handlers
handlers handlers handlershandlers handlers handlers
executed synchronously executed synchronously
• Handlers executed synchronously executed synchronously
• Handlers • Handlers • Handlers executed synchronously executed synchronously
• Handlers executed synchronously executed synchronously
• Handlers • Handlers • Handlers executed synchronously executed synchronously
• Handlers executed synchronously executed synchronously
• Handlers • Handlers
le threada single threada single threada single thread
– on – on – on – on a single threada single threada single threada single thread
– on – on – on – on a single threada single threada single threada single thread
– on – on – on
ersUsepass messages messages messages messages handlersUsepass messages messages messages messages handlersUse handlersUsepass messages messages messages
• to handlersUse handlersUsepass
• to pass • to handlers to pass • Use • to handlersUse handlersUsepass
• to pass • to handlers to pass • Use • to pass messages
• to handlersUse handlers to pass
• to pass
application comms
• Inter/intra application comms
• Inter/intra application comms
• Inter/intra application comms• Inter/intra application comms
• Inter/intra application comms
• Inter/intra application comms
• Inter/intra application comms Inter/intra application comms
• • Inter/intra application comms
• Inter/intra application comms
• Inter/intra application comms
s with EventBus with EventBus with EventBus with messages
– messages – messages – messages – EventBus with EventBus with EventBus with EventBus with messages
– messages – messages – messages – EventBus with EventBus with EventBus with EventBus with messages
– messages – messages – messages
red data structuresdata structuresdata structuresdata structures
– Safe shared – Safe shared – Safe shared – Safe shared data structuresdata structuresdata structuresdata structures
– Safe shared – Safe shared – Safe shared – Safe shared data structuresdata structuresdata structuresdata structures
– Safe shared – Safe shared – Safe shared
Verticle Verticle Verticle 9
Verticle9 9
Verticle
9
Verticle Verticle 9
Verticle
9 9
Verticle
9
Verticle Verticle 9
Verticle
9 9
Event Bus
47. Into the Browser!
orks it works it works it works
How How How How it works it works it works it works
How How How
Event loop Event loop Event loop Event loop Event loop Event loop Event loop Event loop
rs App registers App registers App registers trigger Events trigger Events trigger Events trigger registers App registers trigger Events trigger Events trigger Events trigger
Events App registers App registers App Events
handlers handlers handlershandlers handlers handlers
handlers handlers
handlers handlers handlershandlers handlers handlers handlers
executed synchronously executed synchronously
• Handlers executed synchronously executed synchronously
• Handlers • Handlers • Handlers executed synchronously executed synchronously
• Handlers executed synchronously executed synchronously
• Handlers • Handlers
le threada single threada single threada single thread
– on – on – on – on a single threada single threada single threada single thread
– on – on – on
ersUsepass messages messages messages messages handlersUsepass messages messages messages messages
• to handlersUse handlersUsepass
• to pass • to handlers to pass • Use • to handlersUse handlersUsepass
• to pass • to handlers to pass
application comms
• Inter/intra application comms
• Inter/intra application comms
• Inter/intra application comms• Inter/intra application comms
• Inter/intra application comms
• Inter/intra application comms
• Inter/intra application comms
s with EventBus with EventBus with EventBus with messages
– messages – messages – messages – EventBus with EventBus with EventBus with EventBus with messages
– messages – messages – messages
red data structuresdata structuresdata structuresdata structures
– Safe shared – Safe shared – Safe shared – Safe shared data structuresdata structuresdata structuresdata structures
– Safe shared – Safe shared – Safe shared
Verticle Verticle Verticle 9
Verticle9 9
Verticle
9
Verticle Verticle 9
Verticle
9 9 9
SockJS Bridge
Event Bus
55. Vert.x Shared State
• SharedData Object (vertx.sharedData())
• collection of
java.util.concurrent.ConcurrentMap<K,V>
• collection of java.util.Set<E> (backed by
ConcurrentMap)
• Elements MUST be immutable values (well,
sort of...)
• Currently only available within a Vertx.
instance, not across a cluster.
56. Allowed Values
• Strings
• Boxed Primitives
•byte[]
R !
•org.vertx.java.core.buffer.Buffer
• Implementors of
G E
Shareable
AN
org.vertx.java.core.shareddata.
D
59. Problem #4:
The
Event
Loop
Douglas Schmidt
Father of the Reactor Pattern
60. Reactor
w it works Pattern Review
Event loop
Application ...events
pp registers
registers Events t
trigger
handlers handl
handlers... handlers.
Event Loop
andlers executed synchronously
on a single thread
se handlers to pass messages
61. Reactor Pattern Review
• Single thread / single event loop
• EVERYTHING runs on it
• You MUST NOT block the event loop
62. Reactor Pattern Problems
• Some work is naturally blocking:
• Intensive data crunching
• 3rd-party blocking API’s (e.g. JDBC)
• Pure reactor (e.g. Node.js) is not a good fit
for this kind of work!
63. Solution #4:
Worker
Verticles
Carl Hewitt
Father of the Actor Model
64. Worker Verticles
• Not assigned a Vert.x event loop thread
• Executes on background thread pool
• Never executed concurrently by more than
one thread
• Not allowed to use TCP or HTTP clients/
servers
• Communicate using the event bus
• Should be kept to a minimum
65. The “Multi-reactor”
How it works it works it works it works
How How How
Event loop Event loop Event loop Event loop
BG BG
App registers App registers App registers App registers trigger Events trigger Events trigger Events trigger
Events
handlers handlers handlers handlershandlers handlers
Pool
handlers
Pool
handlers
• Handlers executed synchronously executed synchronously
• Handlers executed synchronously executed synchronously
• Handlers • Handlers
– on a single threada single threada single threada single thread
– on – on – on
• Use handlersUse handlersUse handlersUse handlers to pass messages
• to pass messages messages messages
• to pass • to pass
• Inter/intra application comms
• Inter/intra application comms
• Inter/intra application comms
• Inter/intra application comms
– EventBus with EventBus with EventBus with EventBus with messages
– messages – messages – messages
– Safe shared data structuresdata structuresdata structuresdata structures
– Safe shared – Safe shared – Safe shared
Worker Worker
Verticle Verticle Verticle Verticle
Verticle Verticle
9 9 9 9
Event Bus
66.
67.
68. Problem/Solution Summary
• Node.js compels the use of JavaScript
• Vert.x is Polyglot
• Node.js is inherently single-threaded
• Vert.x leverages the multi-threaded JVM
69. Problem/Solution Summary
• Node.js doesn’t help much w/ interprocess
communication
• Vert.x features a distributed event bus which
reaches all the way into the browser
• Node.js requires all code to run on the event
loop
• Vert.x features background workers that
allow blocking work to be done off of the
event loops
70. Other Goodies
• Growing Module • TCP/SSL servers/clients
Repository • HTTP/HTTPS servers/
clients
• web server
• persistors (Mongo, • WebSockets support
JDBC, ...) • SockJS support
• work queue • Timers
• authentication • Buffers
manager
• Streams and Pumps
• session manager • Routing
• Socket.IO • Asynchronous File I/O
72. Get Involved!
• Google Group: http://groups.google.com/
group/vertx
• GitHub: https://github.com/vert-x/vert.x
• IRC: irc://freenode.net/vertx
• Needs:
• language implementations
• modules (esp. persistence, security, ...)
• examples/blogs/documentation help
73. Vert.x:
This ain’t your Dad’s Node!
Matt Stine
Enterprise Java/Cloud Consultant
Please fill out an evaluation:
matt.stine@gmail.com
http://mattstine.com
http://speakerrate.com/talks/16821
Twitter: @mstine
74. Image Credits
• Tim Fox: https://twitter.com/timfox
• BSOD Phone: http://www.flickr.com/photos/markhillary/3413357033
• V8: http://www.flickr.com/photos/gorbould/3479298062
• Ryan Dahl: http://www.flickr.com/photos/franksvalli/5163205409
• Shortcomings: http://www.flickr.com/photos/hendricksphotos/3340896056
• Brendan Eich: http://www.flickr.com/photos/equanimity/4055148344
• Neal Ford: http://nealford.com/images/Neal-2012-headshot.jpg
• Lars Bak: http://www.flickr.com/photos/niallkennedy/2822229099
• James Gosling: http://www.flickr.com/photos/skrb/2499736195
• Tony Hoare: http://www.flickr.com/photos/adewale_oshineye/3687557065
• Alan Kay: http://www.flickr.com/photos/mwichary/3010026816
• Rich Hickey: http://www.flickr.com/photos/hlship/3603090614
• Douglas Schmidt: http://www.cs.wustl.edu/~schmidt/gifs/SchmidtD.jpg
• Carl Hewitt: http://www.flickr.com/photos/jeanbaptisteparis/3098594954