This document presents various patterns for building resilience into systems. It discusses core architectural patterns like isolation, loose coupling, and latency control. It also covers detection/treatment patterns like monitoring, circuit breakers, and retries. Prevention patterns include redundancy, idempotency, and error handling. Recovery/mitigation patterns include rollback, failover, read repair, and shedding load. The document provides examples and explanations of these patterns.
The Ring programming language version 1.5.3 book - Part 78 of 184Mahmoud Samir Fayed
This document contains code for a notepad application user interface created with the Ring programming language. It defines functions for creating the main window, menu bar, toolbars, dock widgets, and text editor. It also includes functions for common editing actions like opening, saving, printing files and performing search/replace.
financial analytics of AAPL_stock marketssarath Kumar
This document contains a dataset of stock market data for Apple (AAPL) from 2016 to 2017 that includes date, open, high, low, close, volume and other technical indicators. The data is read in from a CSV file, assigned column names and the date column is converted to an integer for analysis. No analysis is performed on the data in this document, it is solely for loading and preparing the stock market dataset.
Cloud native applications are popular these days – applications that run in the cloud reliably und scale almost arbitrarily. They follow three key principles: They are built and composed as microservices, they are packaged and distributed in containers and the containers are executed dynamically in the cloud. In this hands-on session we will show how to build, package and deploy cloud native Java EE applications on top of DC/OS - fully automated with Gradle using cloud native infrastructure like Consul, Fabio, Hystrix and Prometheus. And for the fun of it we will be using an off-the-shelf DJ pad, programmed with nothing else than the Java Sound API, to demonstrate the core concepts and to visualize and remote control DC/OS.
The Ring programming language version 1.3 book - Part 51 of 88Mahmoud Samir Fayed
The document describes a Ring programming language code for creating a basic notepad application with a graphical user interface (GUI). It includes code to:
- Create the main window with menus, toolbars, dock widgets for files/project, source code, and web browser
- Add buttons and menu options for common file operations like new, open, save, print, cut, copy, paste
- Display the file contents in a text editor widget
- Allow searching/replacing text and going to a specific line
- Include a basic web browser functionality to load URLs
The Ring programming language version 1.5.1 book - Part 66 of 180Mahmoud Samir Fayed
The document describes functions and methods for a card game application in Ring. It includes functions for player clicks, eating cards, checking for a new game, and delaying actions. Methods are provided to handle clicks for players 1 and 2, allow players to eat cards of the same value, increment player scores, and check if the game is over by seeing if any cards remain. The application uses GUI elements like buttons and labels to display the game and scores to players.
Testing multi outputformat based mapreduceAshok Agarwal
The document describes using a MultiOutputFormat in MapReduce to generate separate output files for each stock price based on input that contains stock price data. It includes code for a mapper that extracts the stock name and price from each input record and a reducer that writes these values to individual files for each stock name. Unit tests are also described to test the reducer by mocking the MultipleOutputs class and validating that the output files contain the expected stock price values.
The Ring programming language version 1.5.3 book - Part 78 of 184Mahmoud Samir Fayed
This document contains code for a notepad application user interface created with the Ring programming language. It defines functions for creating the main window, menu bar, toolbars, dock widgets, and text editor. It also includes functions for common editing actions like opening, saving, printing files and performing search/replace.
financial analytics of AAPL_stock marketssarath Kumar
This document contains a dataset of stock market data for Apple (AAPL) from 2016 to 2017 that includes date, open, high, low, close, volume and other technical indicators. The data is read in from a CSV file, assigned column names and the date column is converted to an integer for analysis. No analysis is performed on the data in this document, it is solely for loading and preparing the stock market dataset.
Cloud native applications are popular these days – applications that run in the cloud reliably und scale almost arbitrarily. They follow three key principles: They are built and composed as microservices, they are packaged and distributed in containers and the containers are executed dynamically in the cloud. In this hands-on session we will show how to build, package and deploy cloud native Java EE applications on top of DC/OS - fully automated with Gradle using cloud native infrastructure like Consul, Fabio, Hystrix and Prometheus. And for the fun of it we will be using an off-the-shelf DJ pad, programmed with nothing else than the Java Sound API, to demonstrate the core concepts and to visualize and remote control DC/OS.
The Ring programming language version 1.3 book - Part 51 of 88Mahmoud Samir Fayed
The document describes a Ring programming language code for creating a basic notepad application with a graphical user interface (GUI). It includes code to:
- Create the main window with menus, toolbars, dock widgets for files/project, source code, and web browser
- Add buttons and menu options for common file operations like new, open, save, print, cut, copy, paste
- Display the file contents in a text editor widget
- Allow searching/replacing text and going to a specific line
- Include a basic web browser functionality to load URLs
The Ring programming language version 1.5.1 book - Part 66 of 180Mahmoud Samir Fayed
The document describes functions and methods for a card game application in Ring. It includes functions for player clicks, eating cards, checking for a new game, and delaying actions. Methods are provided to handle clicks for players 1 and 2, allow players to eat cards of the same value, increment player scores, and check if the game is over by seeing if any cards remain. The application uses GUI elements like buttons and labels to display the game and scores to players.
Testing multi outputformat based mapreduceAshok Agarwal
The document describes using a MultiOutputFormat in MapReduce to generate separate output files for each stock price based on input that contains stock price data. It includes code for a mapper that extracts the stock name and price from each input record and a reducer that writes these values to individual files for each stock name. Unit tests are also described to test the reducer by mocking the MultipleOutputs class and validating that the output files contain the expected stock price values.
This document discusses CQRS and CQS patterns for domain-driven design (DDD). It begins by clarifying the terms CQRS and CQS, explaining that CQRS involves separating reads from writes while CQS involves separating queries from commands. The document then provides an example DDD model of a cinema domain and discusses applying CQS principles by having separate query and command classes, services, and handlers. It emphasizes using lightweight data access for queries to return only needed data and avoiding repositories for queries. The document concludes by discussing some considerations for applying CQS for DDD.
RAPIDS: ускоряем Pandas и scikit-learn на GPU Павел Клеменков, NVidiaMail.ru Group
Все мы знаем, что наш любимый Pandas исключительно однопоточный, а модели из scikit-learn часто учатся не очень быстро даже в несколько процессов. Поэтому в докладе я расскажу о проекте RAPIDS - наборе библиотек для анализа данных и построения предиктивных моделей с использованием NVIDIA GPU. В докладе я предложу подискутировать о том, что закон Мура больше не выполняется, рассмотрю принципы работы архитектуры CUDA. Разберу библиотеки cuDF и cuML, а также постараюсь предельно честно рассказать о том, ждать ли чуда от перехода на GPU и в каких случаях чудо неизбежно.
This document discusses CQS (Command Query Separation) and how it can be applied to Domain-Driven Design (DDD). It begins by clarifying the terms CQRS and CQS, explaining that CQS is a design principle where methods are either queries that return data without modifying state, or commands that change state without returning data. The document then provides an example DDD model and discusses how to apply CQS by separating queries from commands. Queries are handled by simple data access objects while commands are handled by request/response message handlers. Other tips discussed include using lazy loading cautiously and considering Interaction Driven Design. The document concludes by opening the discussion to questions.
There are three levels of tracing in Vertica: Select, Session, and System. The Select level traces a single statement, Session traces all statements in a session, and System traces all queries across sessions. The trace output populates tables with query metadata and execution details. A long-running query was identified and traced to a costly GroupByHash operator. Creating a projection to presort the data enabled pipelining between operators, improving performance by 85%.
A lot of data is best represented as time series: Operational data, financial data, and even in data warehouses the dominant dimension is often time. We present Chronix, a time series database based on Apache Solr and Spark which is able to handle trillions of time series data points and perform interactive queries. Chronix Spark is open source software and battle-proven at a German car manufacturer and an international telco.
We demonstrate several use cases of Chronix from real-life. Afterwards we lift the curtain and deep-dive into the Chronix architecture esp. how we're using Solr to store time series data and how we've hooked up Solr with Spark. We provide some benchmarks showing how Chronix has outperformed other time series databases in both performance and storage-efficiency.
Chronix is open source under the Apache License (http://chronix.io).
The document discusses the tools Spock and Geb for testing in Groovy. It provides arguments for why to use Spock, describes the Given-When-Then structure in Spock tests, and covers Spock blocks, lifecycles, mocking, and the four phases of testing.
The document discusses issues with testing business logic in Orleans grains that access grain state. Specifically, the business logic code is duplicated across grain methods and calling the logic directly in tests fails because the grain state is null. The solution is to use Orleans' declarative persistence by defining a grain state interface and inheriting from Grain, which allows the state to be initialized for tests.
Parallel computing allows breaking problems into independent pieces that can be computed simultaneously across multiple processors. The document discusses using the snow package in R to set up a simple parallel cluster on a single machine and perform operations like bootstrapping in parallel. It also mentions more advanced high performance computing techniques for large memory, compiled code, profiling, and batch scheduling.
This document discusses various optimizations and improvements made to Java streams in recent versions. It provides examples of counting large streams, converting streams to arrays, collecting to lists, sorting, skipping elements, and using streams in parallel pipelines. It also covers characteristics of streams like SIZED, ORDERED, DISTINCT, and how operations like distinct(), skip(), and concat() perform in parallel scenarios. Overall it analyzes the performance of core stream operations and how their implementations have evolved.
Undoing Event-driven Adaptation of Business ProcessesSébastien Mosser
This document discusses undoing event-driven adaptations of business processes. It proposes automated unadaptation by identifying the triggering event, correlated adaptations, and yielding the system as if the adaptation never occurred. A demonstration shows events triggering adaptations, then automated unadaptation identifying the trigger, pruning correlated changes, and replaying the process. The approach aims to avoid corrupted processes from naive unadaptation and supports platform-independent unadaptation of running process instances over time.
The document discusses various patterns for building resilience into systems, including isolation, loose coupling, asynchronous communication, statelessness, and others. It defines resilience as the ability to recover from failures or adversity. For each pattern, it provides a definition and example of how the pattern contributes to resilience. The goal is to describe techniques that systems can use to detect failures, recover from them, and continue operating without downtime.
Fault tolerance in general is a challenging topic. Yet we need fault toleranct designs more badly than ever in order to provide robust, highly available systems - especially in times of scale out systems becoming more and more popular.
Unfortunately, most developers do not care too much about a fault tolerant design, either because they are scared by the complexity of the realm or because they do not care enough. One of the problems is that a lack of fault tolerant design does not hurt a lot in development or in QA, but it hurts a lot in production - as Michael Nygard said: "It's all about production!" (at least figuratively).
In this presentation I do *not* try to give a general introduction to fault tolerant design. Instead I pick a few generic case studies that demonstrate the results of missing fault tolerant design, try to sensitize a bit about the production relevance of fault tolerant design and then go along with a few selected patterns. I picked a few patterns which are surprisingly easy to implement and help to mitigate the problems of the former case studies.
This way I try to show two things:
1. A piece of architecture or design as a pattern is not necessarily hard to implement. Sometimes the code is written quicker than it takes to explain the pattern beforehand.
2. Even if fault tolerant design as a general topic might be hard, some parts of it can be implemented very easily and it's more than worth the coding effort if you look how much better your system behaves in production just from adding those few lines of code.
Azure Durable Funkiness - .NET Oxford June 2018Stuart Leeks
This document discusses the evolution of asynchronous and parallel programming in C# code. It begins by covering synchronous code examples. It then covers asynchronous programming using async/await. Examples of parallel programming by starting multiple asynchronous tasks concurrently are also provided. The document then introduces Azure Durable Functions as a way to distribute asynchronous and parallel code across multiple servers. It provides examples of common Durable Functions patterns like chaining functions, fan-out/fan-in, external events, and timers. Overall it shows how programming models have evolved from synchronous to asynchronous to parallel and now to distributed using serverless platforms like Durable Functions.
The document discusses various features and capabilities of PHPUnit for testing PHP code. It covers command line options for PHPUnit like filters and coverage reports. It also covers different types of assertions for validating test expectations, using annotations to organize tests, and special tests for things like exceptions. The document aims to explain some of the more advanced but lesser known aspects of using PHPUnit for testing.
Immutable infrastructure - Beyond statelessJorge Dias
This talk is structured in 2 parts, the first is an introduction to immutable infrastructures, what it is, advantages and disadvantages and architecture requirements for applications. In the second part I'll explain how we apply those principles at the storage team by Schibsted for our stateful services to provide a managed database offering for multiple customers. The use cases will be based on Cassandra, Kafka and zookeeper which we currently support in many clusters in production.
The Ring programming language version 1.10 book - Part 94 of 212Mahmoud Samir Fayed
The document describes the Trace Library in Ring and how it can be used to trace program execution, debug code, and step through a program line by line. It provides examples of loading the Trace Library, tracing all events, tracing control flow between functions, and using the pass error functionality to continue execution after an error. Key functions and capabilities of the Trace Library discussed include tracing specific events, setting breakpoints, accessing trace data, and redefining see and give behavior.
The document discusses asynchronous and non-blocking I/O with JRuby. It explains that asynchronous operations are better than synchronous operations because they use fewer resources and allow for parallelism. It provides an example of building a JRuby application with the Ratpack framework that makes asynchronous HTTP requests to eBay's API in a non-blocking way using promises. It also discusses using RxJava and Hystrix with Ratpack to build a book management application that handles data and API requests asynchronously.
A lot of people using PHPunit for testing their source code. While I was observing my team
I recognized most of them are only using the standard ssertions like 'assertEquals()' or
'assertTrue()' and are complaining about how hard it is to test the code even when the tests are written first. This talk is about all the stuff not used on a daily basis. It shows you some nice features of PHPUnit and how to use them for your benefit.
The document discusses reactive programming and how it can be used on Android. It explains that reactive programming uses observable sequences and asynchronous data flows. It introduces RxJava as a library for reactive programming that uses Observables to compose flows of asynchronous data. It provides examples of how RxJava can be used on Android to perform background tasks, handle errors and activity lifecycles, load images asynchronously, and create and transform Observables.
Since it’s introduction over 20 years ago, Java developers have had plenty of strong and often opposing ways of doing things.
Modern day JVM development has only added more options, more divisiveness, and even more heated arguments.
* Constructor or Setter Injection ?
* Dynamic or Static typing ?
* Monolithic or Micro-service application design ?
* Java or Scala or Kotlin ?
* JVM or .NET ?
* Reactive ?
* Are Mutable types and Threads inherently Evil?
* Is Kubernetes / Docker the modern way of JVM deployments?
Let’s dive into these and other issues .. while also stepping back and looking at the Bigger Picture:
What is it really about these choices that improve the bottom line ?
Most importantly .. let’s also settle once and for all:
Maven or Gradle?
The document discusses ReactiveUI, a framework that uses reactive programming principles to build reactive UIs. It introduces key ReactiveUI concepts like ReactiveObjects and ReactiveCommands that make view models and commands reactive. Key Rx operators like Select, Where, and Subscribe are demonstrated for projecting and subscribing to observable sequences. The benefits of reactive programming with ReactiveUI are loosely coupled code, easier event handling through observables, and better testability.
This document discusses CQRS and CQS patterns for domain-driven design (DDD). It begins by clarifying the terms CQRS and CQS, explaining that CQRS involves separating reads from writes while CQS involves separating queries from commands. The document then provides an example DDD model of a cinema domain and discusses applying CQS principles by having separate query and command classes, services, and handlers. It emphasizes using lightweight data access for queries to return only needed data and avoiding repositories for queries. The document concludes by discussing some considerations for applying CQS for DDD.
RAPIDS: ускоряем Pandas и scikit-learn на GPU Павел Клеменков, NVidiaMail.ru Group
Все мы знаем, что наш любимый Pandas исключительно однопоточный, а модели из scikit-learn часто учатся не очень быстро даже в несколько процессов. Поэтому в докладе я расскажу о проекте RAPIDS - наборе библиотек для анализа данных и построения предиктивных моделей с использованием NVIDIA GPU. В докладе я предложу подискутировать о том, что закон Мура больше не выполняется, рассмотрю принципы работы архитектуры CUDA. Разберу библиотеки cuDF и cuML, а также постараюсь предельно честно рассказать о том, ждать ли чуда от перехода на GPU и в каких случаях чудо неизбежно.
This document discusses CQS (Command Query Separation) and how it can be applied to Domain-Driven Design (DDD). It begins by clarifying the terms CQRS and CQS, explaining that CQS is a design principle where methods are either queries that return data without modifying state, or commands that change state without returning data. The document then provides an example DDD model and discusses how to apply CQS by separating queries from commands. Queries are handled by simple data access objects while commands are handled by request/response message handlers. Other tips discussed include using lazy loading cautiously and considering Interaction Driven Design. The document concludes by opening the discussion to questions.
There are three levels of tracing in Vertica: Select, Session, and System. The Select level traces a single statement, Session traces all statements in a session, and System traces all queries across sessions. The trace output populates tables with query metadata and execution details. A long-running query was identified and traced to a costly GroupByHash operator. Creating a projection to presort the data enabled pipelining between operators, improving performance by 85%.
A lot of data is best represented as time series: Operational data, financial data, and even in data warehouses the dominant dimension is often time. We present Chronix, a time series database based on Apache Solr and Spark which is able to handle trillions of time series data points and perform interactive queries. Chronix Spark is open source software and battle-proven at a German car manufacturer and an international telco.
We demonstrate several use cases of Chronix from real-life. Afterwards we lift the curtain and deep-dive into the Chronix architecture esp. how we're using Solr to store time series data and how we've hooked up Solr with Spark. We provide some benchmarks showing how Chronix has outperformed other time series databases in both performance and storage-efficiency.
Chronix is open source under the Apache License (http://chronix.io).
The document discusses the tools Spock and Geb for testing in Groovy. It provides arguments for why to use Spock, describes the Given-When-Then structure in Spock tests, and covers Spock blocks, lifecycles, mocking, and the four phases of testing.
The document discusses issues with testing business logic in Orleans grains that access grain state. Specifically, the business logic code is duplicated across grain methods and calling the logic directly in tests fails because the grain state is null. The solution is to use Orleans' declarative persistence by defining a grain state interface and inheriting from Grain, which allows the state to be initialized for tests.
Parallel computing allows breaking problems into independent pieces that can be computed simultaneously across multiple processors. The document discusses using the snow package in R to set up a simple parallel cluster on a single machine and perform operations like bootstrapping in parallel. It also mentions more advanced high performance computing techniques for large memory, compiled code, profiling, and batch scheduling.
This document discusses various optimizations and improvements made to Java streams in recent versions. It provides examples of counting large streams, converting streams to arrays, collecting to lists, sorting, skipping elements, and using streams in parallel pipelines. It also covers characteristics of streams like SIZED, ORDERED, DISTINCT, and how operations like distinct(), skip(), and concat() perform in parallel scenarios. Overall it analyzes the performance of core stream operations and how their implementations have evolved.
Undoing Event-driven Adaptation of Business ProcessesSébastien Mosser
This document discusses undoing event-driven adaptations of business processes. It proposes automated unadaptation by identifying the triggering event, correlated adaptations, and yielding the system as if the adaptation never occurred. A demonstration shows events triggering adaptations, then automated unadaptation identifying the trigger, pruning correlated changes, and replaying the process. The approach aims to avoid corrupted processes from naive unadaptation and supports platform-independent unadaptation of running process instances over time.
The document discusses various patterns for building resilience into systems, including isolation, loose coupling, asynchronous communication, statelessness, and others. It defines resilience as the ability to recover from failures or adversity. For each pattern, it provides a definition and example of how the pattern contributes to resilience. The goal is to describe techniques that systems can use to detect failures, recover from them, and continue operating without downtime.
Fault tolerance in general is a challenging topic. Yet we need fault toleranct designs more badly than ever in order to provide robust, highly available systems - especially in times of scale out systems becoming more and more popular.
Unfortunately, most developers do not care too much about a fault tolerant design, either because they are scared by the complexity of the realm or because they do not care enough. One of the problems is that a lack of fault tolerant design does not hurt a lot in development or in QA, but it hurts a lot in production - as Michael Nygard said: "It's all about production!" (at least figuratively).
In this presentation I do *not* try to give a general introduction to fault tolerant design. Instead I pick a few generic case studies that demonstrate the results of missing fault tolerant design, try to sensitize a bit about the production relevance of fault tolerant design and then go along with a few selected patterns. I picked a few patterns which are surprisingly easy to implement and help to mitigate the problems of the former case studies.
This way I try to show two things:
1. A piece of architecture or design as a pattern is not necessarily hard to implement. Sometimes the code is written quicker than it takes to explain the pattern beforehand.
2. Even if fault tolerant design as a general topic might be hard, some parts of it can be implemented very easily and it's more than worth the coding effort if you look how much better your system behaves in production just from adding those few lines of code.
Azure Durable Funkiness - .NET Oxford June 2018Stuart Leeks
This document discusses the evolution of asynchronous and parallel programming in C# code. It begins by covering synchronous code examples. It then covers asynchronous programming using async/await. Examples of parallel programming by starting multiple asynchronous tasks concurrently are also provided. The document then introduces Azure Durable Functions as a way to distribute asynchronous and parallel code across multiple servers. It provides examples of common Durable Functions patterns like chaining functions, fan-out/fan-in, external events, and timers. Overall it shows how programming models have evolved from synchronous to asynchronous to parallel and now to distributed using serverless platforms like Durable Functions.
The document discusses various features and capabilities of PHPUnit for testing PHP code. It covers command line options for PHPUnit like filters and coverage reports. It also covers different types of assertions for validating test expectations, using annotations to organize tests, and special tests for things like exceptions. The document aims to explain some of the more advanced but lesser known aspects of using PHPUnit for testing.
Immutable infrastructure - Beyond statelessJorge Dias
This talk is structured in 2 parts, the first is an introduction to immutable infrastructures, what it is, advantages and disadvantages and architecture requirements for applications. In the second part I'll explain how we apply those principles at the storage team by Schibsted for our stateful services to provide a managed database offering for multiple customers. The use cases will be based on Cassandra, Kafka and zookeeper which we currently support in many clusters in production.
The Ring programming language version 1.10 book - Part 94 of 212Mahmoud Samir Fayed
The document describes the Trace Library in Ring and how it can be used to trace program execution, debug code, and step through a program line by line. It provides examples of loading the Trace Library, tracing all events, tracing control flow between functions, and using the pass error functionality to continue execution after an error. Key functions and capabilities of the Trace Library discussed include tracing specific events, setting breakpoints, accessing trace data, and redefining see and give behavior.
The document discusses asynchronous and non-blocking I/O with JRuby. It explains that asynchronous operations are better than synchronous operations because they use fewer resources and allow for parallelism. It provides an example of building a JRuby application with the Ratpack framework that makes asynchronous HTTP requests to eBay's API in a non-blocking way using promises. It also discusses using RxJava and Hystrix with Ratpack to build a book management application that handles data and API requests asynchronously.
A lot of people using PHPunit for testing their source code. While I was observing my team
I recognized most of them are only using the standard ssertions like 'assertEquals()' or
'assertTrue()' and are complaining about how hard it is to test the code even when the tests are written first. This talk is about all the stuff not used on a daily basis. It shows you some nice features of PHPUnit and how to use them for your benefit.
The document discusses reactive programming and how it can be used on Android. It explains that reactive programming uses observable sequences and asynchronous data flows. It introduces RxJava as a library for reactive programming that uses Observables to compose flows of asynchronous data. It provides examples of how RxJava can be used on Android to perform background tasks, handle errors and activity lifecycles, load images asynchronously, and create and transform Observables.
Since it’s introduction over 20 years ago, Java developers have had plenty of strong and often opposing ways of doing things.
Modern day JVM development has only added more options, more divisiveness, and even more heated arguments.
* Constructor or Setter Injection ?
* Dynamic or Static typing ?
* Monolithic or Micro-service application design ?
* Java or Scala or Kotlin ?
* JVM or .NET ?
* Reactive ?
* Are Mutable types and Threads inherently Evil?
* Is Kubernetes / Docker the modern way of JVM deployments?
Let’s dive into these and other issues .. while also stepping back and looking at the Bigger Picture:
What is it really about these choices that improve the bottom line ?
Most importantly .. let’s also settle once and for all:
Maven or Gradle?
The document discusses ReactiveUI, a framework that uses reactive programming principles to build reactive UIs. It introduces key ReactiveUI concepts like ReactiveObjects and ReactiveCommands that make view models and commands reactive. Key Rx operators like Select, Where, and Subscribe are demonstrated for projecting and subscribing to observable sequences. The benefits of reactive programming with ReactiveUI are loosely coupled code, easier event handling through observables, and better testability.
Java 7 introduced several new features including the diamond operator <> for type inference, strings in switch statements, automatic resource management using try-with-resources, numeric literals with underscores, binary literals, improved exception handling with multi-catch blocks, NIO 2.0 for file I/O, and the Fork/Join framework for parallel programming.
The document discusses Google App Engine task queues and cron jobs. It provides examples of creating and using default and named push queues, as well as pull queues. It explains how to add tasks, lease tasks from pull queues, and delete tasks. It also covers using task queues within transactions. Additionally, it demonstrates configuring and using cron jobs to schedule recurring tasks.
'Premature optimisation is the root of all evil', Donald Knuth told us in 1974. He was talking about the perceived trade-off between optimising performance and keeping code readable and maintainable. And we all know that we shouldn't even try optimising anything without measuring if there's an actual bottleneck in our product first. Or do we?
Making something faster, even at the micro-level, doesn't always mean that readability suffers. There are a lot of improvements that make code both more readable and better-performing, turning what might be called premature optimisation into just another healthy refactoring. And although some developers like to label almost all forms of optimisation as premature, this depends on a lot of factors, and designing for performance might actually be important for the product you are building. Let us also not forget that optimising, even prematurely, can be a lot of fun!
In this workshop we take a look at examples of optimisations that make sense to both the reader and the end-user of code. We also let ourselves go and prematurely optimise the heck out of some (C++ and Python) code, so make sure to bring your laptop if you have one!
Slides for my k6 load testing presentation at Confoo 2023 in Montreal Canada.
See https://feryn.eu/speaking/distributed-load-testing-k6-confoo23/ for more information.
This document provides examples of functions in Clojure and summaries of testing tools Midje. It shows:
1. Examples of Clojure functions like areduce to apply an expression to array elements, with-precision to set decimal precision, and with-redefs to temporarily mock function values.
2. A brief overview of the Midje testing tool, including using facts to make tests more readable based on assertions, the syntax using midje.sweet, and features like metaconstants and checkers.
3. How to use Midje with a Clojure project including creating a new project, adding a tasks file, writing tests, and mixing deftest functions with facts.
The document discusses performance testing and summarizes that:
1. Performance tests should closely simulate production environments including hardware, software, load, and isolation.
2. Extensive monitoring, logging, and profiling data should be collected to identify bottlenecks based on data rather than intuition.
3. Performance testing can be misleading without sufficient data due to issues like coordinated omission, so tools like Gatling and WRK2 that avoid this problem are recommended.
During past years, the requirements for modern applications have increased from gigabytes of data to terabytes, from thousands of requests per second to millions, from seconds of response time to milliseconds, and this list can be continued. Until now, most of these problems have been solved using the Microservices architecture, but what's next? What next approach should we apply where Microservices fail? In this presentation, we will overview modern approaches to application development with Reactive and Distributed architecture and see how Vert.x help to implement such solutions.
Guava Overview. Part 1 @ Bucharest JUG #1 Andrei Savu
Guava is a Java library developed by Google that includes common libraries such as collections, caching, primitives support, concurrency libraries, and generalized utility classes. The talk covered the basic utilities in Guava including using and avoiding null, preconditions, common object utilities, ordering, and primitive array utilities. It also discussed the collections in Guava including immutable collections, new collection types like multisets and multimaps, collection utilities, and ways to extend the collections framework with decorators.
Baha Majid WCA4Z IBM Z Customer Council Boston June 2024.pdfBaha Majid
IBM watsonx Code Assistant for Z, our latest Generative AI-assisted mainframe application modernization solution. Mainframe (IBM Z) application modernization is a topic that every mainframe client is addressing to various degrees today, driven largely from digital transformation. With generative AI comes the opportunity to reimagine the mainframe application modernization experience. Infusing generative AI will enable speed and trust, help de-risk, and lower total costs associated with heavy-lifting application modernization initiatives. This document provides an overview of the IBM watsonx Code Assistant for Z which uses the power of generative AI to make it easier for developers to selectively modernize COBOL business services while maintaining mainframe qualities of service.
Enhanced Screen Flows UI/UX using SLDS with Tom KittPeter Caitens
Join us for an engaging session led by Flow Champion, Tom Kitt. This session will dive into a technique of enhancing the user interfaces and user experiences within Screen Flows using the Salesforce Lightning Design System (SLDS). This technique uses Native functionality, with No Apex Code, No Custom Components and No Managed Packages required.
Implementing Odoo, a robust and all-inclusive business management software, can significantly improve your organisation. To get the most out of it and ensure a smooth implementation, it is important to have a strategic plan. This blog shares some essential tips to help you with successful Odoo ERP implementation. From planning and customisation to training and support, this blog outlines some expert advice that will guide you through the process confidently. It is true that adopting a new software can be challenging, and hence, this post has tailored these tips to help you avoid common mistakes and achieve the best results. Whether you run a small business or a large enterprise, these tips will help you streamline operations, boost productivity, and drive growth. Whether you are new to Odoo or looking to improve your current setup, it is essential to learn the key strategies for a successful Odoo implementation. Implementing Odoo doesn’t have to be difficult. With the right approach and guidance, you can use this software to elevate your business. Read on to discover the secrets of a successful Odoo implementation.
Why is successful Odoo implementation crucial?
Implementing Odoo effectively can transform your business by making processes smoother, increasing efficiency, and providing useful insights. It helps align your operations with best practices, boosting productivity and aiding better decision-making. A well-executed implementation ensures you get the most out of your investment, while a poor one can cause disruptions, higher costs, and frustration among employees.
Alluxio Webinar | 10x Faster Trino Queries on Your Data PlatformAlluxio, Inc.
Alluxio Webinar
June. 18, 2024
For more Alluxio Events: https://www.alluxio.io/events/
Speaker:
- Jianjian Xie (Staff Software Engineer, Alluxio)
As Trino users increasingly rely on cloud object storage for retrieving data, speed and cloud cost have become major challenges. The separation of compute and storage creates latency challenges when querying datasets; scanning data between storage and compute tiers becomes I/O bound. On the other hand, cloud API costs related to GET/LIST operations and cross-region data transfer add up quickly.
The newly introduced Trino file system cache by Alluxio aims to overcome the above challenges. In this session, Jianjian will dive into Trino data caching strategies, the latest test results, and discuss the multi-level caching architecture. This architecture makes Trino 10x faster for data lakes of any scale, from GB to EB.
What you will learn:
- Challenges relating to the speed and costs of running Trino in the cloud
- The new Trino file system cache feature overview, including the latest development status and test results
- A multi-level cache framework for maximized speed, including Trino file system cache and Alluxio distributed cache
- Real-world cases, including a large online payment firm and a top ridesharing company
- The future roadmap of Trino file system cache and Trino-Alluxio integration
Software Test Automation - A Comprehensive Guide on Automated Testing.pdfkalichargn70th171
Moving to a more digitally focused era, the importance of software is rapidly increasing. Software tools are crucial for upgrading life standards, enhancing business prospects, and making a smart world. The smooth and fail-proof functioning of the software is very critical, as a large number of people are dependent on them.
Building API data products on top of your real-time data infrastructureconfluent
This talk and live demonstration will examine how Confluent and Gravitee.io integrate to unlock value from streaming data through API products.
You will learn how data owners and API providers can document, secure data products on top of Confluent brokers, including schema validation, topic routing and message filtering.
You will also see how data and API consumers can discover and subscribe to products in a developer portal, as well as how they can integrate with Confluent topics through protocols like REST, Websockets, Server-sent Events and Webhooks.
Whether you want to monetize your real-time data, enable new integrations with partners, or provide self-service access to topics through various protocols, this webinar is for you!
How GenAI Can Improve Supplier Performance Management.pdfZycus
Data Collection and Analysis with GenAI enables organizations to gather, analyze, and visualize vast amounts of supplier data, identifying key performance indicators and trends. Predictive analytics forecast future supplier performance, mitigating risks and seizing opportunities. Supplier segmentation allows for tailored management strategies, optimizing resource allocation. Automated scorecards and reporting provide real-time insights, enhancing transparency and tracking progress. Collaboration is fostered through GenAI-powered platforms, driving continuous improvement. NLP analyzes unstructured feedback, uncovering deeper insights into supplier relationships. Simulation and scenario planning tools anticipate supply chain disruptions, supporting informed decision-making. Integration with existing systems enhances data accuracy and consistency. McKinsey estimates GenAI could deliver $2.6 trillion to $4.4 trillion in economic benefits annually across industries, revolutionizing procurement processes and delivering significant ROI.
Just like life, our code must adapt to the ever changing world we live in. From one day coding for the web, to the next for our tablets or APIs or for running serverless applications. Multi-runtime development is the future of coding, the future is to be dynamic. Let us introduce you to BoxLang.
Hyperledger Besu 빨리 따라하기 (Private Networks)wonyong hwang
Hyperledger Besu의 Private Networks에서 진행하는 실습입니다. 주요 내용은 공식 문서인https://besu.hyperledger.org/private-networks/tutorials 의 내용에서 발췌하였으며, Privacy Enabled Network와 Permissioned Network까지 다루고 있습니다.
This is a training session at Hyperledger Besu's Private Networks, with the main content excerpts from the official document besu.hyperledger.org/private-networks/tutorials and even covers the Private Enabled and Permitted Networks.
Photoshop Tutorial for Beginners (2024 Edition)alowpalsadig
Photoshop Tutorial for Beginners (2024 Edition)
Explore the evolution of programming and software development and design in 2024. Discover emerging trends shaping the future of coding in our insightful analysis."
Here's an overview:Introduction: The Evolution of Programming and Software DevelopmentThe Rise of Artificial Intelligence and Machine Learning in CodingAdopting Low-Code and No-Code PlatformsQuantum Computing: Entering the Software Development MainstreamIntegration of DevOps with Machine Learning: MLOpsAdvancements in Cybersecurity PracticesThe Growth of Edge ComputingEmerging Programming Languages and FrameworksSoftware Development Ethics and AI RegulationSustainability in Software EngineeringThe Future Workforce: Remote and Distributed TeamsConclusion: Adapting to the Changing Software Development LandscapeIntroduction: The Evolution of Programming and Software Development
Photoshop Tutorial for Beginners (2024 Edition)Explore the evolution of programming and software development and design in 2024. Discover emerging trends shaping the future of coding in our insightful analysis."Here's an overview:Introduction: The Evolution of Programming and Software DevelopmentThe Rise of Artificial Intelligence and Machine Learning in CodingAdopting Low-Code and No-Code PlatformsQuantum Computing: Entering the Software Development MainstreamIntegration of DevOps with Machine Learning: MLOpsAdvancements in Cybersecurity PracticesThe Growth of Edge ComputingEmerging Programming Languages and FrameworksSoftware Development Ethics and AI RegulationSustainability in Software EngineeringThe Future Workforce: Remote and Distributed TeamsConclusion: Adapting to the Changing Software Development LandscapeIntroduction: The Evolution of Programming and Software Development
The importance of developing and designing programming in 2024
Programming design and development represents a vital step in keeping pace with technological advancements and meeting ever-changing market needs. This course is intended for anyone who wants to understand the fundamental importance of software development and design, whether you are a beginner or a professional seeking to update your knowledge.
Course objectives:
1. **Learn about the basics of software development:
- Understanding software development processes and tools.
- Identify the role of programmers and designers in software projects.
2. Understanding the software design process:
- Learn about the principles of good software design.
- Discussing common design patterns such as Object-Oriented Design.
3. The importance of user experience (UX) in modern software:
- Explore how user experience can improve software acceptance and usability.
- Tools and techniques to analyze and improve user experience.
4. Increase efficiency and productivity through modern development tools:
- Access to the latest programming tools and languages used in the industry.
- Study live examples of applications
The Comprehensive Guide to Validating Audio-Visual Performances.pdfkalichargn70th171
Ensuring the optimal performance of your audio-visual (AV) equipment is crucial for delivering exceptional experiences. AV performance validation is a critical process that verifies the quality and functionality of your AV setup. Whether you're a content creator, a business conducting webinars, or a homeowner creating a home theater, validating your AV performance is essential.
Orca: Nocode Graphical Editor for Container OrchestrationPedro J. Molina
Tool demo on CEDI/SISTEDES/JISBD2024 at A Coruña, Spain. 2024.06.18
"Orca: Nocode Graphical Editor for Container Orchestration"
by Pedro J. Molina PhD. from Metadev
Nashik's top web development company, Upturn India Technologies, crafts innovative digital solutions for your success. Partner with us and achieve your goals
57. Read repair example
public class FooResolver implements ConflictResolver<Foo> {
@Override
public Foo resolve(List<Foo> siblings) {
// Insert your sibling resolution logic here
}
}
public class Buddy {
public String name;
public Set<String> nicknames;
public Buddy(String name, Set<String> nicknames) { this.name = name;
this.nicknames = nicknames;
}
}
public class BuddyResolver implements ConflictResolver<Buddy> {
@Override
public Buddy resolve(List<Buddy> siblings) {
if (siblings.size == 0) {
return null;
} else if (siblings.size == 1) {
return siblings.get(0);
} else {
// Name is also used as key. Thus, all siblings have the same name
String name = siblings.get(0). name;
Set<String> mergedNicknames = new HashSet<String>();
for (Buddy buddy : siblings) {
mergedNicknames.addAll(buddy.nicknames);
}
return new Buddy(name, mergedNicknames);
}
}
71. Deferrable work example
// Do or wait variant <init batch>
while(<more to process>) {
int load = getLoad();
if (load > THRESHOLD) {
waitFixedDuration();
} else {
<process next batch of work>
}
}
void waitFixedDuration() {
Thread.sleep(DELAY); // try-catch left out for better readability
}
// Adaptive load variant <init batch>
while(<more to process>) {
waitLoadBased();
<process next batch of work>
}
void waitLoadBased() {
int load = getLoad();
long delay = calcDelay(load);
Thread.sleep(delay); // try-catch left out for better readability
}
long calcDelay(int load) {
// Simple example implementation
if (load < THRESHOLD) {
return 0L;
}
return (load – THRESHOLD) * DELAY_FACTOR;
}