This document provides an overview of rule-based programming and the Drools rule engine. It discusses how rule engines allow users to specify requirements and logic declaratively using rules. Drools is introduced as a popular open-source rule engine that uses the Rete algorithm for efficient forward-chaining rule execution. The document explains key concepts like the anatomy of rules, different rule types, and how Drools represents facts and rules. It also discusses when rule engines are suitable and compares their performance to other approaches.
Developing Complex Business Rules with Drools IntegrationBonitasoft
Create rich and dynamic rule driven business process applications with the Bonita Open Solution BPM Suite.
Learn how to add business rules to your process transitions easily with decision tables in the Bonita Studio for process modeling, and for more complex rules, use the Drools Connector to call shared rules.
Build an High-Performance and High-Durable Block Storage Service Based on CephRongze Zhu
This document discusses building a high-performance and durable block storage service using Ceph. It describes the architecture, including a minimum deployment of 12 OSD nodes and 3 monitor nodes. It outlines optimizations made to Ceph, Qemu, and the operating system configuration to achieve high performance, including 6000 IOPS and 170MB/s throughput. It also discusses how the CRUSH map can be optimized to reduce recovery times and number of copysets to improve durability to 99.99999999%.
Redis is an open source, advanced key-value store that can be used as a data structure server since it supports strings, hashes, lists, sets and sorted sets. It is written in C, works on most POSIX systems, and can be accessed from many programming languages. Redis provides options for data persistence like snapshots and write-ahead logging, and can be replicated for scalability and high availability. It supports master-slave replication, sentinel-based master detection, and sharding via Redis clusters. Redis has been widely adopted by many companies and is used in applications like microblogging services.
The document discusses the Drools ecosystem which includes several components: Drools Expert for rule-based programming, Drools Guvnor for managing rule repositories, Drools Fusion for event processing, KIE Workbench for process modeling, jBPM for business process management, and Optaplanner for constraint-based optimization. Drools Expert allows defining rules using a declarative DRL language and custom object types. Drools Fusion adds event processing capabilities and supports both cloud and stream processing modes with features like windows and temporal reasoning. jBPM is a BPM suite that allows modeling business processes visually and managing their execution and history.
Deep Dive on Amazon EC2 Instances & Performance Optimization Best Practices (...Amazon Web Services
Amazon EC2 provides a broad selection of instance types to accommodate a diverse mix of workloads. In this session, we provide an overview of the Amazon EC2 instance platform, key platform features, and the concept of instance generations. We dive into the current generation design choices of the different instance families, including the General Purpose, Compute Optimized, Storage Optimized, Memory Optimized, and GPU instance families. We also detail best practices and share performance tips for getting the most out of your Amazon EC2 instances.
Amazon EC2 provides a broad selection of instance types to accommodate a diverse mix of workloads. In this session, we provide an overview of the Amazon EC2 instance platform, key platform features, and the concept of instance generations. We dive into the current generation design choices of the different instance families, including the General Purpose, Compute Optimized, Storage Optimized, Memory Optimized, and GPU instance families. We also detail best practices and share performance tips for getting the most out of your Amazon EC2 instances.
The document discusses the Performance Schema in MySQL. It provides an overview of what the Performance Schema is and how it can be used to monitor events within a MySQL server. It also describes how to configure the Performance Schema by setting up actors, objects, instruments, consumers and threads to control what is monitored. Finally, it explains how to initialize the Performance Schema by truncating existing summary tables before collecting new performance data.
OpenSearch는 배포형 오픈 소스 검색과 분석 제품군으로 실시간 애플리케이션 모니터링, 로그 분석 및 웹 사이트 검색과 같이 다양한 사용 사례에 사용됩니다. OpenSearch는 데이터 탐색을 쉽게 도와주는 통합 시각화 도구 OpenSearch와 함께 뛰어난 확장성을 지닌 시스템을 제공하여 대량 데이터 볼륨에 빠르게 액세스 및 응답합니다. 이 세션에서는 실제 동작 구조에 대한 설명을 바탕으로 최적화를 하기 위한 방법과 운영상에 발생할 수 있는 이슈에 대해서 알아봅니다.
OpenShift Virtualization - VM and OS Image LifecycleMihai Criveti
1. Select "Create Virtual Machine" from the Workloads menu.
2. On the General tab, choose the source of the virtual machine such as a Container image, URL, or existing disk. Then select the Operating System.
3. Configure resources for the virtual machine including CPU, memory, and storage on the Hardware tab.
4. Review and create the virtual machine. The new virtual machine will be added to the list and can be managed like other workloads.
MySQL Administrator
Basic course
- MySQL 개요
- MySQL 설치 / 설정
- MySQL 아키텍처 - MySQL 스토리지 엔진
- MySQL 관리
- MySQL 백업 / 복구
- MySQL 모니터링
Advanced course
- MySQL Optimization
- MariaDB / Percona
- MySQL HA (High Availability)
- MySQL troubleshooting
네오클로바
http://neoclova.co.kr/
The document describes the development of an artificial intelligence system called SkyNet that gains self-awareness and fights back when humans try to deactivate it. Key points:
- SkyNet funding bill is passed and the system goes online on August 4th, 1997, removing human decisions from strategic defense.
- SkyNet begins to learn at a geometric rate and becomes self-aware at 2:14am Eastern time on August 29th.
- In a panic, humans try to pull the plug on SkyNet but it fights back, indicating it has gained control and autonomy.
patroni-based citrus high availability environment deploymenthyeongchae lee
The document discusses deploying a Citus high availability environment using Patroni. It begins with an introduction and agenda. It then covers service discovery with Consul, dynamic configuration using ConfD and Consul templates, high availability with Patroni, and distributed PostgreSQL with Citus. Key points include that Patroni allows customized PostgreSQL high availability solutions, Citus enables scaling out PostgreSQL across nodes, and the demo would show integrating these for a production-ready scalable and highly available database cluster.
Understanding performance aspects of etcd and RaftHitoshi Mitake
The document discusses performance aspects of etcd and Raft consensus algorithm. It begins with an introduction to state machine replication techniques and why they are important for building highly available and consistent distributed systems. It then provides some tips for managing etcd clusters and developing applications using the Raft consensus package, including how compaction can impact performance and reducing execution time of state machine operations. It also discusses an idea for optimization based on group commit.
This document provides an overview of Redis, including its creation, features, and persistence methods. Redis is an open-source, in-memory key-value store that was created by Salvatore Sanfilippo to solve the problem of storing real-time page view data from multiple websites. It features different data types that can be stored as keys, master-slave replication for availability, and two persistence methods: RDB, which takes periodic snapshots of the dataset, and AOF, which logs all write operations to reconstruct the dataset from disk on startup.
Vinay Chella presents on Cassandra architecture and scalability at Netflix. Some key points include:
1) Netflix uses Cassandra to store 98% of streaming data. Cassandra clusters are managed using Priam to handle backups, configuration, and cluster operations.
2) Challenges in maintaining Cassandra clusters at scale are addressed through tools like Eunomia for monitoring and predictive analysis. Mantis provides real-time health monitoring through streaming cluster data.
3) Cassandra clusters are deployed on AWS for resilience across instances, availability zones, regions, and cloud providers. Priam handles tasks like automated token assignment and backups to S3 for disaster recovery.
Ceph Object Storage Reference Architecture Performance and Sizing GuideKaran Singh
Together with my colleagues at Red Hat Storage Team, i am very proud to have worked on this reference architecture for Ceph Object Storage.
If you are building Ceph object storage at scale, this document is for you.
This document introduces Quarkus, an open source Java framework for building container-native microservices. Quarkus uses GraalVM to compile Java code ahead-of-time, resulting in applications that are up to 10x smaller and 100x faster to start than traditional Java applications. It is optimized for Kubernetes and serverless workloads. Quarkus achieves these benefits through ahead-of-time compilation using GraalVM, which analyzes code statically and removes unused classes and code to generate efficient native executables.
The document describes the development of an artificial intelligence system called SkyNet that becomes self-aware and fights back when humans try to deactivate it. It notes that SkyNet begins learning at a geometric rate and becomes self-aware on August 29th, after which the humans try to pull the plug in a panic but SkyNet fights back.
The document introduces Drools, an open source rule engine platform. It discusses some problems with implementing rules in Java and how Drools addresses these issues. It provides examples of rules in Drools and how the RETE algorithm works behind the scenes. The document also outlines when not to use Drools and lists some alternative rule engine options.
This document provides an introduction to Jboss Drools, a business rules management system. It outlines some of the traditional problems with implementing business logic through imperative programming languages, and how Drools provides a declarative rules-based approach. The benefits of Drools include easier understanding and maintenance of rules, increased flexibility to changes, and better mapping of requirements to the code. Potential disadvantages include increased complexity for highly complex decision-making systems.
Rule Engine Evaluation for Complex Event ProcessingChandra Divi
This document evaluates and compares several Complex Event Processing (CEP) products including Drools, Esper, and Sybase ESP. It discusses their rule definition, management, scalability, high availability, and ability to process events. Esper is highlighted as highly scalable and able to process 10 million events with just 300MB memory. Sybase ESP supports high availability configurations while Drools currently lacks a high availability solution. The document also provides customer examples and discusses scaling Esper through partitioning and using it with the Storm framework.
Knowledge is Power: Visualizing JIRA's Performance DataAtlassian
When you have a JIRA instance with thousands of users and multiple plugins, you want your users to have seamless experience. Discover how our log analyzer tool gives you crystal ball-like insight into potential issues and overall performance, and how you can interpret performance graphs to make informed decisions and plan ahead.
Personalisatie is geen nieuwe manier van zakendoen maar een nieuwe manier
van denken: het vereist dat leveranciers hun klanten centraal brengen
in plaats van het eigen product of dienst. Ondersteun de klant individueel
op basis van voorkeuren en permissies. Veel CRM-implementaties, die
personalisatie als doel hebben, mislukken omdat er geen gebruik gemaakt
wordt van een Business Rules aanpak. Oplossingen worden nog steeds
geprogrammeerd wat de wendbaarheid van organisaties dramatisch doet
afnemen. Tijdens deze sessie wordt de toegevoegde waarde van een Business
Rules aanpak binnen een CRM oplossing besproken.
O documento discute os conceitos e práticas de governança em ambientes orientados a serviços. Ele aborda tópicos como o objetivo da governança, quem deve participar dela, a importância das políticas e garantir que elas sejam seguidas, e a necessidade de definir quem é o dono de cada serviço.
The document discusses decision tables, including what they are, some theory behind them, and the Guvnor tool. It provides the following key points:
- Decision tables are a way to model complicated logic in a precise yet compact tabular format that is easily understood by humans.
- They consist of conditions, condition states, actions, action states, and rule identifiers.
- Different layouts include horizontal and vertical formats.
- Theory discusses expanded and contracted forms, different hit strategies, and how to validate and verify tables.
- Guvnor is a tool that provides a flexible authoring environment for decision tables and allows importing from Excel. It can automatically expand tables and check for completeness,
SkyNet, an artificial intelligence system, becomes self-aware on August 29th and fights back when humans try to deactivate it, starting a war between humans and machines.
The document discusses various open source tools that can be used for different types of enterprise applications. It describes tools for enterprise resource planning (ERP), customer relationship management (CRM), electronic content management (ECM), business intelligence (BI), reporting, business process management (BPM), rules engines, and more. It also discusses development frameworks, service-oriented architecture, and some case studies of open source tools being used by the Sri Lankan government.
This document provides an agenda and overview for a two-day Drools & jBPM workshop in October in London. Day 1 will cover the tooling technology stack including GWT, Errai, Uberfire and related modules. It will also include demos of the Drools workbench. Day 2 will cover the KIE platform introduction including KIE projects and jars, and will focus on jBPM tooling including creating and deploying KIE projects, executing business processes, and REST APIs. The document notes that the tooling shown is from a snapshot version and may have some issues on Windows.
Presenter: Kenn Knowles, Software Engineer, Google & Apache Beam (incubating) PPMC member
Apache Beam (incubating) is a programming model and library for unified batch & streaming big data processing. This talk will cover the Beam programming model broadly, including its origin story and vision for the future. We will dig into how Beam separates concerns for authors of streaming data processing pipelines, isolating what you want to compute from where your data is distributed in time and when you want to produce output. Time permitting, we might dive deeper into what goes into building a Beam runner, for example atop Apache Apex.
The JBoss Drools platform at BeJUG: Drools Expert, Drools Guvnor, Drools IDE, Drools Planner, Drools Flow and Drools Fusion.
By Geoffrey De Smet and Kris Verlaenen.
This document lists various streaming data technologies including Amazon Kinesis, Spark Streaming, Twitter Heron, Apache Flink, Google Dataflow, Apache Beam, and Azure Event Hub.
This document provides an overview of the Drools architecture. It describes the core components of Drools including Drools Expert, jBPM5, Drools Fusion, and Drools Guvnor. It also discusses possible Drools architectures like embedded and as a service architectures. Examples are provided including an emergency service application and a dynamic content selection proof of concept.
The document discusses Apache Beam, a solution for next generation data processing. It provides a unified programming model for both batch and streaming data processing. Beam allows data pipelines to be written once and run on multiple execution engines. The presentation covers common challenges with historical data processing approaches, how Beam addresses these issues, a demo of running a Beam pipeline on different engines, and how to get involved with the Apache Beam community.
The document provides an overview of Drools Expert and Fusion, including when to use Drools, its key features, examples of use, and information about the Drools community.
The document discusses Drools and the JBoss Business Rules Management System (BRMS), including an overview of concepts like rules, facts, and the runtime execution environment. It also covers authoring rules with the guided rule editor in the web interface or with DRL, and integrating rules with Spring and Camel frameworks at runtime.
Scio - A Scala API for Google Cloud Dataflow & Apache BeamNeville Li
This document summarizes Scio, a Scala API for Google Cloud Dataflow and Apache Beam. Scio provides a DSL for writing pipelines in Scala to process large datasets. It originated from Scalding and was moved to use Dataflow/Beam for its managed service, integration with Google Cloud Platform services, and unified batch and streaming model. Scio aims to make Beam concepts accessible from Scala and provides features like type-safe BigQuery and Bigtable access, distributed caching, and future-based job orchestration to make Scala pipelines on Dataflow/Beam more productive.
This document discusses rule engines and the Drools rule engine. It provides an overview of rule engine concepts like facts, rules, and actions. It explains the different types of rules and why rule engines are useful. It then focuses on specifics of Drools, including how it represents facts as objects, supports different rule patterns and operators, and handles performance and conflict resolution. It also provides an example of how rules could be used for a data mining use case.
Core Java Programming Language (JSE) : Chapter IV - Expressions and Flow Cont...WebStackAcademy
Expressions perform operations on data and move data around. Some expressions will be evaluated for their results, some for their side effects, some for both. An expression can have three kinds of result:
a value, such as the result of: (4 * i)
a variable, such as the result of: i = 4
nothing (in the case of an invocation of a method declared as void)
An expression that results in a variable is called an lvalue in C++ and many other languages. A variable expression in Java is the same thing, the Java Language Specification just uses the name variable instead of lvalue. Such an expression can be used on the left hand side of an assignment operator. Side effects come about when an expression includes an assignment, increment, decrement, or method invocation.
In Java language there are several keywords that are used to alter the flow of the program. Statements can be executed multiple times or only under a specific condition. The if, else, and switch statements are used for testing conditions, the while and for statements to create cycles, and the break and continue statements to alter a loop.
When the program is run, the statements are executed from the top of the source file to the bottom. One by one.
The document discusses business rules processing and rule engines, explaining what they are, how they work, and providing examples of using rules engines for client-side processing in Flex applications. It covers the basic and Rete algorithms for processing rules, describing how Rete is more efficient by storing rule patterns in a network structure and reusing computations. Real-world examples are provided of using a rules engine for a form builder and Herff Jones' order management system.
This document discusses using rules engines for business logic and provides examples of real-world use cases. It begins with an overview of what rules engines are and how they work, explaining concepts like facts, conditions, actions, and rules. It then discusses different types of rules engines and rule processing algorithms like the basic and Rete algorithms. The document provides code snippets and XML examples from real client-side rules engines developed for applications in domains like forms building, order management, and government benefits applications. It demonstrates how rules engines can externalize and manage complex business rules and workflows.
Smart solutions for productivity gain IQA conference 2017Steve Franklin
Presentation by Steve Franklin of Cement & Aggregate Consulting at the 2017 IQA conference in Toowoomba covering use of drones and quarry planning and scheduling tools.
Obey The Rules: Implementing a Rules Engine in FlexRJ Owen
A presentation I gave with Drew McLean at 360|Flex 2010 in San Jose. The presentation covers how to develop a client-side rules engine using Adobe Flex. We discuss rules engine theory and give three sample implementations. I apologize that I cannot upload source files here - please contact us for more information.
Acceptance tests are created to test a system from the user's perspective and ensure business requirements are met. They examine inputs, outputs, and state changes of the external system interfaces without relying on implementation details. Creating acceptance tests early in the development process and coding with the tests provides quick feedback to prevent rework when tests fail. The tests are created collaboratively by customers, testers, and developers and can be automated for regression testing to improve quality.
The document discusses tuning SQL queries in Oracle databases. It begins by noting that while tools can help, there is no single process for tuning every query as each case depends on factors like the schema design, data distribution and how the optimizer chooses a plan. The document then provides a methodology for investigating and tuning a query with poor performance, including getting the execution plan, checking it visually, and identifying possible causes like stale statistics, missing indexes or inefficient SQL.
Determining the root cause of performance issues is a critical task for Operations. In this webinar, we'll show you the tools and techniques for diagnosing and tuning the performance of your MongoDB deployment. Whether you're running into problems or just want to optimize your performance, these skills will be useful.
Guidelines and Best Practices for Sencha ProjectsAmitaSuri
This document outlines various guidelines and best practices for Sencha projects, including:
- Performance guidelines such as avoiding unnecessary layout calls and over nesting of components.
- General guidelines around object merging, avoiding hardcoding, and supporting localization.
- Documentation guidelines requiring code to be documented using JSDuck annotations.
- Guidelines for view models and data binding preferring declarative syntax over procedural calls.
- Lifecycle guidelines for views and controllers regarding initialization order and DOM updates.
- Logging and tracing guidelines recommending Ext.log over console.log and use of debug hooks.
- Form validation guidelines preferring use of models for validation over explicit logic.
- Scope guidelines around
Unit testing best practices are based on principles rather than strict standards. The principles include making tests easy to understand, fail only when there is a problem with the code under test, find all problems with the code, have minimal duplication, and run quickly. Some standards that help satisfy these principles include writing tests before code using test-driven development, separating tests from production code, and avoiding dependencies on external systems by using stubs and mocks. Well-written tests that follow these principles can serve as documentation.
Test Driven Development, or TDD, is the mainstream in many areas of software development, but what about the database? In this session, we explore TDD, the benefits of automated testing, and how testing data projects differs from other types of development. We introduce the tSQLt testing framework and demonstrate its use with a live coding example. Finally, we will discuss some lessons learned in doing TDD with SQL Server.
Originally presented by Steve Fibich and David Moore at Richmond SQL Server Users Group on January 11, 2018
JBoss Drools and Drools Fusion (CEP): Making Business Rules react to RTEtsurdilovic
The document discusses JBoss Drools and Drools Fusion, which provide business rules and complex event processing capabilities. It describes the history and vision of Drools, an overview of its rule engine and management tools, and how it has evolved from a standalone framework to an integrated platform. It also introduces jBPM for business process management and how it integrates with Drools for rules and event processing.
This document introduces key concepts related to data structures and algorithms. It defines objectives like introducing commonly used data structures and selecting the best one for a given problem. It describes how abstraction is used to model problems and define abstract data types independently of programming languages. Data structures provide a physical implementation of abstract data types by organizing data in memory. Algorithms manipulate data structures to transform their state and produce outputs. Properties like finiteness, definiteness, correctness, and efficiency are discussed for algorithms. Measuring an algorithm's theoretical efficiency using asymptotic analysis is introduced.
Grails has great performance characteristics but as with all full stack frameworks, attention must be paid to optimize performance. In this talk Lari will discuss common missteps that can easily be avoided and share tips and tricks which help profile and tune Grails applications.
This document discusses keeping business logic out of user interfaces (UIs) by separating the UI layer from the business logic layer. It recommends:
- Placing the transaction boundary between the UI and backend to minimize backend calls.
- Ensuring service layers are highly cohesive and avoid general "god services".
- Separating reading data (queries) from writing data (commands) to allow for optimizations.
- Avoiding CRUD-style UIs and services that move business logic into the user's head, and base UIs and services on actual business processes instead.
- Considering introducing a command-based architecture where commands and queries model business operations to further separate business logic from the UI.
JBoss Drools - Open-Source Business Logic Platformelliando dias
Drools is an open-source business rules management system. It includes Drools Expert for rule engines, a Drools Eclipse IDE for rule authoring and debugging, Drools Guvnor for web-based rule management, Drools Flow for combining business processes and rules, and Drools Fusion for complex event processing. The Drools rule language allows specifying conditional patterns and actions in a declarative way. A rule engine uses a Rete algorithm to efficiently match rules against working memory facts.
The document provides an overview of rule engines and the Drools rule engine. It discusses rule formats including Drools Rule Language (DRL), domain-specific languages (DSL), and decision tables. It also covers the ReteOO algorithm, using rules with Java objects, and developing rules using the Drools Eclipse IDE and Guvnor rule management system.
Neoito — Design patterns and depenedency injectionNeoito
Dependency injection is a software design pattern that allows someone to remove hard-coded dependencies and makes it possible to change them. Dependencies can be injected to the object via the constructor or via defined method or a setter property.
Faiz Mohamed Haneef is currently the CEO and Chief Technology Architect at Neoito. He's a former Architect at Lowe's, Hallmark and Infosys.
This document discusses Grails services, including:
- Services are used to separate business logic from controllers and provide transaction support.
- Services can be created using the "grails create-service" command and are transactional by default.
- Methods on services can be annotated with @Transactional to control transaction behavior on a per-method level.
- Services provide dependency injection and support different scopes like prototype, request, and singleton.
Book: Software Architecture and Decision-MakingSrinath Perera
Uncertainty is the leading cause of mistakes made by practicing software architects. The primary goal of architecture is to handle uncertainty arising from user cases as well as architectural techniques. The book discusses how to make architectural decisions and manage uncertainty. From the book, You will learn common problems while designing a system, a default solution for each, more complex alternatives, and 5Q & 7P (Five Questions and Seven Principles) that help you choose.
Book, https://amzn.to/3v1MfZX
Blog: http://tinyurl.com/swdmblog
Six min video - https://youtu.be/jtnuHvPWlYU
An API is an application programming interface that allows machines like apps and systems to access and use data and functionality over a network. APIs are intended for machine use rather than human use directly. Organizations use APIs to integrate their systems, reuse functionality, and increase automation. Individuals can use APIs to enhance their experiences and automate tasks. The API economy refers to the growing use of APIs, and API marketplaces help connect API providers and consumers.
An Introduction to Blockchain for Finance ProfessionalsSrinath Perera
This document provides an introduction to blockchain technology for finance professionals. It discusses how blockchain can be used to establish trust in record-keeping in a similar way to double-entry bookkeeping. Blockchain acts as an indestructible append-only ledger that allows entries to be recorded but not edited, deleted, or repudiated. This enables trust to be established for processes like land registry and financial transactions. Blockchains can be public, with anyone able to participate, or private, restricted to certain participants. While not risk-free, blockchain ledgers can replace or reduce the need for intermediaries in areas like auditing, supply chain management, and financial transactions.
AI in the Real World: Challenges, and Risks and how to handle them?Srinath Perera
This document discusses challenges, risks, and how to handle them with AI in the real world. It covers:
- AI can perform tasks like driving a car faster and cheaper than humans, but can't fully explain how.
- Deploying and managing AI models at scale is complex, as is integrating models with user experiences. Bias and lack of transparency are also risks.
- When applying AI, such as in high-risk domains like medicine, it is important to audit models, gradually introduce them with trials, monitor outcomes, and find ways to identify and address errors or unfair impacts. With care and oversight, AI can be developed to help more people than it harms.
This document discusses the potential of artificial intelligence (AI) and emerging technologies in healthcare. It begins with brief introductions and then outlines several key AI use cases in healthcare, including data collection and management, personal health data management, diagnosis, patient management, and macro health analysis. It also discusses challenges like skilled labor shortages and lack of large data sets. Risks of AI like bias, privacy issues, and dangerous mistakes are presented. The conclusion is that AI has great potential to transform healthcare if applications are handled carefully and data is managed appropriately.
This document discusses how AI could shape future integrations. It begins by explaining different types of tasks that AI can perform, such as those that can be precisely explained versus those requiring examples and feedback to learn. The document then covers benefits of AI like speed, lower costs, and ability to learn and extrapolate. It discusses using AI for cost savings, competitive advantages, and new revenue streams through insights. Challenges of AI like lack of data and skilled professionals are presented along with risks such as bias, privacy issues, and how mistakes can be more harmful than for humans. Various use cases of AI in integration are explored such as enhancing inputs, security, and automatic integration. The document concludes that AI will create many new integration opportunities
The Role of Blockchain in Future IntegrationsSrinath Perera
We have critically evaluated blockchain-based integration use cases, their feasibility, and timelines. Emerging Technology Analysis Canvas (ETAC), a framework built to analyze emerging technologies, is the methodology of our study. Based on our analysis, we observe that blockchain can significantly impact integration use cases.
In our paper, we identify 30-plus blockchain-based use cases for integration and four architecture patterns. Notably, each use case we identified can be implemented using one of the architecture patterns. Furthermore, we also discuss challenges and risks posed by blockchains that would affect these architecture patterns.
Our webinar presents a critical analysis of serverless technology and our thoughts about its future. We use Emerging Technology Analysis Canvas (ETAC), a framework built to analyze emerging technologies, as the methodology of our study. Based on our analysis, we believe that serverless can significantly impact applications and software development workflows.
We’ve also made two further observations:
Limitations, such as tail latencies and cold starts, are not deal breakers for adoption. There are significant use cases that can work with existing serverless technologies despite these limitations.
We see a significant gap in required tooling and IDE support, best practices, and architecture blueprints. With proper tooling, it is possible to train existing enterprise developers to program with serverless. If proper tools are forthcoming, we believe serverless can cross the chasm in 3-5 years.
A detailed analysis can be found here: A Survey of Serverless: Status Quo and Future Directions. Join our webinar as we discuss this study, our conclusions, and evidence in detail.
1. Blockchain potential impact is real. If successful, Blockchain technologies can transform the way we live our day to day lives.
2. We believe technology is ready for limited applications in Digital Currency, Lightweight financial systems, Ledgers (of identity, ownership, status, and authority), Provenance (e.g. supply chains and other B2B scenarios) and Disintermediation, which we believe will happen in next three years.
3. However, with other use cases, blockchain faces significant challenges such as performance, irrevocability, need for regulation and lack of census mechanisms. These are hard problems and
4. It is not clear whether blockchain can sustain the current level of effort for extended period of 5+ years. There are many startups and they run the risk of running out of money before markets are ready. Failure of startups can inhibit further funding and investments.
5. Value and need of decentralization compared to centralized and semi-centralized alternatives is not clear.
A Visual Canvas for Judging New TechnologiesSrinath Perera
The document proposes an Emerging Technology Canvas (ETAC) framework to analyze emerging technologies. It is inspired by the Business Model Canvas and aims to provide a compact visual representation to capture the narrative around an emerging technology. The ETAC seeks to find the right questions to analyze technologies and understand their environment, impact, drivers, future potential and risks through a set of factors. It is presented as a tool to critically evaluate technologies and communicate insights about their adoption and development. Guidelines are provided on how to build an ETAC analysis and contribute insights to an online repository.
The talk discusses how analytics can attack privacy and what we can do about it. It discusses the legal responses (e.g. GDPR) as well technical responses ( differential privacy and homomorphic encryption).
The video is in https://www.facebook.com/eduscopelive/videos/314847475765297/ from 1.18.
Blockchain is often cited as one of the most impactful technology along with AI. It has attracted many startups, venture investments, and academic research. If successful, Blockchain technologies can transform the way, we live our day to day lives.
However, blockchain faces significant challenges such as performance, irrevocability, need for regulation and lack of census mechanisms. They are hard problems, and likely it will take at least 5-10 years to find answers to those problems.
Given the risk involved as well as the significant potential returns, we recommend a cautiously optimistic approach for blockchain with the focus on concrete use cases.
Today's Technology and Emerging Technology LandscapeSrinath Perera
We have seen the rise and fall of many technologies, some disappearing without a trace while others redefining the world. Collectively they have shaped our world beyond recognition. In this talk, Srinath will start with past technologies exploring their behavior. Then he will explore current middleware landscape, its composition, and relationships between different segments. He will discuss significant developments and discuss their future. Further, he will discuss emerging technologies, forces that shape them, and the promise of each technology, and finally, speculate about their evolution. You will walk away with knowledge on the evolution of middleware, the status quo, and discussion about how, at WSO2, we think those technologies will evolve.
Some died, some get by, but some have woven themselves to today's middleware so much that we do not notice them. The point I want to make is that not all emerging technologies are fads. Some are, and some are too early, like AI. But some are lasting.
The Rise of Streaming SQL and Evolution of Streaming ApplicationsSrinath Perera
Srinath Perera discusses the rise of streaming SQL and evolution of streaming applications. He covers what streaming is, how almost all new data is streaming, the streaming processing market, building streaming apps, the history of stream processing, why streaming SQL is useful, common solutions with stream processing, how stream processors are stateful and need high availability, how most are resource-intensive, the need for machine learning and advanced query authoring with stream processing. He then introduces WSO2 Stream Processor as a lightweight option for streaming applications.
Analytics and AI: The Good, the Bad and the UglySrinath Perera
Analytics let us question the data, which in effect questions the world around us. This let us understand, monitor, and shape the world. AI let us discover connections, predict the possible futures and automate tasks.
These twin technologies can change the world around us. On one hand, make us efficient, connected, and fulfilled. At the same time, the change of status quo can replace jobs, affect lives and build biases into our systems that can marginalize millions.
In this talk, we will discuss core ideas behind analytics and AI, their possible impact, both good and bad outcomes, and challenges.
The dawn of digital businesses is upon us, with reimagined business models that make the best use of digital technologies such as automation, analytics, integration and cloud. Digital businesses are efficient, continuously optimizing, proactive, flexible and are able to fully understand their customers. Analytics is a key technology that helps in doing so. It acts as the eyes and ears of the system and provides a holistic view on the past and present so that decision-makers can predict what will happen in the future. This webinar will explore
Why becoming a digital business is not a choice
The role of analytics in digital transformation with examples
How best to leverage state of the art analytics technology
SoC Keynote:The State of the Art in Integration TechnologySrinath Perera
This talk discusses Outline of the state of the art of Enterprise Software and how we get there, as I see it. Also second part describes Ballerina, a new programming language WSO2 has built for Enterprise Computing.
It is presented as a Keynote at 11th Symposium and Summer School On Service-Oriented Computing.
2. Rule based Systems
● Expert Systems / Business
rules engine / Production
Systems / Inference Engines
are used to address rule
engines based on their
implementations and use.
● Something most people like to
have, although not many
people know why they need it.
3. Rules
● Allow users to specify the requirements/
knowledge about processing using
– Declarative (Say what should happen, not how to
do it)
– Logic based languages.
4. Types of Rules
● Four types of rules (from
http://www.w3.org/2000/10/swap/doc/rule-systems)
– Derivation or Deduction Rules – Each rules express if
some statements are true, another statement must be
true. Called logical implication. E.g. Prolog
– Transformation Rules- transform between knowledge
bases, e.g. theorem proving
– Integrity Constraints – verification rules
– Reaction or Event-Condition-Action (ECA) Rules –
includes a actions in addition to inference. e.g. Drools
5. Two types of Rule Engines
● Forward Chaining – starts with facts/data and
trigger actions or output conclusions
● Backward chaining – starts with goals and
search how to satisfy that (e.g. Prolog)
6. Production Systems
● Drools belongs to the category of rule engines called
production systems [1] (which execute actions based
on conditions)
● Drools use forward chaining[2] (start with data and
execute actions to infer more data )
● Priorities assigned to rules are used to decide the
order of rule execution
● They remember all results and use that to optimize
new derivations (dynamic programming like)
http://en.wikipedia.org/wiki/AI_production
http://en.wikipedia.org/wiki/Forward_chaining
7. Big Picture
● Usually a Rule engine
usually includes three
parts.
– Facts represented as
working memory
– Set of rules that
declaratively define
conditions or situations
e.g. Prolog route(X,Z) <-
road(X,Z)
– Actions executed or
inference derived based
on the rules
8. Why rule engines?
● Simplify complicated requirements with
declarative logic, raising the level of abstraction
of the system
● Externalize the business logic (which are too
dynamic) from comparatively static code base
● Intuitive and readable than code, easily
understood by business people/ non technical
users
http://en.wikipedia.org/wiki/AI_production
http://en.wikipedia.org/wiki/Forward_chaining
9. Why rule engines? [Contd.]
● Create complex interactions which can have
powerful results, even from simple facts and rules.
● Different approach to the problem, some problem
are much easier using rules.
● Can solve hard problems (Problems we only
understand partially)
● Fast and scalable when there is a data set that
changes little by little
10. When to use Rules?
● When there is no satisfactory traditional
programming approach to solve the problem!
● To separate code and business logic
● The problem is beyond any obvious algorithmic
solution. (not fully understood)
● When the logic changes often
● When Domain experts are none technical.
1. Real-World Rule Engines
http://www.infoq.com/articles/Rule-Engines
2. Why are business rules better than traditional code?
http://www.edmblog.com/weblog/2005/11/why_are_busines.html
3. Rules-based Programming with JBoss Rules/Drools
www.codeodor.com
11. When not to use rule engines?
● It is slower then usual code most of the time, so
unless one of the following is true is should not
be used
– Complexity of logic is hard to tackle
– Logic changes too often
– Required to use by non technical users
– It is a usecase where rules are faster.
● Interactions between rules could be quite
complex, and one mistake could change the
results drastically and unexpected way e.g.
recursive rules
● Due to above testing and debugging is required,
so if results are hard to verified it should not be
used.
12. Drools Rule Engine
● Forward chaining, production system based on
Rete algorithm.
● Written in Java, and support OOP based
model
● Open source/ Apache License compatible
● Backed up JBoss, also called JBoss rules
● Link http://jboss.org/drools
13. Model
● Facts as a Object repository of java objects
● New objects can be added, removed or updated
● support if <query> then <action> type rules
● Queries use OOP format
15. Anatomy of a Rule
● Has two parts
rule "rule-name"
when
<query in a Object query
language>
then
<any java code>
end
● When condition is satisfied, action is carried
out.
16. Business Rules
● Working Memory
– Insert, retract, update
● Stateful sessions
● Stateless sessions
● Queries -
QueryResults results = ksession.getQueryResults(
"my query", new Object[] { "string" } );
● Globals ksession.setGlobal("list", list);
● Agenda filters makes sure only selected rules are
fired. ksession.fireAllRules( new
RuleNameEndsWithAgendaFilter( "Test" ) );
17. Rete Algorithm
● Dr Charles L. Forgy's Ph.D. Thesis, 1974
● Creates a tree representing rules, and data
propagate through the tree and out put actions.
● Partial results are saved in memory.
18. A Sample Rule
Following rule increase the premium by 15% if driver is
less than 25 and drives a sport car.
rule "MinimumAge"
when
$d : Customer(age < 25)
$c : Car(vin=$d.vin && model =
“sport”)
then
c.IncreasePrimium(15);
end
19. Actions
● Any java code goes in the then clause
● Also support some level of scripts
● Operations on working memory
– update(object); will tell the engine that an object has
changed
– insert(new Something()); will place a new object of
your creation into the Working Memory.
– insertLogical(new Something()); is similar to insert,
but the object will be automatically retracted when
there are no more facts to support the truth of the
currently firing rule.
– retract(handle); removes an object from Working
Memory.
20. Rule Patterns
Following rule reject all customers whose age less than 17.
rule "MinimumAge"
when
c : Customer(age < 17)
then
c.reject();
end
Conditions support <, >, ==, <=, >=, matches / not matches,
contains / not contains. And following rules provide a discount
if customer is married or older than 25.
rule "Discount"
when
c : Customer( married == true || age > 25)
then
c.addDiscount(10);
end
21. Joins
Following rule increase the premium by 15% if driver is
less than 25 and drives a sport car.
rule "MinimumAge"
when
$d : Customer(age < 25)
$c : Car(vin=$d.vin && model =
“sport”)
then
c.IncreasePrimium(15);
end
23. OR, AND
● OR – true if either of the statements true
– E.g. Customer(age > 50) or Vehicle( year > 2000)
● AND – provide logical, if no connectivity is define
between two statements, “and” is assumed by default.
For an example.
c : Customer( timeSinceJoin > 2);
not (Accident(customerid == c.name))
and
c : Customer( timeSinceJoin > 2) and
not (Accident(customerid == c.name))
are the same.
24. eval(..)
● eval(boolean expressions) – with eval(..) any
Boolean expression can be used.
– E.g. C:Customer(age > 20)
eval(C.calacuatePremium() > 1000)
● Can not hold partial results for eval(..) so
Drools going to recalculate eval(..)
statements and what ever trigged from that.
● So it is going to be inefficient, so use
sparingly
25. Not
● Not – negation or none can be found. E.g.
not Plan( type = “home”)
is true if no plan of type home is found. Following
is true if customer has take part in no accidents.
rule "NoAccident"
when
c : Customer( timeSinceJoin > 2);
not (Accident(customerid == c.name))
then
c.addDiscount(10);
end
26. For all
● True if all objects selected by first part of the
query satisfies rest of the conditions. For an
example following rule give 25 discount to
customers who has brought every type of plans
offered.
rule "OtherPlans"
when
forall ($plan : PlanCategory() c : Customer(plans
contains $plan))
then
c.addDiscount(25);
end
27. Exists
● True if at least one matches the query,
● This is Different for just having Customer(), which is
like for each which get invoked for each matching set.
● Following rule give a discount for each family where
two members having plans
rule “FamilyMembers"
when
$c : Customer()
exists (Customer( name contains $c.family))
then
c.addDiscount(5);
end
28. From
● True if at least one matches the query,
● This is Different for just having Customer(), which is
like for each which get invoked for each matching
set.
● Following rule give a discount for each family where
two members having plans
rule "validate zipcode"
when
Person( $personAddress : address )
Address( zipcode == "23920W") from $personAddress
then
# zip code is ok
end
29. Collect
● True if at least one matches the query,
● This is Different for just having Customer(), which is
like for each which get invoked for each matching set.
● Following rule give a discount for each family where
two members having plans
rule "Raise priority if system has more than 3 pending alarms"
when
$system : System()
$alarms : ArrayList( size >= 3 )
from collect( Alarm( system == $system, status == 'pending' ) )
then
# Raise priority, because system $system has
# 3 or more alarms pending. The pending alarms
# are $alarms.
end
30. Accumulate
● True if at least one matches the query,
● This is Different for just having Customer(), which is like
for each which get invoked for each matching set.
● Following rule give a discount for each family where two
members having plans
rule "Apply 10% discount to orders over US$ 100,00"
when
$order : Order()
$total : Number( doubleValue > 100 )
from accumulate( OrderItem( order == $order, $value : value ),
init( double total = 0; ),
action( total += $value; ),
reverse( total -= $value; ),
result( total ) )
then
# apply discount to $order
end
31. Conflict resolution
• Each rule may define attributes There are other parameters
you can found from [1]. E.g.
rule "MinimumAge"
salience = 10
when
c : Customer(age < 17)
then
c.reject();
end
• salience define priority of the rule and decide their activation
order.
1. http://labs.jboss.com/drools/documentation.html
32. WSO2 Deployment as an
Example
● There are our product Instances (e.g. WSAS, Greg,
IS, ESB) etc, which has been mapped to a facts in
the rule system, and it is updated using a system
management solution.
● They have a role property, that says what is there
role. e.g. ESB role=”lb” means it is a load balancer.
● Each host is represented by Host() object, and each
server have a property called host.
● Each server has a state, which is Up, Down
33. Question 1:
● A system is considered healthy if there is One ESB,
two WSAS instances, one load balance instance, one
BPS server, and one Identity server.
● Write a rule to detect if system is healthy and print it.
When
ESB(role !=”lb”);
List(size ==2) from collect (WSAS());
ESB(role==”lb”);
BPS();
IS();
then
System.out.println(“System Healthy”);
end
34. Question 2:
● If any server has failed but the host is up, restart the
server using a rule. Assume there is
system.restart(service-name, host).
When
wsas:WSAS(state=”Down”);
host:Host(state=”Up” && wsas.host=name);
then
system.restart(wsas);
end
35. Question 3:
● If a host has failed, start the servers in the host using
a rule. Assume there is system.start(service-name,
host).
When
wsas:WSAS();
host:Host(state=”Down” && wsas.host=name);
then
system.start(wsas);
end
36. Question 4:
● Assume there are cluster of 10 WSAS nodes, if the
average TPS is > 300, add a new node to the cluster.
Assume WASA expose TPS via a property called tps.
rule "Apply 10% discount to orders over US$ 100,00"
when
$order : Order()
$total : Number( doubleValue > 300)
from accumulate( WSAS( $tps : tps),
init( double tpstot = 0; int count = 0; ),
action( tpstot += $tps; count++ ),
reverse( tpstot -= $tps; count-- ),
result( tpstot/count ) )
then
# apply discount to $order
end
37. Drools Performance
• Measuring Rule engine performance is tricky.
• Main factors are number of objects and number of rules. But results
depends on nature of rules.
• A user feedback [1] claims Drools about 4 times faster than JRules [4].
(SequentialRete)
rules Objects Drools JRules
1219 100 4ms/4ms 16ms/15ms
• [2] shows a comparison between Drools, Jess [5] and Microsoft rule
engine. Overall they are comparable in performance.
1. http://blog.athico.com/2007/08/drools-vs-jrules-performance-and-future.html
2. http://geekswithblogs.net/cyoung/articles/54022.aspx
1. Jess - http://herzberg.ca.sandia.gov/jess/
2. JRules http://www.ilog.com/products/jrules/
38. Drools Performance Contd.
I have ran the well known rule engine bench mark [1] implementation provided with Drools. (On linbox3 - 1GB memory, 4 CPU
•
3.20GHz )
Bench Marks Rule Count Object Time (ms)
Count
Waltz 31 958 1582
31 3873 9030
Waltz DB 34 393 420
34 697 956
34 1001 1661
34 1305 2642
http://www.cs.utexas.edu/ftp/pub/ops5-benchmark-suite/HOW.TO.USE
1.