2011-11-02 | 05:45 PM - 06:35 PM | Victoria
The Disruptor is new open-source concurrency framework, designed as a high performance mechanism for inter-thread messaging. It was developed at LMAX as part of our efforts to build the world's fastest financial exchange. Using the Disruptor as an example, this talk will explain of some of the more detailed and less understood areas of concurrency, such as memory barriers and cache coherency. These concepts are often regarded as scary complex magic only accessible by wizards like Doug Lea and Cliff Click. Our talk will try and demystify them and show that concurrency can be understood by us mere mortal programmers.
Concurrent Programming Using the DisruptorTrisha Gee
Presented to the London Java Community at Skillsmatter on 1st March 2012.
Full presentation can be viewed here: http://skillsmatter.com/podcast/home/the-disruptor/js-3798
Communication between Microservices is inherently unreliable. These integration points may produce cascading failures, slow responses, service outages. We will walk through stability patterns like timeouts, circuit breaker, bulkheads and discuss how they improve stability of Microservices.
Concurrent Programming Using the DisruptorTrisha Gee
Presented to the London Java Community at Skillsmatter on 1st March 2012.
Full presentation can be viewed here: http://skillsmatter.com/podcast/home/the-disruptor/js-3798
Communication between Microservices is inherently unreliable. These integration points may produce cascading failures, slow responses, service outages. We will walk through stability patterns like timeouts, circuit breaker, bulkheads and discuss how they improve stability of Microservices.
Apache kafka 모니터링을 위한 Metrics 이해 및 최적화 방안SANG WON PARK
Apache Kafak의 빅데이터 아키텍처에서 역할이 점차 커지고, 중요한 비중을 차지하게 되면서, 성능에 대한 고민도 늘어나고 있다.
다양한 프로젝트를 진행하면서 Apache Kafka를 모니터링 하기 위해 필요한 Metrics들을 이해하고, 이를 최적화 하기 위한 Configruation 설정을 정리해 보았다.
[Apache kafka 모니터링을 위한 Metrics 이해 및 최적화 방안]
Apache Kafka 성능 모니터링에 필요한 metrics에 대해 이해하고, 4가지 관점(처리량, 지연, Durability, 가용성)에서 성능을 최적화 하는 방안을 정리함. Kafka를 구성하는 3개 모듈(Producer, Broker, Consumer)별로 성능 최적화를 위한 …
[Apache Kafka 모니터링을 위한 Metrics 이해]
Apache Kafka의 상태를 모니터링 하기 위해서는 4개(System(OS), Producer, Broker, Consumer)에서 발생하는 metrics들을 살펴봐야 한다.
이번 글에서는 JVM에서 제공하는 JMX metrics를 중심으로 producer/broker/consumer의 지표를 정리하였다.
모든 지표를 정리하진 않았고, 내 관점에서 유의미한 지표들을 중심으로 이해한 내용임
[Apache Kafka 성능 Configuration 최적화]
성능목표를 4개로 구분(Throughtput, Latency, Durability, Avalibility)하고, 각 목표에 따라 어떤 Kafka configuration의 조정을 어떻게 해야하는지 정리하였다.
튜닝한 파라미터를 적용한 후, 성능테스트를 수행하면서 추출된 Metrics를 모니터링하여 현재 업무에 최적화 되도록 최적화를 수행하는 것이 필요하다.
This presentation shortly describes key features of Apache Cassandra. It was held at the Apache Cassandra Meetup in Vienna in January 2014. You can access the meetup here: http://www.meetup.com/Vienna-Cassandra-Users/
Everything you ever needed to know about Kafka on Kubernetes but were afraid ...HostedbyConfluent
Kubernetes became the de-facto standard for running cloud-native applications. And many users turn to it also to run stateful applications such as Apache Kafka. You can use different tools to deploy Kafka on Kubernetes - write your own YAML files, use Helm Charts, or go for one of the available operators. But there is one thing all of these have in common. You still need very good knowledge of Kubernetes to make sure your Kafka cluster works properly in all situations. This talk will cover different Kubernetes features such as resources, affinity, tolerations, pod disruption budgets, topology spread constraints and more. And it will explain why they are important for Apache Kafka and how to use them. If you are interested in running Kafka on Kubernetes and do not know all of these, this is a talk for you.
Grafana Mimir and VictoriaMetrics_ Performance Tests.pptxRomanKhavronenko
VictoriaMetrics and Grafana Mimir are time series databases with support of mostly the same protocols and APIs. However, they have different architectures and components, which makes the comparison more complicated. In the talk, we'll go through the details of the benchmark where I compared both solutions. We'll see how VictoriaMetrics and Mimir are dealing with identical workloads and how efficient they’re with using the allocated resources.
The talk will cover design and architectural details, weak and strong points, trade-offs, and maintenance complexity of both solutions.
Apache kafka performance(latency)_benchmark_v0.3SANG WON PARK
Apache Kafka를 이용하여 이미지 데이터를 얼마나 빠르게(with low latency) 전달 가능한지 성능 테스트.
최종 목적은 AI(ML/DL) 모델의 입력으로 대량의 실시간 영상/이미지 데이터를 전달하는 메세지 큐로 사용하기 위하여, Drone/제조공정 등의 장비에서 전송된 이미지를 얼마나 빨리 AI Model로 전달 할 수 있는지 확인하기 위함.
그래서 Kafka에서 이미지를 전송하는 간단한 테스트를 진행하였고,
이 과정에서 latency를 얼마나 줄여주는지를 확인해 보았다.(HTTP 프로토콜/Socket과 비교하여)
[현재 까지 결론]
- Apache Kafka는 대량의 요청 처리를 위한 throughtput에 최적화 된 솔루션임.
- 현재는 producer의 몇가지 옵션만 조정하여 테스트한 결과이므로,
- 잠정적인 결과이지만, kafka의 latency를 향상을 위해서는 많은 시도가 필요할 것 같음.
- 즉, 단일 요청의 latency는 확실히 느리지만,
- 대량의 처리를 기준으로 평균 latency를 비교하면 평균적인 latency는 많이 낮아짐.
Test Code : https://github.com/freepsw/kafka-latency-test
Stephan Ewen - Experiences running Flink at Very Large ScaleVerverica
This talk shares experiences from deploying and tuning Flink steam processing applications for very large scale. We share lessons learned from users, contributors, and our own experiments about running demanding streaming jobs at scale. The talk will explain what aspects currently render a job as particularly demanding, show how to configure and tune a large scale Flink job, and outline what the Flink community is working on to make the out-of-the-box for experience as smooth as possible. We will, for example, dive into - analyzing and tuning checkpointing - selecting and configuring state backends - understanding common bottlenecks - understanding and configuring network parameters
Spark 의 핵심은 무엇인가? RDD! (RDD paper review)Yongho Ha
요즘 Hadoop 보다 더 뜨고 있는 Spark.
그 Spark의 핵심을 이해하기 위해서는 핵심 자료구조인 Resilient Distributed Datasets (RDD)를 이해하는 것이 필요합니다.
RDD가 어떻게 동작하는지, 원 논문을 리뷰하며 살펴보도록 합시다.
http://www.cs.berkeley.edu/~matei/papers/2012/sigmod_shark_demo.pdf
How Criteo is managing one of the largest Kafka Infrastructure in EuropeRicardo Paiva
In Criteo we manage one of the largest Kafka infrastructure in Europe, with more than 7 million msgs/sec. This talk was first presented on the Kafka Meetup Paris, in January of 2019.
Apache kafka 모니터링을 위한 Metrics 이해 및 최적화 방안SANG WON PARK
Apache Kafak의 빅데이터 아키텍처에서 역할이 점차 커지고, 중요한 비중을 차지하게 되면서, 성능에 대한 고민도 늘어나고 있다.
다양한 프로젝트를 진행하면서 Apache Kafka를 모니터링 하기 위해 필요한 Metrics들을 이해하고, 이를 최적화 하기 위한 Configruation 설정을 정리해 보았다.
[Apache kafka 모니터링을 위한 Metrics 이해 및 최적화 방안]
Apache Kafka 성능 모니터링에 필요한 metrics에 대해 이해하고, 4가지 관점(처리량, 지연, Durability, 가용성)에서 성능을 최적화 하는 방안을 정리함. Kafka를 구성하는 3개 모듈(Producer, Broker, Consumer)별로 성능 최적화를 위한 …
[Apache Kafka 모니터링을 위한 Metrics 이해]
Apache Kafka의 상태를 모니터링 하기 위해서는 4개(System(OS), Producer, Broker, Consumer)에서 발생하는 metrics들을 살펴봐야 한다.
이번 글에서는 JVM에서 제공하는 JMX metrics를 중심으로 producer/broker/consumer의 지표를 정리하였다.
모든 지표를 정리하진 않았고, 내 관점에서 유의미한 지표들을 중심으로 이해한 내용임
[Apache Kafka 성능 Configuration 최적화]
성능목표를 4개로 구분(Throughtput, Latency, Durability, Avalibility)하고, 각 목표에 따라 어떤 Kafka configuration의 조정을 어떻게 해야하는지 정리하였다.
튜닝한 파라미터를 적용한 후, 성능테스트를 수행하면서 추출된 Metrics를 모니터링하여 현재 업무에 최적화 되도록 최적화를 수행하는 것이 필요하다.
This presentation shortly describes key features of Apache Cassandra. It was held at the Apache Cassandra Meetup in Vienna in January 2014. You can access the meetup here: http://www.meetup.com/Vienna-Cassandra-Users/
Everything you ever needed to know about Kafka on Kubernetes but were afraid ...HostedbyConfluent
Kubernetes became the de-facto standard for running cloud-native applications. And many users turn to it also to run stateful applications such as Apache Kafka. You can use different tools to deploy Kafka on Kubernetes - write your own YAML files, use Helm Charts, or go for one of the available operators. But there is one thing all of these have in common. You still need very good knowledge of Kubernetes to make sure your Kafka cluster works properly in all situations. This talk will cover different Kubernetes features such as resources, affinity, tolerations, pod disruption budgets, topology spread constraints and more. And it will explain why they are important for Apache Kafka and how to use them. If you are interested in running Kafka on Kubernetes and do not know all of these, this is a talk for you.
Grafana Mimir and VictoriaMetrics_ Performance Tests.pptxRomanKhavronenko
VictoriaMetrics and Grafana Mimir are time series databases with support of mostly the same protocols and APIs. However, they have different architectures and components, which makes the comparison more complicated. In the talk, we'll go through the details of the benchmark where I compared both solutions. We'll see how VictoriaMetrics and Mimir are dealing with identical workloads and how efficient they’re with using the allocated resources.
The talk will cover design and architectural details, weak and strong points, trade-offs, and maintenance complexity of both solutions.
Apache kafka performance(latency)_benchmark_v0.3SANG WON PARK
Apache Kafka를 이용하여 이미지 데이터를 얼마나 빠르게(with low latency) 전달 가능한지 성능 테스트.
최종 목적은 AI(ML/DL) 모델의 입력으로 대량의 실시간 영상/이미지 데이터를 전달하는 메세지 큐로 사용하기 위하여, Drone/제조공정 등의 장비에서 전송된 이미지를 얼마나 빨리 AI Model로 전달 할 수 있는지 확인하기 위함.
그래서 Kafka에서 이미지를 전송하는 간단한 테스트를 진행하였고,
이 과정에서 latency를 얼마나 줄여주는지를 확인해 보았다.(HTTP 프로토콜/Socket과 비교하여)
[현재 까지 결론]
- Apache Kafka는 대량의 요청 처리를 위한 throughtput에 최적화 된 솔루션임.
- 현재는 producer의 몇가지 옵션만 조정하여 테스트한 결과이므로,
- 잠정적인 결과이지만, kafka의 latency를 향상을 위해서는 많은 시도가 필요할 것 같음.
- 즉, 단일 요청의 latency는 확실히 느리지만,
- 대량의 처리를 기준으로 평균 latency를 비교하면 평균적인 latency는 많이 낮아짐.
Test Code : https://github.com/freepsw/kafka-latency-test
Stephan Ewen - Experiences running Flink at Very Large ScaleVerverica
This talk shares experiences from deploying and tuning Flink steam processing applications for very large scale. We share lessons learned from users, contributors, and our own experiments about running demanding streaming jobs at scale. The talk will explain what aspects currently render a job as particularly demanding, show how to configure and tune a large scale Flink job, and outline what the Flink community is working on to make the out-of-the-box for experience as smooth as possible. We will, for example, dive into - analyzing and tuning checkpointing - selecting and configuring state backends - understanding common bottlenecks - understanding and configuring network parameters
Spark 의 핵심은 무엇인가? RDD! (RDD paper review)Yongho Ha
요즘 Hadoop 보다 더 뜨고 있는 Spark.
그 Spark의 핵심을 이해하기 위해서는 핵심 자료구조인 Resilient Distributed Datasets (RDD)를 이해하는 것이 필요합니다.
RDD가 어떻게 동작하는지, 원 논문을 리뷰하며 살펴보도록 합시다.
http://www.cs.berkeley.edu/~matei/papers/2012/sigmod_shark_demo.pdf
How Criteo is managing one of the largest Kafka Infrastructure in EuropeRicardo Paiva
In Criteo we manage one of the largest Kafka infrastructure in Europe, with more than 7 million msgs/sec. This talk was first presented on the Kafka Meetup Paris, in January of 2019.
Today's trending technologies is tomorrows popular technologies, be updated with the most trending technologies and choose the technology that fits with your business needs.
Make JSF more type-safe with CDI and MyFaces CODIos890
These slides show how to use type-safe mechanisms provided by MyFaces CODI for developing JSF applications which are more type-safe and easier to maintain.
http://2012.con-fess.com/sessions/-/details/136/MyFaces-CODI-and-JBoss-Seam3-become-Apache-DeltaSpike is the next part with more details about MyFaces CODI and Apache DeltaSpike at
MyFaces CODI and JBoss Seam3 become Apache DeltaSpikeos890
These slides show how to use type-safe mechanisms provided by MyFaces CODI for developing JSF applications which are more type-safe and easier to maintain as well as common pitfalls. Beyond that there is an basic overview of Apache DeltaSpike.
Combining Front-End and Backend Testing with Sauce Labs & BlazeMeterSauce Labs
In advance of the 2016 holiday season, Sauce Labs and BlazeMeter teamed up for a webinar that presented step-by-step instructions on how to use JMeter and Selenium to get real-world results from your front end-while applying load to the backend.
How To Combine Back-End & Front-End Testing with BlazeMeter & Sauce LabsSauce Labs
Sauce Labs and BlazeMeter teamed up for an awesome webinar, giving step-by-step instructions on how to get real-world results from your front end while applying load to the backend.
IPT High Performance Reactive Programming with JAVA 8 and JavaScriptTrayan Iliev
Presentation @ jProfessionals BGJUG Conference
Sofia, November 22, 2015 by IPT – IT Education Evolved, High Performance Reactive Programming Workshop - Dec 15-17,2015 http://iproduct.org/en/course-reactive-java-js/
You are welcome to join us!
Low-latency, high-throughput reactive and functional programming in Java using Spring Reactor, RxJava, RxJS, Facebook React, Angular 2, Reactive Streams, Disruptor (ring buffer), Reactor & Proactor design patterns, benchmarking & comparison of concurrency implementations. December 15 - 17, 2015 - Workshop: High Performance Reactive Programming with JAVA 8 and JavaScript - http://iproduct.org/en/course-reactive-java-js/
Options and trade offs for parallelism and concurrency in Modern C++Satalia
While threads have become a first class citizen in C++ since C++11, it is not always the case that they are the best abstraction to express parallelism where the objective is to speed up computations. OpenMP is a parallelism API for C/C++ and Fortran that has been around for a long time. Intel's Threading Building Blocks (TBB) is only a little bit more than 10 years old, but is very mature, and specifically for C++.
Mats will introduce OpenMP and TBB and their use in modern C++ and provide some best practices for them as well as try to predict what the C++ standard has in store for us when it comes to parallelism in the future.
Locks? We Don't Need No Stinkin' Locks - Michael BarkerJAX London
Embrace the dark side. As a developer you'll often be advised that writing concurrent code should be the purview of the genius coders alone. In this talk Michael Barker will discard that notion into the cesspits of logic and reason and attempt to present on the less understood area of non-blocking concurrency, i.e. concurrency without locks. We'll look the modern Intel CPU architecture, why we need a memory model, the performance costs of various non-blocking constructs and delve into the implementation details of the latest version of the Disruptor to see how non-blocking concurrency can be applied to build high performance data structures.
.NET has accustomed us to writing code quickly and without thinking about what is going on underneath. Unfortunately, convenience comes with additional cost. It is very easy to lose the performance of our component through simple statement or code block which behaves differently than we thought. I will focus on the everyday performance traps, which can spoil your hard effort.
Java/Scala Lab: Анатолий Кметюк - Scala SubScript: Алгебра для реактивного пр...GeeksLab Odessa
SubScript - это расширение языка Scala, добавляющее поддержку конструкций и синтаксиса аглебры общающихся процессов (Algebra of Communicating Processes, ACP). SubScript является перспективным расширением, применимым как для разработки высоконагруженных параллельных систем, так и для простых персональных приложений.
How Triton can help to reverse virtual machine based software protectionsJonathan Salwan
The first part of the talk is going to be an introduction to the Triton framework to expose its components and to explain how they work together. Then, the second part will include demonstrations on how it's possible to reverse virtual machine based protections using taint analysis, symbolic execution, SMT simplifications and LLVM-IR optimizations.
Java Tech & Tools | Continuous Delivery - the Writing is on the Wall | John S...JAX London
2011-11-01 | 10:40 AM - 11:40 AM
So you want to do continuous delivery but is it working and how does the team and the organisation know what's going on? Using wallboard, information radiators and even just bits of paper stuck to the wall can help you manage all your development.
Covering the many ways companies have visualised the mashinations of their work and providing tips on setting up your own uber information radiators.
Java Tech & Tools | Mapping, GIS and Geolocating Data in Java | Joachim Van d...JAX London
2011-11-02 | 03:45 PM - 04:35 PM
Introduction to mapping, geographic information systems and geolocalization. After covering basics like layers and projections, data formats and standards we will look at open source tools and Java libraries which can help you to build working solutions.
Keynote | Middleware Everywhere - Ready for Mobile and Cloud | Dr. Mark LittleJAX London
2011-11-01 | 09:45 AM-10:30 AM
The traditional role of middleware in the data center has been challenged to expand and meet the ubiquitous computing demands becoming more prevalent. The way applications are built, deployed, integrated and managed must accommodate the rapidly evolving mobile and cloud paradigms, without sacrificing security or performance. Open Standards, and a more agile stewardship of the Java Community Process will enable developers, architects and IT executives increase return on their existing IT investment and spur innovation in next generation application environments. Please join Dr. Mark Little, Sr. Director Middleware Engineering, as he discusses Red Hat's vision for how JBoss Enterprise Middleware will drive social, mobile and cloud computing.
Spring Day | WaveMaker - Spring Roo - SpringSource Tool Suite: Choosing the R...JAX London
2011-10-31 | 02:15 PM - 03:00 PM
There are many tools out there to help developers working with the Spring framework and its manifold extensions. But it's not always easy to choose the right tool for the job. This talk guides you through the tooling landscape for Spring and illustrates when to use Spring Roo, WaveMaker or the SpringSource Tool Suite. Demos and examples give the audience first-hand insights and useful hints how to use and combine those tools effectively.
Spring Day | Behind the Scenes at Spring Batch | Dave SyerJAX London
2011-10-31 | 01:30 PM - 02:15 PM
Spring Batch has a large user base and a good track record in production systems, but what is it all really about, and why does it work? This presentation provides a short bootstrap to get a new user started with the Batch domain, showing the key concepts and explaining the benefits of the framework. Then it goes into a deeper dive and looks at what holds it all together, with a close look at some of the most important but least understood features, including restart, retry and transactions.
Spring Day | Spring 3.1 in a Nutshell | Sam BrannenJAX London
2011-10-31 | 11:45 AM - 12:30 PM
Spring 3.1 introduces several eagerly awaited features including bean definition profiles (a.k.a., environment-specific configuration), enhanced Java-based application and infrastructure configuration (a la XML namespaces), and a new cache abstraction. This session will provide attendees with a high-level overview of these major new features, plus a quick look at additional enhancements to the framework such as the new c: namespace for constructor arguments, support for Servlet 3.0, improvements to Spring MVC and REST, and Spring's new integration testing support for profiles and configuration classes.
Spring Day | Identity Management with Spring Security | Dave SyerJAX London
2011-10-31 | 11:00 AM - 11:45 AM
Application and platform security requirements are changing under the influence of standards like OpenID and OAuth2, and the increasing demand for lightweight and multi-language platforms. Everyone used to be happy if they could implement single sign on for their Java web applications. That's still important, but there is a growing demand for more extensive Identity Management services, both in the enterprise and for public web applications. CloudFoundry is a nice use case for this new service model: it has multi-language support and security requirements that go beyond simple single sign on. What does that mean, and what does it mean for Spring Security? Come to this presentation to find out.
Spring Day | Spring and Scala | Eberhard WolffJAX London
2011-10-31 | 09:45 AM - 10:30 AM
Spring is widely used in the Java world - but does it make any sense to combine it with Scala? This talk gives an answer and shows how and why Spring is useful in the Scala world. All areas of Spring such as Dependency Injection, Aspect-Oriented Programming and the Portable Service Abstraction as well as Spring MVC are covered.
Java Tech & Tools | Beyond the Data Grid: Coherence, Normalisation, Joins and...JAX London
2011-11-02 | 02:25 PM - 03:15 PM
In 2009 RBS set out to build a single store of trade and risk data that all applications in the bank could access simultaniously. This talk discusses a number of novel techniques that were developed as part of this work. Based on Oracle Coherence the ODC departs from the trend set by most caching solutions by holding its data in a normalised form making it both memory efficient and easy to change. However it does this in a novel way that supports most arbitrary queries without the usual problems associated with distributed joins. We'll be discussing these patterns as well as others that allow linear scalability, fault tolerance and millisecond latencies.
Java Tech & Tools | Social Media in Programming in Java | Khanderao KandJAX London
2011-11-02 | 10:00 AM - 11:00 AM
With the popularity of Social media, businesses require to integrate ERP, CRM and Commerce apps with Social media for consumer monitoring, engagement, analytics, marketing, brand monitoring as well as influencing their purchases. This session covers Java tools, protocols, and frameworks for social media for Social CRM and Social Commerce. Covers: Oauth2, Social Graph, REST, JSON, Facebook & Twitter.
Java Tech & Tools | Just Keep Passing the Message | Russel WinderJAX London
2011-11-01 | 04:20 PM - 05:10 PM
With the increasing ubiquity of multicore and hence parallel systems people are needing better ways of structuring applications than using shared-memory multi-threading. In this session we will look at actors, agents and active objects -- and their implementation in GPars. GPars is a Groovy/Java framework for managing concurrency and parallelism. It leverages all the JSR166 APIs
Java Tech & Tools | Grails in the Java Enterprise | Peter LedbrookJAX London
2011-11-01 | 03:00 PM - 03:50 PM
With all the buzz around rapid web application development frameworks, are enterprise developers left looking on enviously? Not at all. Grails brings the same benefits to Java developers while providing many options for enterprise integration. This talk shows you how to build Grails projects with Ant and Maven; what's involved in talking to legacy databases; and how to talk to Java components.
Java EE | Modular EJBs for Enterprise OSGi | Tim WardJAX London
2011-11-01 | 05:20 PM - 06:10 PM
Enterprise OSGi is all about enabling Java EE technologies in an OSGi environment. Modular EJB provides support for Enterprise Java Beans running inside OSGi, taking advantage of the framework's modularity. See how to: * Package EJBs for use in an OSGi environment * Make use of EJBs from other OSGi bundles * Consume OSGi services directly within your EJBs * Flow transactions between EJBs and OSGi
Java EE | Apache TomEE - Java EE Web Profile on Tomcat | Jonathan GallimoreJAX London
2011-11-01 | 04:20 PM - 05:10 PM
This session explores Apache TomEE, pronounced “Tommy”, an all-Apache Web Profile stack built on Tomcat, which adds all the Java EE Web Profile features, while taking nothing away. The session will show you how to get started with TomEE, how to use it with a sample application, and how you can test your application with TomEE using tools like Arquillian.
Java Core | Java 8 and OSGi Modularisation | Tim Ellison & Neil BartlettJAX London
The talk will cover a bit of background first to set things up: what is a module, why do we need a module system, summary of Java's existing support for modularity. Then it will move on to give a comparison of OSGi's and Jigsaw's dependency models. Pros and cons of each model in different environments will be discussed. Finally, opportunities and challenges for interoperability: from the perspective of both application developers (who may need to integrate modules from both kinds) and from library module developers (who may need to target both module systems)
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
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.
GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using Deplo...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
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.
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
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/
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.
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.
Let's dive deeper into the world of ODC! Ricardo Alves (OutSystems) will join us to tell all about the new Data Fabric. After that, Sezen de Bruijn (OutSystems) will get into the details on how to best design a sturdy architecture within ODC.
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
The Art of the Pitch: WordPress Relationships and SalesLaura Byrne
Clients don’t know what they don’t know. What web solutions are right for them? How does WordPress come into the picture? How do you make sure you understand scope and timeline? What do you do if sometime changes?
All these questions and more will be explored as we talk about matching clients’ needs with what your agency offers without pulling teeth or pulling your hair out. Practical tips, and strategies for successful relationship building that leads to closing the deal.
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.
Software Delivery At the Speed of AI: Inflectra Invests In AI-Powered QualityInflectra
In this insightful webinar, Inflectra explores how artificial intelligence (AI) is transforming software development and testing. Discover how AI-powered tools are revolutionizing every stage of the software development lifecycle (SDLC), from design and prototyping to testing, deployment, and monitoring.
Learn about:
• The Future of Testing: How AI is shifting testing towards verification, analysis, and higher-level skills, while reducing repetitive tasks.
• Test Automation: How AI-powered test case generation, optimization, and self-healing tests are making testing more efficient and effective.
• Visual Testing: Explore the emerging capabilities of AI in visual testing and how it's set to revolutionize UI verification.
• Inflectra's AI Solutions: See demonstrations of Inflectra's cutting-edge AI tools like the ChatGPT plugin and Azure Open AI platform, designed to streamline your testing process.
Whether you're a developer, tester, or QA professional, this webinar will give you valuable insights into how AI is shaping the future of software delivery.
3. Program Order: Execution Order (maybe):
int w = 10; int x = 20;
int x = 20; int y = 30;
int y = 30; int b = x * y;
int z = 40;
int w = 10;
int a = w + z; int z = 40;
int b = x * y; int a = w + z;
6. static long foo = 0;
private static void increment() {
for (long l = 0; l < 500000000L; l++) {
foo++;
}
}
7. public static long foo = 0;
public static Lock lock = new Lock();
private static void increment() {
for (long l = 0; l < 500000000L; l++){
lock.lock();
try {
foo++;
} finally {
lock.unlock();
}
}
}
8. static AtomicLong foo = new AtomicLong(0);
private static void increment() {
for (long l = 0; l < 500000000L; l++) {
foo.getAndIncrement();
}
}
9. Cost of Contention
Increment a counter 500 000 000 times.
• One Thread : 300 ms
10. Cost of Contention
Increment a counter 500 000 000 times.
• One Thread : 300 ms
• One Thread (volatile): 4 700 ms (15x)
11. Cost of Contention
Increment a counter 500 000 000 times.
• One Thread : 300 ms
• One Thread (volatile): 4 700 ms (15x)
• One Thread (Atomic) : 5 700 ms (19x)
12. Cost of Contention
Increment a counter 500 000 000 times.
• One Thread : 300 ms
• One Thread (volatile): 4 700 ms (15x)
• One Thread (Atomic) : 5 700 ms (19x)
• One Thread (Lock) : 10 000 ms (33x)
13. Cost of Contention
Increment a counter 500 000 000 times.
• One Thread : 300 ms
• One Thread (volatile): 4 700 ms (15x)
• One Thread (Atomic) : 5 700 ms (19x)
• One Thread (Lock) : 10 000 ms (33x)
• Two Threads (Atomic) : 30 000 ms (100x)
14. Cost of Contention
Increment a counter 500 000 000 times.
• One Thread : 300 ms
• One Thread (volatile): 4 700 ms (15x)
• One Thread (Atomic) : 5 700 ms (19x)
• One Thread (Lock) : 10 000 ms (33x)
• Two Threads (Atomic) : 30 000 ms (100x)
• Two Threads (Lock) : 224 000 ms (746x)
^^^^^^^^
~4 minutes!!!
15. Parallel v. Serial - String Split
Guy Steele @ Strangle Loop:
http://www.infoq.com/presentations/Thinking-Parallel-
Programming
Scala Implementation and Brute Force version in Java:
https://github.com/mikeb01/folklore/
15
16. Parallel (Scala) Serial (Java)
2000.0
1500.0
1000.0
500.0
0
String Split (ops/sec) higher is better
27. How Fast Is It - Throughput
ABQ Disruptor
30000000.0
22500000.0
15000000.0
7500000.0
0
Unicast Diamond
27
28. How Fast Is It - Latency
ABQ Disruptor
Min 145 29
Mean 32,757 52
99 Percentile 2,097,152 128
99.99 Percentile 4,194,304 8,192
Max 5,069,086 175,567
28
33. Look Ma’ No Memory Barrier
AtomicLong sequence = new AtomicLong(-1);
public void publish(Object value) {
long index = ++nextValue;
data[(int)(index % SIZE)] = value;
sequence.lazySet(index);
}
33
35. Cache Line Padding
public class PaddedAtomicLong extends AtomicLong {
public volatile long p1, p2, p3, p4, p5, p6 = 7L;
//... lines omitted
public long sumPaddingToPreventOptimisation() {
return p1 + p2 + p3 + p4 + p5 + p6;
}
}
35
36. Summary
• Concurrency is a tool
• Ordering and visibility are the key challenges
• For performance the details matter
• Don't believe everything you read
o Come up with your own theories and test them!
36
(Trish)\n\nIntroduce ourselves, mention the award :)\n\n&#x201C;Duke's Choice Award for&#xA0;Innovative Programming Framework&#x201D;\n\nIntroduce what we&#x2019;re going to cover\n - concurrency/performance\n - deep & narrow\n - contradictory - going to argue against abstractions\n
(Trish)\n\nAll of the ask the audience questions:\n\n- Who works with concurrent code daily?\n- Who finds concurrency difficult?\n- Who cares about performance?\n\n
(Trish)\n\nCompilers and CPUs are allowed to reorder instructions as long as program semantics are maintained. &#xA0;Without any explicit requests those correctness semantics are limited to observers in the same thread.\n\nDifferent CPUs reorder&#xA0;instructions&#xA0;to varying degrees. &#xA0;E.g. Intel x86 not much, DEC Alpha lots, Intel Atom not at all.\n\nUnless explicit instructions are used to ensure ordering observers in another thread will see different results. &#xA0;I.e. a separate thread can't assume that because z = 40 is true, x = 20 is also true. &#xA0;It may not have happened yet.\n\nThat's if the other thread can even see the data, throw to next slide on visibility.\n\n1) Compilers and CPUs are free to re-order instructions\n2) Different CPUs reorder different amounts - intel x86 not much\n3) unless otherwise specified, you can only guarantee ordering within same thread\n4) other thread can't guarantee order. x is not necessarily 20. if it's even visible\n\n
(Trish)\n\nMemory on modern CPUs consists of multiple layers of buffering and caching. &#xA0;Storing a value does not mean that it is immediately visible to all threads running on all cores.\n\nExplicit instructions are needed to make data&#xA0;visible&#xA0;to other threads.\n\nThis is the crux of why concurrency is hard. &#xA0;The logical order of your program is not maintained when&#xA0;observing&#xA0;it from another thread (but sometimes it is).\n\nThere are tools to help reason about concurrent programs, the main one is the Memory Model. Memory Models exist at multiple levels langauge, VM and CPUs all can have memory models. &#xA0;Java fortunately has a good one which is portable. &#xA0;C++ only introduced one in the most recent spec. &#xA0;C++ programmers often had to think about the CPUs memory model more often (though there are helpful libraries and compiler&#xA0;intrinsics&#xA0;too).\n\nReordering and smart use of caching is the result of many years of hardware engineering applied to deal with the signficant performance mismatch between the CPU and accessing Memory.\n\nHowever correctness is not the only concern, a lack of understanding of the detail can lead to other problems...(thow to Mike).\n\n1) different layers of storage on modern cpu (explain diag)\n2) the different levels exist because main memory is slow\n3) data for your instruction could be at any of these levels. &#xA0;threads on a different CPU might not see it\n4) Java Memory Model is a good tool to reason about concurrent programming, and it's cross platform\n
(Mike)\n\nAre we taking a step back (Martijn)? &#xA0;Yes, necessarily so. Parallelism and concurrency are means to an end, not an end in their own right. &#xA0;The goal being performance. &#xA0;Performance generally covers throughput, latency, scalability. &#xA0;I'd through in 4th, energy efficiency. Concurrent code can bring with it a number of performance surprises, let's look an example.\n\n
\n
\n
\n
\n
\n
\n
\n
\n
(Mike)\n\nUp to 3 orders of magnitude difference in performance between best and worst case. Important to understand what's happening at the lower layers to &#xA0;understand why code can perform poorly. Understanding the details of how concurrency works at the machine level makes understanding higher level concurrency models (e.g. Clojure STM, Queues, Actors) much easier. Locks require kernal arbitration. The Disruptor looks to remove as much contention as possible.\n
(Mike)\n\nDon't be scared of putting code into a single thread. Ported Guy Steele's algorithm written in Fortress to Scala and compared it to a brute single threaded implementation. Use Scala's new parallel collections library. Not too much detail on the algorithm, based on divide/conqueor model to fit easily with fork/join.\n\n
(Mike)\n\nTested with a copy of Alice in Wonderland. Guess how many cores used to get 440 ops/sec? &#xA0;8 cores with hyper-threading - 16 concurrent threads. While eventually the Scala version would be faster, given enough cores it is horribly inefficient with its use of energy. This is likely to be more of an issue as we move into the future. Don't take this as a negative regarding Scala's parallel collections.\n\n
(Mike)\n\nCPU performance is more&#xA0;complicated&#xA0;than a simple measurement of GHz or number of cores. &#xA0;Many other factors come into place. &#xA0;Cache size, cache speed, bus architecture, data path sizes, numbers of caches.....\n
\n
(Trish)\n\nIntro to lmax\nReal world problems\nDR / replication, high availability\n\n
(Trish)\n\nSEDA Architecture. A real enterprise solution needs more than just business logic. DR, journalling - gives you reliability\n\nThis is a single service. Business logic is the interesting thing.\n\n
(Trish)\n\n- Testing showed each queue had its own latency overhead. \n- When you add it all up, even including your IO for replication and journalling, it's a big chunk of overall latency.\n- Business logic is such a tiny amount of time\n\n
\n
\n
\n
(Trish)\n\nIntroduce the Ring buffer, talk about how this is the basis of the Disruptor\n\nAll event processors own their own sequence numbers. Producer writes to ringbuffer, which updates its sequence number. Consumer reads from ring buffer, and writes to its own sequence number\n\n1) RingBuffer/Disruptor intro\n2) Producer writes, consumer reads\n3) Individual sequence numbers\n\n
(Trish)\n\nNote that things can now be parallelised\n\n
\n
\n
Diving in deep! If assembly code scares you, go get beer now\n\n
\n
\n
(Mike)\n\nIntel doesn't need a&#xA0;special&#xA0;instruction for volatile reads. &#xA0;Just ensures that it is not stored in a register and that the write takes care of the cache invalidation. &#xA0;Doesn't reorder reads with respect to each other. &#xA0;Intel has a strong memory model. &#xA0;Other CPU would require fence instructions on the read too.\n\n*notes from Brown bag*\nFriendlier comment/java code\ntalk about where cache lines are flushed\ntalk about number of cycles\n\n
(Trish)\n(Still not sure about this, doesn't make it clear where the sequence number is)\n\ncreate a bunch of empty longs to pad out the cache line\nadd them to a public method so they don't get optimised away\n\nsee our shiny method names\n\n
Concurrency is a good way to make your code slower and more complex.\n