This document discusses row-based type systems for algebraic effect handlers. It provides background on algebraic effects and handlers, which allow user-defined effects to be separated from their implementations. Effects are invoked via operations and interpreted by handlers. Row-based type systems represent effects using rows of effect names. This allows detecting which effects may be invoked by functions statically based on their type. An example demonstrates annotating a function with the fail effect it may invoke.
Domain Modeling Made Functional (DevTernity 2022)Scott Wlaschin
(video at https://fsharpforfunandprofit.com/ddd/)
Statically typed functional programming languages encourage a very different way of thinking about types. The type system is your friend, not an annoyance, and can be used in many ways that might not be familiar to OO programmers. Types can be used to represent the domain in a fine-grained, self documenting way. And in many cases, types can even be used to encode business rules so that you literally cannot create incorrect code. You can then use the static type checking almost as an instant unit test — making sure that your code is correct at compile time. In this talk, we'll look at some of the ways you can use types as part of a domain driven design process, with some simple real world examples in F#. No jargon, no maths, and no prior F# experience necessary.
The document discusses Scala, a programming language designed to be scalable. It can be used for both small and large programs. Scala combines object-oriented and functional programming. It interoperates seamlessly with Java but allows developers to add new constructs like actors through libraries. The Scala community is growing, with industrial adoption starting at companies like Twitter.
This document discusses intrinsic methods in the HotSpot JVM. It provides background on what intrinsic methods are and how they are implemented and optimized in JVMs and native compilers. It gives examples of intrinsic methods in HotSpot VM like System.currentTimeMillis(), Unsafe.compareAndSwapInt(), and Math.log(). It also discusses intrinsic methods added in TaobaoJDK like TCrc32 and how to experiment implementing your own intrinsic methods in the C1 and C2 compilers.
The document discusses 2D arrays, including their definition as an array of arrays, implementation methods of row-major and column-major ordering, and formulas for calculating element addresses based on storage method. It also covers basic arithmetic operations on 2D arrays like addition, subtraction, and multiplication. Examples of problems involving 2D arrays and their solutions are provided.
Domain Modeling Made Functional (DevTernity 2022)Scott Wlaschin
(video at https://fsharpforfunandprofit.com/ddd/)
Statically typed functional programming languages encourage a very different way of thinking about types. The type system is your friend, not an annoyance, and can be used in many ways that might not be familiar to OO programmers. Types can be used to represent the domain in a fine-grained, self documenting way. And in many cases, types can even be used to encode business rules so that you literally cannot create incorrect code. You can then use the static type checking almost as an instant unit test — making sure that your code is correct at compile time. In this talk, we'll look at some of the ways you can use types as part of a domain driven design process, with some simple real world examples in F#. No jargon, no maths, and no prior F# experience necessary.
The document discusses Scala, a programming language designed to be scalable. It can be used for both small and large programs. Scala combines object-oriented and functional programming. It interoperates seamlessly with Java but allows developers to add new constructs like actors through libraries. The Scala community is growing, with industrial adoption starting at companies like Twitter.
This document discusses intrinsic methods in the HotSpot JVM. It provides background on what intrinsic methods are and how they are implemented and optimized in JVMs and native compilers. It gives examples of intrinsic methods in HotSpot VM like System.currentTimeMillis(), Unsafe.compareAndSwapInt(), and Math.log(). It also discusses intrinsic methods added in TaobaoJDK like TCrc32 and how to experiment implementing your own intrinsic methods in the C1 and C2 compilers.
The document discusses 2D arrays, including their definition as an array of arrays, implementation methods of row-major and column-major ordering, and formulas for calculating element addresses based on storage method. It also covers basic arithmetic operations on 2D arrays like addition, subtraction, and multiplication. Examples of problems involving 2D arrays and their solutions are provided.
^Regular Expressions is one of those tools that every developer should have in their toolbox. You can do your job without regular expressions, but knowing when and how to use them will make you a much more efficient and marketable developer. You'll learn how regular expressions can be used for validating user input, parsing text, and refactoring code. We'll also cover various tools that can be used to help you write and share expressions.$
Domain Driven Design with the F# type System -- F#unctional Londoners 2014Scott Wlaschin
(Video of these slides here http://fsharpforfunandprofit.com/ddd)
Statically typed functional programming languages like F# encourage a very different way of thinking about types. The type system is your friend, not an annoyance, and can be used in many ways that might not be familiar to OO programmers.
Types can be used to represent the domain in a fine-grained, self documenting way. And in many cases, types can even be used to encode business rules so that you literally cannot create incorrect code. You can then use the static type checking almost as an instant unit test — making sure that your code is correct at compile time.
In this talk, we'll look at some of the ways you can use types as part of a domain driven design process, with some simple real world examples in F#. No jargon, no maths, and no prior F# experience necessary.
Code, links to video, etc., at http://fsharpforfunandprofit.com/ddd
NEW AND IMPROVED - added sections on:
* why OO, not FP is scary
* designing with states and transitions
This document compares and contrasts Clojure and Elixir programming languages. It provides an overview of their origins, syntax, concurrency models, macro systems, and further reading recommendations. Key points include Clojure running on the JVM while Elixir runs on the BEAM VM, both having Lisp-like syntax with differences in collection types, and both supporting metaprogramming through macros while having different macro expansion approaches.
Domain Modeling Made Functional (KanDDDinsky 2019)Scott Wlaschin
(video at https://fsharpforfunandprofit.com/ddd/)
Statically typed functional programming languages encourage a very different way of thinking about types. The type system is your friend, not an annoyance, and can be used in many ways that might not be familiar to OO programmers. Types can be used to represent the domain in a fine-grained, self documenting way. And in many cases, types can even be used to encode business rules so that you literally cannot create incorrect code. You can then use the static type checking almost as an instant unit test — making sure that your code is correct at compile time. In this talk, we'll look at some of the ways you can use types as part of a domain driven design process, with some simple real world examples in F#. No jargon, no maths, and no prior F# experience necessary.
In this chapter we are going to get familiar with recursion and its applications. Recursion represents a powerful programming technique in which a method makes a call to itself from within its own method body. By means of recursion we can solve complicated combinatorial problems, in which we can easily exhaust different combinatorial configurations, e.g. generating permutations and variations and simulating nested loops. We are going to demonstrate many examples of correct and incorrect usage of recursion and convince you how useful it can be.
The document summarizes lecture 2 of the CIS-122 Data Structures course. It covers applications of stacks like arithmetic expressions, recursion, quicksort, and towers of Hanoi. It also discusses stack implementations using arrays and linked lists and provides examples of infix to postfix conversion and evaluating arithmetic expressions using a stack.
The document contains program code snippets for various networking lab programs including:
1. A CRC program to calculate and check CRC of transmitted data frames.
2. A distance vector routing program to calculate shortest paths between nodes in a network.
3. A FIFO client and server program for inter-process communication using named pipes.
4. Other programs for frame sorting, Hamming code, leaky bucket algorithm, RSA encryption, and a TCP client.
Laziness, trampolines, monoids and other functional amenities: this is not yo...Mario Fusco
The document discusses functional programming concepts like higher-order functions, function composition, currying, and lazy evaluation. It provides examples of implementing strategies like converting between units using functions and creating streams of prime numbers lazily to avoid stack overflows. Tail call optimization is mentioned as a way to avoid stack overflows with recursive functions.
A quick tutorial on what debuggers are and how to use them. We present a debugging example using GDB. At the end of this tutorial, you will be able to work your way through a crash and analyze the cause of the error responsible for the crash.
introduction to c programming and C History.pptxManojKhadilkar1
C programming was developed by Dennis Ritchie at Bell Labs in 1972. It was derived from an earlier language called BCPL. A C program typically includes source code, which is compiled into object code and linked to produce an executable file. The structure of a C program includes sections for documentation, definitions, global declarations, functions, and the main function.
Declare Your Language: Name ResolutionEelco Visser
Scope graphs are used to represent the binding information in programs. They provide a language-independent representation of name resolution that can be used to conduct and represent the results of name resolution. Separating the representation of resolved programs from the declarative rules that define name binding allows language-independent tooling to be developed for name resolution and other tasks.
^Regular Expressions is one of those tools that every developer should have in their toolbox. You can do your job without regular expressions, but knowing when and how to use them will make you a much more efficient and marketable developer. You'll learn how regular expressions can be used for validating user input, parsing text, and refactoring code. We'll also cover various tools that can be used to help you write and share expressions.$
Domain Driven Design with the F# type System -- F#unctional Londoners 2014Scott Wlaschin
(Video of these slides here http://fsharpforfunandprofit.com/ddd)
Statically typed functional programming languages like F# encourage a very different way of thinking about types. The type system is your friend, not an annoyance, and can be used in many ways that might not be familiar to OO programmers.
Types can be used to represent the domain in a fine-grained, self documenting way. And in many cases, types can even be used to encode business rules so that you literally cannot create incorrect code. You can then use the static type checking almost as an instant unit test — making sure that your code is correct at compile time.
In this talk, we'll look at some of the ways you can use types as part of a domain driven design process, with some simple real world examples in F#. No jargon, no maths, and no prior F# experience necessary.
Code, links to video, etc., at http://fsharpforfunandprofit.com/ddd
NEW AND IMPROVED - added sections on:
* why OO, not FP is scary
* designing with states and transitions
This document compares and contrasts Clojure and Elixir programming languages. It provides an overview of their origins, syntax, concurrency models, macro systems, and further reading recommendations. Key points include Clojure running on the JVM while Elixir runs on the BEAM VM, both having Lisp-like syntax with differences in collection types, and both supporting metaprogramming through macros while having different macro expansion approaches.
Domain Modeling Made Functional (KanDDDinsky 2019)Scott Wlaschin
(video at https://fsharpforfunandprofit.com/ddd/)
Statically typed functional programming languages encourage a very different way of thinking about types. The type system is your friend, not an annoyance, and can be used in many ways that might not be familiar to OO programmers. Types can be used to represent the domain in a fine-grained, self documenting way. And in many cases, types can even be used to encode business rules so that you literally cannot create incorrect code. You can then use the static type checking almost as an instant unit test — making sure that your code is correct at compile time. In this talk, we'll look at some of the ways you can use types as part of a domain driven design process, with some simple real world examples in F#. No jargon, no maths, and no prior F# experience necessary.
In this chapter we are going to get familiar with recursion and its applications. Recursion represents a powerful programming technique in which a method makes a call to itself from within its own method body. By means of recursion we can solve complicated combinatorial problems, in which we can easily exhaust different combinatorial configurations, e.g. generating permutations and variations and simulating nested loops. We are going to demonstrate many examples of correct and incorrect usage of recursion and convince you how useful it can be.
The document summarizes lecture 2 of the CIS-122 Data Structures course. It covers applications of stacks like arithmetic expressions, recursion, quicksort, and towers of Hanoi. It also discusses stack implementations using arrays and linked lists and provides examples of infix to postfix conversion and evaluating arithmetic expressions using a stack.
The document contains program code snippets for various networking lab programs including:
1. A CRC program to calculate and check CRC of transmitted data frames.
2. A distance vector routing program to calculate shortest paths between nodes in a network.
3. A FIFO client and server program for inter-process communication using named pipes.
4. Other programs for frame sorting, Hamming code, leaky bucket algorithm, RSA encryption, and a TCP client.
Laziness, trampolines, monoids and other functional amenities: this is not yo...Mario Fusco
The document discusses functional programming concepts like higher-order functions, function composition, currying, and lazy evaluation. It provides examples of implementing strategies like converting between units using functions and creating streams of prime numbers lazily to avoid stack overflows. Tail call optimization is mentioned as a way to avoid stack overflows with recursive functions.
A quick tutorial on what debuggers are and how to use them. We present a debugging example using GDB. At the end of this tutorial, you will be able to work your way through a crash and analyze the cause of the error responsible for the crash.
introduction to c programming and C History.pptxManojKhadilkar1
C programming was developed by Dennis Ritchie at Bell Labs in 1972. It was derived from an earlier language called BCPL. A C program typically includes source code, which is compiled into object code and linked to produce an executable file. The structure of a C program includes sections for documentation, definitions, global declarations, functions, and the main function.
Declare Your Language: Name ResolutionEelco Visser
Scope graphs are used to represent the binding information in programs. They provide a language-independent representation of name resolution that can be used to conduct and represent the results of name resolution. Separating the representation of resolved programs from the declarative rules that define name binding allows language-independent tooling to be developed for name resolution and other tasks.
The document discusses various operators in Python including assignment, comparison, logical, identity, and membership operators. It provides examples of how each operator works and the output. Specifically, it explains that assignment operators are used to assign values to variables using shortcuts like +=, -=, etc. Comparison operators compare values and return True or False. Logical operators combine conditional statements using and, or, and not. Identity operators compare the memory location of objects using is and is not. Membership operators test if a value is present in a sequence using in and not in.
A formalization of complex event stream processingSylvain Hallé
Information systems in general, and business processes in particular, generate a wealth of information in the form of event traces or logs. The analysis of these logs, either offline or in real-time, can be put to numerous uses: computation of various statistics, detection of anomalous patterns or compliance violations of some form of contract. However, current solutions for Complex Event Processing (CEP) generally offer only a restricted set of predefined queries on traces, and otherwise require a user to write procedural code to compute custom queries. In this presentation, we present a formal and declarative language for the manipulation of event traces.
Module II Partition and Generating Function (2).pptssuser26e219
This document provides an overview of module 2 of the course "Discrete Mathematics for IT". The module covers topics related to relations and functions, including properties of binary relations, closure of relations, Warshall's algorithm, equivalence relations and partitions, partial ordering relations, functions, composition of functions, invertible functions, and the pigeonhole principle. It also discusses discrete numeric functions, generating functions, and linear recurrence relations with constant coefficients.
The document provides an overview of key concepts in programming with examples, including:
- Identifiers, variables, data types, literals and constants
- Expressions, operators, precedence and order of evaluation
- Input/output using dialog boxes
- Common errors like syntax, runtime, logic errors
- Style and documentation guidelines
This document provides a quick tour of the Python programming language. It introduces basic Python concepts like data types, variables, operators, conditional statements, loops, and functions. It explains how to get user input, perform type conversions, and work with common data types like integers, floats, strings, and booleans. It also demonstrates how to define functions, use default arguments and keyword arguments, and handle global variables. The document uses examples to illustrate concepts like arithmetic operations, string slicing, indexing, concatenation, and repetition.
The document discusses different types of functions in programming. It explains that built-in functions are predefined, modular functions are contained in imported modules, and user-defined functions are created using the def keyword. It also discusses function definitions, calling functions, arguments, parameters, and the return statement. Functions can accept inputs, perform tasks, and produce outputs.
The document provides an overview of higher-kinds, typeclasses, type-level encodings, and continuations in Scala. It discusses how kind systems classify types, how typeclasses allow abstraction over types, and examples of encoding data structures like linked lists at the type level. It also introduces delimited continuations in Scala and how they can be used to simulate control flow constructs like break statements.
The document discusses various operators in the C programming language. It begins by defining C operators as symbols that are used to perform logical and mathematical operations. It then describes the different types of operators in C - arithmetic, assignment, relational, logical, bitwise, conditional (ternary), and increment/decrement operators. For each type of operator, it provides examples and an example program to demonstrate their usage.
This document provides an overview of Python data types. It discusses numeric data types like integer and float, as well as sequence data types like strings, lists, and tuples. It also covers boolean, set, and dictionary data types. For each data type, it provides examples of how to define and use variables of that type in Python code, as well as built-in functions like type() and operations that can be performed. The document contains questions for readers and exercises to test understanding of Python data types.
The document provides information about Python programming language:
- Python was created in the late 1980s and became widely popular in the early 2000s.
- It is a high-level, general-purpose, interpreted programming language that can be used for web, desktop, game development, data science, and more.
- Some key features of Python include dynamic typing, automatic memory management, and being multi-paradigm supporting object-oriented, imperative, functional programming styles.
The document discusses Python functions. Some key points covered include:
- Functions are reusable blocks of code defined using the def keyword that can accept parameters and return values.
- To execute a function, it must be called by name with appropriate arguments.
- Functions can call themselves, which is known as recursion.
- Functions can have default, variable, and keyword parameters to provide flexibility in how they are called.
This document discusses data types in Python. It describes the main numeric, string, boolean, and container data types. For numeric types, it explains integers, floating point numbers, complex numbers, and how to convert between them. For strings, it demonstrates indexing, slicing, concatenation and iteration. It also discusses booleans, lists, tuples, sets and dictionaries. The document then covers operators in Python like arithmetic, comparison, logical and bitwise operators. It provides examples of using each operator and precedence rules. Finally, it briefly discusses expressions and type conversion.
The document summarizes the different types of operators in Java, including arithmetic, relational, conditional, and bitwise operators. It provides examples of each type of operator and how they are used in Java code. The main types of operators covered are assignment, arithmetic, unary, relational, conditional, type comparison, and bitwise/bit shift operators. Examples are given to demonstrate how each operator is used and the output it produces.
Slides accompanying talk at : https://youtu.be/vtUiZkHVi-w
Come learn about Python typing, and we'll cover the type system as well as the mypy tool and all the tools that you need for your typing needs.
Given to HSV.py on Nov 8th, 2019
(video of these slides available here http://fsharpforfunandprofit.com/fppatterns/)
In object-oriented development, we are all familiar with design patterns such as the Strategy pattern and Decorator pattern, and design principles such as SOLID.
The functional programming community has design patterns and principles as well.
This talk will provide an overview of some of these, and present some demonstrations of FP design in practice.
Similar to Row-based Effect Systems for Algebraic Effect Handlers (20)
"Frontline Battles with DDoS: Best practices and Lessons Learned", Igor IvaniukFwdays
At this talk we will discuss DDoS protection tools and best practices, discuss network architectures and what AWS has to offer. Also, we will look into one of the largest DDoS attacks on Ukrainian infrastructure that happened in February 2022. We'll see, what techniques helped to keep the web resources available for Ukrainians and how AWS improved DDoS protection for all customers based on Ukraine experience
HCL Notes and Domino License Cost Reduction in the World of DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-and-domino-license-cost-reduction-in-the-world-of-dlau/
The introduction of DLAU and the CCB & CCX licensing model caused quite a stir in the HCL community. As a Notes and Domino customer, you may have faced challenges with unexpected user counts and license costs. You probably have questions on how this new licensing approach works and how to benefit from it. Most importantly, you likely have budget constraints and want to save money where possible. Don’t worry, we can help with all of this!
We’ll show you how to fix common misconfigurations that cause higher-than-expected user counts, and how to identify accounts which you can deactivate to save money. There are also frequent patterns that can cause unnecessary cost, like using a person document instead of a mail-in for shared mailboxes. We’ll provide examples and solutions for those as well. And naturally we’ll explain the new licensing model.
Join HCL Ambassador Marc Thomas in this webinar with a special guest appearance from Franz Walder. It will give you the tools and know-how to stay on top of what is going on with Domino licensing. You will be able lower your cost through an optimized configuration and keep it low going forward.
These topics will be covered
- Reducing license cost by finding and fixing misconfigurations and superfluous accounts
- How do CCB and CCX licenses really work?
- Understanding the DLAU tool and how to best utilize it
- Tips for common problem areas, like team mailboxes, functional/test users, etc
- Practical examples and best practices to implement right away
Skybuffer SAM4U tool for SAP license adoptionTatiana Kojar
Manage and optimize your license adoption and consumption with SAM4U, an SAP free customer software asset management tool.
SAM4U, an SAP complimentary software asset management tool for customers, delivers a detailed and well-structured overview of license inventory and usage with a user-friendly interface. We offer a hosted, cost-effective, and performance-optimized SAM4U setup in the Skybuffer Cloud environment. You retain ownership of the system and data, while we manage the ABAP 7.58 infrastructure, ensuring fixed Total Cost of Ownership (TCO) and exceptional services through the SAP Fiori interface.
Conversational agents, or chatbots, are increasingly used to access all sorts of services using natural language. While open-domain chatbots - like ChatGPT - can converse on any topic, task-oriented chatbots - the focus of this paper - are designed for specific tasks, like booking a flight, obtaining customer support, or setting an appointment. Like any other software, task-oriented chatbots need to be properly tested, usually by defining and executing test scenarios (i.e., sequences of user-chatbot interactions). However, there is currently a lack of methods to quantify the completeness and strength of such test scenarios, which can lead to low-quality tests, and hence to buggy chatbots.
To fill this gap, we propose adapting mutation testing (MuT) for task-oriented chatbots. To this end, we introduce a set of mutation operators that emulate faults in chatbot designs, an architecture that enables MuT on chatbots built using heterogeneous technologies, and a practical realisation as an Eclipse plugin. Moreover, we evaluate the applicability, effectiveness and efficiency of our approach on open-source chatbots, with promising results.
The Microsoft 365 Migration Tutorial For Beginner.pptxoperationspcvita
This presentation will help you understand the power of Microsoft 365. However, we have mentioned every productivity app included in Office 365. Additionally, we have suggested the migration situation related to Office 365 and how we can help you.
You can also read: https://www.systoolsgroup.com/updates/office-365-tenant-to-tenant-migration-step-by-step-complete-guide/
Freshworks Rethinks NoSQL for Rapid Scaling & Cost-EfficiencyScyllaDB
Freshworks creates AI-boosted business software that helps employees work more efficiently and effectively. Managing data across multiple RDBMS and NoSQL databases was already a challenge at their current scale. To prepare for 10X growth, they knew it was time to rethink their database strategy. Learn how they architected a solution that would simplify scaling while keeping costs under control.
zkStudyClub - LatticeFold: A Lattice-based Folding Scheme and its Application...Alex Pruden
Folding is a recent technique for building efficient recursive SNARKs. Several elegant folding protocols have been proposed, such as Nova, Supernova, Hypernova, Protostar, and others. However, all of them rely on an additively homomorphic commitment scheme based on discrete log, and are therefore not post-quantum secure. In this work we present LatticeFold, the first lattice-based folding protocol based on the Module SIS problem. This folding protocol naturally leads to an efficient recursive lattice-based SNARK and an efficient PCD scheme. LatticeFold supports folding low-degree relations, such as R1CS, as well as high-degree relations, such as CCS. The key challenge is to construct a secure folding protocol that works with the Ajtai commitment scheme. The difficulty, is ensuring that extracted witnesses are low norm through many rounds of folding. We present a novel technique using the sumcheck protocol to ensure that extracted witnesses are always low norm no matter how many rounds of folding are used. Our evaluation of the final proof system suggests that it is as performant as Hypernova, while providing post-quantum security.
Paper Link: https://eprint.iacr.org/2024/257
Taking AI to the Next Level in Manufacturing.pdfssuserfac0301
Read Taking AI to the Next Level in Manufacturing to gain insights on AI adoption in the manufacturing industry, such as:
1. How quickly AI is being implemented in manufacturing.
2. Which barriers stand in the way of AI adoption.
3. How data quality and governance form the backbone of AI.
4. Organizational processes and structures that may inhibit effective AI adoption.
6. Ideas and approaches to help build your organization's AI strategy.
What is an RPA CoE? Session 1 – CoE VisionDianaGray10
In the first session, we will review the organization's vision and how this has an impact on the COE Structure.
Topics covered:
• The role of a steering committee
• How do the organization’s priorities determine CoE Structure?
Speaker:
Chris Bolin, Senior Intelligent Automation Architect Anika Systems
Monitoring and Managing Anomaly Detection on OpenShift.pdfTosin Akinosho
Monitoring and Managing Anomaly Detection on OpenShift
Overview
Dive into the world of anomaly detection on edge devices with our comprehensive hands-on tutorial. This SlideShare presentation will guide you through the entire process, from data collection and model training to edge deployment and real-time monitoring. Perfect for those looking to implement robust anomaly detection systems on resource-constrained IoT/edge devices.
Key Topics Covered
1. Introduction to Anomaly Detection
- Understand the fundamentals of anomaly detection and its importance in identifying unusual behavior or failures in systems.
2. Understanding Edge (IoT)
- Learn about edge computing and IoT, and how they enable real-time data processing and decision-making at the source.
3. What is ArgoCD?
- Discover ArgoCD, a declarative, GitOps continuous delivery tool for Kubernetes, and its role in deploying applications on edge devices.
4. Deployment Using ArgoCD for Edge Devices
- Step-by-step guide on deploying anomaly detection models on edge devices using ArgoCD.
5. Introduction to Apache Kafka and S3
- Explore Apache Kafka for real-time data streaming and Amazon S3 for scalable storage solutions.
6. Viewing Kafka Messages in the Data Lake
- Learn how to view and analyze Kafka messages stored in a data lake for better insights.
7. What is Prometheus?
- Get to know Prometheus, an open-source monitoring and alerting toolkit, and its application in monitoring edge devices.
8. Monitoring Application Metrics with Prometheus
- Detailed instructions on setting up Prometheus to monitor the performance and health of your anomaly detection system.
9. What is Camel K?
- Introduction to Camel K, a lightweight integration framework built on Apache Camel, designed for Kubernetes.
10. Configuring Camel K Integrations for Data Pipelines
- Learn how to configure Camel K for seamless data pipeline integrations in your anomaly detection workflow.
11. What is a Jupyter Notebook?
- Overview of Jupyter Notebooks, an open-source web application for creating and sharing documents with live code, equations, visualizations, and narrative text.
12. Jupyter Notebooks with Code Examples
- Hands-on examples and code snippets in Jupyter Notebooks to help you implement and test anomaly detection models.
5th LF Energy Power Grid Model Meet-up SlidesDanBrown980551
5th Power Grid Model Meet-up
It is with great pleasure that we extend to you an invitation to the 5th Power Grid Model Meet-up, scheduled for 6th June 2024. This event will adopt a hybrid format, allowing participants to join us either through an online Mircosoft Teams session or in person at TU/e located at Den Dolech 2, Eindhoven, Netherlands. The meet-up will be hosted by Eindhoven University of Technology (TU/e), a research university specializing in engineering science & technology.
Power Grid Model
The global energy transition is placing new and unprecedented demands on Distribution System Operators (DSOs). Alongside upgrades to grid capacity, processes such as digitization, capacity optimization, and congestion management are becoming vital for delivering reliable services.
Power Grid Model is an open source project from Linux Foundation Energy and provides a calculation engine that is increasingly essential for DSOs. It offers a standards-based foundation enabling real-time power systems analysis, simulations of electrical power grids, and sophisticated what-if analysis. In addition, it enables in-depth studies and analysis of the electrical power grid’s behavior and performance. This comprehensive model incorporates essential factors such as power generation capacity, electrical losses, voltage levels, power flows, and system stability.
Power Grid Model is currently being applied in a wide variety of use cases, including grid planning, expansion, reliability, and congestion studies. It can also help in analyzing the impact of renewable energy integration, assessing the effects of disturbances or faults, and developing strategies for grid control and optimization.
What to expect
For the upcoming meetup we are organizing, we have an exciting lineup of activities planned:
-Insightful presentations covering two practical applications of the Power Grid Model.
-An update on the latest advancements in Power Grid -Model technology during the first and second quarters of 2024.
-An interactive brainstorming session to discuss and propose new feature requests.
-An opportunity to connect with fellow Power Grid Model enthusiasts and users.
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/temporal-event-neural-networks-a-more-efficient-alternative-to-the-transformer-a-presentation-from-brainchip/
Chris Jones, Director of Product Management at BrainChip , presents the “Temporal Event Neural Networks: A More Efficient Alternative to the Transformer” tutorial at the May 2024 Embedded Vision Summit.
The expansion of AI services necessitates enhanced computational capabilities on edge devices. Temporal Event Neural Networks (TENNs), developed by BrainChip, represent a novel and highly efficient state-space network. TENNs demonstrate exceptional proficiency in handling multi-dimensional streaming data, facilitating advancements in object detection, action recognition, speech enhancement and language model/sequence generation. Through the utilization of polynomial-based continuous convolutions, TENNs streamline models, expedite training processes and significantly diminish memory requirements, achieving notable reductions of up to 50x in parameters and 5,000x in energy consumption compared to prevailing methodologies like transformers.
Integration with BrainChip’s Akida neuromorphic hardware IP further enhances TENNs’ capabilities, enabling the realization of highly capable, portable and passively cooled edge devices. This presentation delves into the technical innovations underlying TENNs, presents real-world benchmarks, and elucidates how this cutting-edge approach is positioned to revolutionize edge AI across diverse applications.
Have you ever been confused by the myriad of choices offered by AWS for hosting a website or an API?
Lambda, Elastic Beanstalk, Lightsail, Amplify, S3 (and more!) can each host websites + APIs. But which one should we choose?
Which one is cheapest? Which one is fastest? Which one will scale to meet our needs?
Join me in this session as we dive into each AWS hosting service to determine which one is best for your scenario and explain why!
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/how-axelera-ai-uses-digital-compute-in-memory-to-deliver-fast-and-energy-efficient-computer-vision-a-presentation-from-axelera-ai/
Bram Verhoef, Head of Machine Learning at Axelera AI, presents the “How Axelera AI Uses Digital Compute-in-memory to Deliver Fast and Energy-efficient Computer Vision” tutorial at the May 2024 Embedded Vision Summit.
As artificial intelligence inference transitions from cloud environments to edge locations, computer vision applications achieve heightened responsiveness, reliability and privacy. This migration, however, introduces the challenge of operating within the stringent confines of resource constraints typical at the edge, including small form factors, low energy budgets and diminished memory and computational capacities. Axelera AI addresses these challenges through an innovative approach of performing digital computations within memory itself. This technique facilitates the realization of high-performance, energy-efficient and cost-effective computer vision capabilities at the thin and thick edge, extending the frontier of what is achievable with current technologies.
In this presentation, Verhoef unveils his company’s pioneering chip technology and demonstrates its capacity to deliver exceptional frames-per-second performance across a range of standard computer vision networks typical of applications in security, surveillance and the industrial sector. This shows that advanced computer vision can be accessible and efficient, even at the very edge of our technological ecosystem.
Discover top-tier mobile app development services, offering innovative solutions for iOS and Android. Enhance your business with custom, user-friendly mobile applications.
3. Algebraic effects & handlers
[Plotkin & Pretnar ’09, ’13]
• A mechanism to give user-defined effects
(a.k.a. to use continuations in a “well-structured” manner)
• Separating interfaces and implementations
of effects
• Invoked via operations
• Interpreted by handlers
• Handlers give the ability to call continuations
• Implemented as libraries or primitives in
languages such as Eff, Koka, Frank, etc.
!3
4. Example
effect fail : str ! unit
let div (x:int) (y:int) =
if y = 0 then (#fail “div0”; -1)
else x / y
let f (x:int) : (str,int) either =
handle (div 42 x) with
return (y:int) ! Right y
fail (y:str) ! Left y
!4
5. Example
effect fail : str ! unit
let div (x:int) (y:int) =
if y = 0 then (#fail “div0”; -1)
else x / y
let f (x:int) : (str,int) either =
handle (div 42 x) with
return (y:int) ! Right y
fail (y:str) ! Left y
Declare fail operation
!5
6. Example
effect fail : str ! unit
let div (x:int) (y:int) =
if y = 0 then (#fail “div0”; -1)
else x / y
let f (x:int) : (str,int) either =
handle (div 42 x) with
return (y:int) ! Right y
fail (y:str) ! Left y
Declare fail operation
Invoke fail
!6
7. Example
effect fail : str ! unit
let div (x:int) (y:int) =
if y = 0 then (#fail “div0”; -1)
else x / y
let f (x:int) : (str,int) either =
handle (div 42 x) with
return (y:int) ! Right y
fail (y:str) ! Left y
Declare fail operation
Invoke fail
Inject interpretation into effects
invoked in “div 42 x”
!7
8. Example
effect fail : str ! unit
let div (x:int) (y:int) =
if y = 0 then (#fail “div0”; -1)
else x / y
let f (x:int) : (str,int) either =
handle (div 42 x) with
return (y:int) ! Right y
fail (y:str) ! Left y
Declare fail operation
Invoke fail
Inject interpretation into effects
invoked in “div 42 x”
Interpretation of
fail operation
!8
9. Example
effect fail : str ! unit
let div (x:int) (y:int) =
if y = 0 then (#fail “div0”; -1)
else x / y
let f (x:int) : (str,int) either =
handle (div 42 x) with
return (y:int) ! Right y
fail (y:str) ! Left y
Declare fail operation
Invoke fail
Inject interpretation into effects
invoked in “div 42 x”
f 0 Left “div0”⟶
Interpretation of
fail operation
!8
10. Example
effect fail : str ! unit
let div (x:int) (y:int) =
if y = 0 then (#fail “div0”; -1)
else x / y
let f (x:int) : (str,int) either =
handle (div 42 x) with
return (y:int) ! Right y
fail (y:str) ! Left y
Declare fail operation
Invoke fail
f 0 Left “div0”⟶
Inject interpretation into effects
invoked in “div 42 x”
Evaluated with
the value of “div 42 x”
Interpretation of
fail operation
!9
11. Example
effect fail : str ! unit
let div (x:int) (y:int) =
if y = 0 then (#fail “div0”; -1)
else x / y
let f (x:int) : (str,int) either =
handle (div 42 x) with
return (y:int) ! Right y
fail (y:str) ! Left y
Declare fail operation
Invoke fail
f 7 Right 6⟶f 0 Left “div0”⟶
Inject interpretation into effects
invoked in “div 42 x”
Evaluated with
the value of “div 42 x”
Interpretation of
fail operation
!9
12. Resumption
Handlers support resumption of the computation
from the point of the effect invocation
• Reminiscent of delimited continuation
effect choose : int × int ! int
handle #choose(1,2) +
#choose(10,20) with
return (x:int) ! x
choose (x:int,y:int) ! resume x
!10
13. Resumption
Handlers support resumption of the computation
from the point of the effect invocation
• Reminiscent of delimited continuation
effect choose : int × int ! int
handle #choose(1,2) +
#choose(10,20) with
return (x:int) ! x
choose (x:int,y:int) ! resume x
!10
14. Resumption
Handlers support resumption of the computation
from the point of the effect invocation
• Reminiscent of delimited continuation
effect choose : int × int ! int
handle #choose(1,2) +
#choose(10,20) with
return (x:int) ! x
choose (x:int,y:int) ! resume x
!10
15. Resumption
Handlers support resumption of the computation
from the point of the effect invocation
• Reminiscent of delimited continuation
effect choose : int × int ! int
handle #choose(1,2) +
#choose(10,20) with
return (x:int) ! x
choose (x:int,y:int) ! resume x
Return x as
the result of #choose
!11
16. Resumption
Handlers support resumption of the computation
from the point of the effect invocation
• Reminiscent of delimited continuation
effect choose : int × int ! int
handle #choose(1,2) +
#choose(10,20) with
return (x:int) ! x
choose (x:int,y:int) ! resume x
Return x as
the result of #choose
!11
17. Resumption
Handlers support resumption of the computation
from the point of the effect invocation
• Reminiscent of delimited continuation
effect choose : int × int ! int
handle #choose(1,2) +
#choose(10,20) with
return (x:int) ! x
choose (x:int,y:int) ! resume x
x := 1
Return x as
the result of #choose
!11
18. Resumption
Handlers support resumption of the computation
from the point of the effect invocation
• Reminiscent of delimited continuation
effect choose : int × int ! int
handle 1 +
#choose(10,20) with
return (x:int) ! x
choose (x:int,y:int) ! resume x
x := 1
Return x as
the result of #choose
!12
19. Resumption
Handlers support resumption of the computation
from the point of the effect invocation
• Reminiscent of delimited continuation
effect choose : int × int ! int
handle 1 +
#choose(10,20) with
return (x:int) ! x
choose (x:int,y:int) ! resume x
Return x as
the result of #choose
!13
20. Resumption
Handlers support resumption of the computation
from the point of the effect invocation
• Reminiscent of delimited continuation
effect choose : int × int ! int
handle 1 +
#choose(10,20) with
return (x:int) ! x
choose (x:int,y:int) ! resume x
Return x as
the result of #choose
!13
21. Resumption
effect choose : int × int ! int
handle 1 +
10 with
return (x:int) ! x
choose (x:int,y:int) ! resume x
Handlers support resumption of the computation
from the point of the effect invocation
• Reminiscent of delimited continuation
Return x as
the result of #choose
!14
22. Parameterized effects
effect α choose : α × α ! α
handle if #choose(true,false)
then 1 else 2 with
return (x:int) ! #choose(10,20) + x
bool choose (x,y) ! resume (x && y)
!15
23. Parameterized effects
effect α choose : α × α ! α
handle if #choose(true,false)
then 1 else 2 with
return (x:int) ! #choose(10,20) + x
bool choose (x,y) ! resume (x && y)
!16
Signature is parameterized over types
24. Parameterized effects
effect α choose : α × α ! α
handle if #choose(true,false)
then 1 else 2 with
return (x:int) ! #choose(10,20) + x
bool choose (x,y) ! resume (x && y)
!17
Signature is parameterized over types
α := bool
25. Parameterized effects
effect α choose : α × α ! α
handle if #choose(true,false)
then 1 else 2 with
return (x:int) ! #choose(10,20) + x
bool choose (x,y) ! resume (x && y)
!18
Signature is parameterized over types
α := bool
Effect “bool choose” is handled
26. Parameterized effects
effect α choose : α × α ! α
handle if #choose(true,false)
then 1 else 2 with
return (x:int) ! #choose(10,20) + x
bool choose (x,y) ! resume (x && y)
!19
Signature is parameterized over types
α := bool
α := int
Effect “bool choose” is handled
27. Parameterized effects
effect α choose : α × α ! α
handle if #choose(true,false)
then 1 else 2 with
return (x:int) ! #choose(10,20) + x
bool choose (x,y) ! resume (x && y)
!19
Effect “int choose” will be
handled by an outer handler
Signature is parameterized over types
α := bool
α := int
Effect “bool choose” is handled
30. Motivation
Detection of “Handler-Not-Found” error
!21
effect fail : str ! unit
let div (x:int) (y:int) =
if y = 0 then (#fail “div0”; -1)
else x / y
div 10 0
There are no
handlers for #fail
31. Effect(-and-type) system
A means to detect invoked effects statically
• Types contain information about effects
!22
τ1 ! τ2Function type
32. Effect(-and-type) system
A means to detect invoked effects statically
• Types contain information about effects
!22
τ1 ! τ2Function type ε
Functions of this type may invoke effects ε
33. Row-based effect system
[Hillerström+ ’16; Leijen ’17; Lindley+ 17]
Effects ε are represented by a row
• It is originated from record typing
• Supported by Koka, Frank, Links, etc.
!23
34. Row-based effect system
[Hillerström+ ’16; Leijen ’17; Lindley+ 17]
Effects ε are represented by a row
• It is originated from record typing
• Supported by Koka, Frank, Links, etc.
!23
A sequence of effect names
〈 fail, int choose, … 〉
35. Row-based effect system
[Hillerström+ ’16; Leijen ’17; Lindley+ 17]
Effects ε are represented by a row
• It is originated from record typing
• Supported by Koka, Frank, Links, etc.
!23
A sequence of effect names
〈 fail, int choose, … 〉
τ1 !〈fail, int choose〉τ2
36. Row-based effect system
[Hillerström+ ’16; Leijen ’17; Lindley+ 17]
Effects ε are represented by a row
• It is originated from record typing
• Supported by Koka, Frank, Links, etc.
!23
A sequence of effect names
〈 fail, int choose, … 〉
Given to functions that may invoke
only “fail" and/or “int choose”
τ1 !〈fail, int choose〉τ2
37. Example
effect fail : str ! unit
let div (x:int) (y:int) =
if y = 0 then (#fail “div0”; -1)
else x / y
!24
let f (x:int) : (str,int) either =
handle (div 42 x) with
return (y:int) ! Right y
fail (y:str) ! Left y
38. Example
effect fail : str ! unit
let div (x:int) (y:int) =
if y = 0 then (#fail “div0”; -1)
else x / y
!24
div : int !〈〉int !〈fail〉int
let f (x:int) : (str,int) either =
handle (div 42 x) with
return (y:int) ! Right y
fail (y:str) ! Left y
39. Example
effect fail : str ! unit
let div (x:int) (y:int) =
if y = 0 then (#fail “div0”; -1)
else x / y
!24
div : int !〈〉int !〈fail〉int
let f (x:int) : (str,int) either =
handle (div 42 x) with
return (y:int) ! Right y
fail (y:str) ! Left y
f : int !〈〉(str, int) either
42. Example
!27
effect fail : str ! unit
type α opt = Some of α | None
let to-maybe (f : unit !〈fail〉α) : α opt =
handle f () with
return x ! Some x
fail _ ! None
to-maybe : ∀α. (unit !〈fail〉α) !〈〉α opt
43. Example
!27
effect fail : str ! unit
type α opt = Some of α | None
let to-maybe (f : unit !〈fail〉α) : α opt =
handle f () with
return x ! Some x
fail _ ! None
Problem: to-maybe cannot be applied to
functions invoking effects other than fail
Ex: to-maybe (fun () ! #choose(1,2))
to-maybe : ∀α. (unit !〈fail〉α) !〈〉α opt
44. Row polymorphism
Allowing functions to be parameterized over rows
!28
effect fail : str ! unit
let to-maybe (f : unit !〈fail, ρ〉α) =
handle f () with
return x ! Some x
fail _ ! None
45. Row polymorphism
Allowing functions to be parameterized over rows
!28
effect fail : str ! unit
let to-maybe (f : unit !〈fail, ρ〉α) =
handle f () with
return x ! Some x
fail _ ! None
Row variable
f will invoke fail and/or
effects substituted for ρ
46. Row polymorphism
Allowing functions to be parameterized over rows
!28
effect fail : str ! unit
let to-maybe (f : unit !〈fail, ρ〉α) =
handle f () with
return x ! Some x
fail _ ! None
∀α,ρ. (unit !〈fail,ρ〉α) !〈ρ〉α opt
to-maybe (fun () ! #choose(1,2))
by instantiating ρ with〈int choose〉
Row variable
f will invoke fail and/or
effects substituted for ρ
48. Duplication of effect names
• An effect can occur in multiple positions in a row
• Multiple parameterized effects with the same
name can occur in a row
!30
〈fail, int choose, fail〉
〈fail, int choose, bool choose〉
49. Benefits of duplication
• Functions can invoke effects given different
type parameters
• Simplifying the effect system, especially, with
row polymorphism
• Support for abstract effects
!31
50. Benefits of duplication
• Functions can invoke effects given different
type parameters
• Simplifying the effect system, especially, with
row polymorphism
• Support for abstract effects
!32
51. Benefit 1
Functions can invoke effects given different type
parameters
!33
let f () =
if #choose(true, false)
then #choose(1, 2)
else #choose(10, 20)
52. Benefit 1
Functions can invoke effects given different type
parameters
!33
let f () =
if #choose(true, false)
then #choose(1, 2)
else #choose(10, 20)
bool choose
53. Benefit 1
Functions can invoke effects given different type
parameters
!33
let f () =
if #choose(true, false)
then #choose(1, 2)
else #choose(10, 20)
bool choose
Int chooseint choose
54. Benefit 1
Functions can invoke effects given different type
parameters
!33
let f () =
if #choose(true, false)
then #choose(1, 2)
else #choose(10, 20)
bool choose
Int chooseint choose
f : unit !〈bool choose, int choose〉int
55. Handling duplicated effects
Effects are handled from the leftmost among
ones having the same name
!34
let f
(g : unit !〈int choose, bool choose〉unit) =
handle g () with
return x ! 0
int choose (x,y) ! 1
56. Handling duplicated effects
Effects are handled from the leftmost among
ones having the same name
!35
let f
(g : unit !〈int choose, bool choose〉unit) =
handle g () with
return x ! 0
bool choose (x,y) ! 1
57. Conclusion
• Algebraic effects & handlers are a means
to give user-defined effects
• Effect systems structure and analyze
effectful behavior of programs
• Row-based systems are expressive and
amenable
!36
58. Call for collaboration
Research interests
• New effect systems to capture and structure
effectful behavior
• Efficient implementation of effect handlers
• Practical applications of effects
(and continuations)
!37