•

2 likes•2,568 views

APL is an interesting beast, with an immense level of expressiveness locked away in a syntax that instantly scares away all but the initiated. In this talk, we'll take a gentle introduction to APL and demonstrate its power to implement complex algorithms in very little code. We'll compare examples with equivalents in C# to illustrate why APL is much better suited as a "thinking tool" for programmers.

Report

Share

Report

Share

Download to read offline

Left and Right Folds- Comparison of a mathematical definition and a programm...

We compare typical definitions of the left and right fold functions, with their mathematical definitions in Sergei Winitzki’s upcoming book: The Science of Functional Programming.
Errata:
Slide 13: "The way 𝑓𝑜𝑙𝑑𝑙 does it is by associating to the right" - should, of course ,end in "to the left".

N-Queens Combinatorial Problem - Polyglot FP for Fun and Profit – Haskell and...

See how the guard function has migrated from MonadPlus to Alternative and learn something about the latter.
Learn how to write a Scala program that draws an N-Queens solution board using the Doodle graphics library.
See how to write the equivalent Haskell program using the Gloss graphics library.
Learn how to use Monoid and Foldable to compose images both in Haskell and in Scala.
Link to part 1: https://www.slideshare.net/pjschwarz/nqueens-combinatorial-problem-polyglot-fp-for-fun-and-profit-haskell-and-scala-part-1
Errata:
On slide 22, the last line of the showQueens function should of course be show(solution).draw(frame) rather than show(solution).draw
On slide 43, it would be better if the definitions of the beside, above and on Monoids were also shown.

Quicksort - a whistle-stop tour of the algorithm in five languages and four p...

Quicksort - a whistle-stop tour of the algorithm in five languages and four paradigms.
Programming Paradigms: Functional, Logic, Imperative, Imperative Functional
Languages: Haskell, Scala, Java, Clojure, Prolog

Haskell for data science

Slideshare hasn't imported my notes, so here's the link to the Google Presentation: https://goo.gl/Gl4Vhm
Haskell is a statically typed, non strict, pure functional programming language. It is often talked and blogged about, but rarely used commercially. This talk starts with a brief overview of the language, then explains how Haskell is evaluated and how it deals with non-determinism and side effects using only pure functions. The suitability of Haskell for real world data science is then discussed, along with some examples of its users, a small Haskell-powered visualization, and an overview of useful packages for data science. Finally, Accelerate is introduced, an embedded DSL for array computations on the GPU, and an ongoing attempt to use it as the basis for a deep learning package.

Functional Core and Imperative Shell - Game of Life Example - Haskell and Scala

See a program structure flowchart used to highlight how an FP program breaks down into a functional core and imperative shell
View a program structure flowchart for the Game of Life
See the code for Game of Life’s functional core and imperative shell, both in Haskell and in Scala.
Code:
https://github.com/philipschwarz/functional-core-imperative-shell-scala
https://github.com/philipschwarz/functional-core-imperative-shell-haskell

Procedural Programming: It’s Back? It Never Went Away

This document discusses procedural programming and the iterative process of designing systems through modularization and testing. It provides examples of early programming languages like Fortran that used procedural approaches with GOTOs and examples of refining algorithms through iterative testing against specifications. The document emphasizes writing modular, testable code and iterating the design process through refinement based on tests and specifications.

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - Part 5

(download for best quality slides) Gain a deeper understanding of why right folds over very large and infinite lists are sometimes possible in Haskell.
See how lazy evaluation and function strictness affect left and right folds in Haskell.
Learn when an ordinary left fold results in a space leak and how to avoid it using a strict left fold.
Errata:
slide 15: "as sharing is required" should be "as sharing is not required"
slide 43: 𝑠𝑓𝑜𝑙𝑑𝑙 (⊕) 𝑎 should be 𝑠𝑓𝑜𝑙𝑑𝑙 (⊕) 𝑒

Stack and Queue (brief)

The document discusses stacks and queues. A stack follows the LIFO (last in, first out) principle where the last element added is the first to be removed. Real-world examples include plates and books. Queues follow the FIFO (first in, first out) principle where the first element added is the first to be removed, as seen with ticket lines. Visual simulations and examples of using stacks for recursion and queues for threading are provided.

Left and Right Folds- Comparison of a mathematical definition and a programm...

We compare typical definitions of the left and right fold functions, with their mathematical definitions in Sergei Winitzki’s upcoming book: The Science of Functional Programming.
Errata:
Slide 13: "The way 𝑓𝑜𝑙𝑑𝑙 does it is by associating to the right" - should, of course ,end in "to the left".

N-Queens Combinatorial Problem - Polyglot FP for Fun and Profit – Haskell and...

See how the guard function has migrated from MonadPlus to Alternative and learn something about the latter.
Learn how to write a Scala program that draws an N-Queens solution board using the Doodle graphics library.
See how to write the equivalent Haskell program using the Gloss graphics library.
Learn how to use Monoid and Foldable to compose images both in Haskell and in Scala.
Link to part 1: https://www.slideshare.net/pjschwarz/nqueens-combinatorial-problem-polyglot-fp-for-fun-and-profit-haskell-and-scala-part-1
Errata:
On slide 22, the last line of the showQueens function should of course be show(solution).draw(frame) rather than show(solution).draw
On slide 43, it would be better if the definitions of the beside, above and on Monoids were also shown.

Quicksort - a whistle-stop tour of the algorithm in five languages and four p...

Quicksort - a whistle-stop tour of the algorithm in five languages and four paradigms.
Programming Paradigms: Functional, Logic, Imperative, Imperative Functional
Languages: Haskell, Scala, Java, Clojure, Prolog

Haskell for data science

Slideshare hasn't imported my notes, so here's the link to the Google Presentation: https://goo.gl/Gl4Vhm
Haskell is a statically typed, non strict, pure functional programming language. It is often talked and blogged about, but rarely used commercially. This talk starts with a brief overview of the language, then explains how Haskell is evaluated and how it deals with non-determinism and side effects using only pure functions. The suitability of Haskell for real world data science is then discussed, along with some examples of its users, a small Haskell-powered visualization, and an overview of useful packages for data science. Finally, Accelerate is introduced, an embedded DSL for array computations on the GPU, and an ongoing attempt to use it as the basis for a deep learning package.

Functional Core and Imperative Shell - Game of Life Example - Haskell and Scala

See a program structure flowchart used to highlight how an FP program breaks down into a functional core and imperative shell
View a program structure flowchart for the Game of Life
See the code for Game of Life’s functional core and imperative shell, both in Haskell and in Scala.
Code:
https://github.com/philipschwarz/functional-core-imperative-shell-scala
https://github.com/philipschwarz/functional-core-imperative-shell-haskell

Procedural Programming: It’s Back? It Never Went Away

This document discusses procedural programming and the iterative process of designing systems through modularization and testing. It provides examples of early programming languages like Fortran that used procedural approaches with GOTOs and examples of refining algorithms through iterative testing against specifications. The document emphasizes writing modular, testable code and iterating the design process through refinement based on tests and specifications.

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - Part 5

(download for best quality slides) Gain a deeper understanding of why right folds over very large and infinite lists are sometimes possible in Haskell.
See how lazy evaluation and function strictness affect left and right folds in Haskell.
Learn when an ordinary left fold results in a space leak and how to avoid it using a strict left fold.
Errata:
slide 15: "as sharing is required" should be "as sharing is not required"
slide 43: 𝑠𝑓𝑜𝑙𝑑𝑙 (⊕) 𝑎 should be 𝑠𝑓𝑜𝑙𝑑𝑙 (⊕) 𝑒

Stack and Queue (brief)

The document discusses stacks and queues. A stack follows the LIFO (last in, first out) principle where the last element added is the first to be removed. Real-world examples include plates and books. Queues follow the FIFO (first in, first out) principle where the first element added is the first to be removed, as seen with ticket lines. Visual simulations and examples of using stacks for recursion and queues for threading are provided.

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - with ...

(download for perfect quality) - See how recursive functions and structural induction relate to recursive datatypes.
Follow along as the fold abstraction is introduced and explained.
Watch as folding is used to simplify the definition of recursive functions over recursive datatypes
Part 1 - through the work of Richard Bird and Graham Hutton.
This version corrects the following issues:
slide 7, 11 fib(0) is 0,rather than 1
slide 23: was supposed to be followed by 2-3 slides recapitulating definitions of factorial and fibonacci with and without foldr, plus translation to scala
slide 36: concat not invoked in concat example
slides 48 and 49: unwanted 'm' in definition of sum
throughout: a couple of typographical errors
throughout: several aesthetic imperfections (wrong font, wrong font colour)

Functional programming with haskell

This document provides an overview of functional programming with Haskell. It discusses key concepts of functional programming like immutable data structures and pure functions. It introduces Haskell types including basic types, tuples, lists, data types, and type classes. It covers Haskell functions like pattern matching, guards, and higher order functions. It also discusses Haskell concepts like laziness, currying, and polymorphism. Finally, it provides an introduction to monads in Haskell and discusses Haskell tools, frameworks, and performance.

The Functional Programming Triad of Folding, Scanning and Iteration - a first...

The document discusses implementing various functional programming concepts like folding, scanning, and iteration to solve problems involving converting between digit sequences and integers. It provides examples in Scala and Haskell of using fold left to implement a digits-to-integer function and the iterate function to implement an integer-to-digits function. It also discusses using techniques like pipes in Scala and the $ operator in Haskell to improve readability by ordering function applications in the sequence they will be executed.

Programming Paradigms Which One Is The Best?

The document discusses different programming paradigms and which one may be best. It describes object-oriented programming, imperative programming, and declarative programming. For each, it provides examples in code to illustrate the paradigm. It argues that while imperative programming is popular and easy, it can be error-prone and not scale well. Declarative programming is described as simpler, safer, and more scalable by declaring intent rather than implementation. In the end, the document concludes that no single paradigm is best, and that they are often used together in practice.

Introduction to Functional Languages

The document provides information about functional programming languages and concepts including:
1) Haskell and ML are introduced as functional languages with features like strong typing, algebraic data types, and pattern matching.
2) Core functional programming concepts are explained like referential transparency, higher-order functions, and recursion instead of iteration.
3) Fold functions are summarized as a way to iterate over lists in functional languages in both a left and right oriented way.

Sierpinski Triangle - Polyglot FP for Fun and Profit - Haskell and Scala

Take the very first baby steps on the path to doing graphics in Haskell and Scala.
Learn about a simple yet educational recursive algorithm producing images that are pleasing to the eye.
Learn how functional programs deal with the side effects required to draw images.
See how libraries like Gloss and Doodle make drawing Sierpinski’s triangle a doddle.
Code for this slide deck:
https://github.com/philipschwarz/sierpinski-triangle-haskell-gloss
https://github.com/philipschwarz/sierpinski-triangle-scala-cats-io
https://github.com/philipschwarz/sierpinski-triangle-scala-awt-and-doodle
Errata:
1. the title 'Sierpinski Triangle' on the front slide could be improved by replacing it with 'Sierpinski's Triangle'.
2. a couple of typos on two slides
3. the triangles drawn using Doodle are not equilateral, as intended but isosceles.
(UPDATE 2021-06-15 I opened PR https://github.com/creativescala/doodle/pull/99 and as a result, an equilateral triangle has now been added to Doodle: https://github.com/creativescala/doodle/commit/30d20efebcc2016942e9cdbae85fefca5b95fa3c).
Here is a corrected version of the deck: https://www.slideshare.net/pjschwarz/sierpinski-triangle-polyglot-fp-for-fun-and-profit-haskell-and-scala-with-minor-corrections

The Functional Programming Triad of fold, scan and iterate

In the functional programming paradigm, the programmer does not need to write any loops or use array indices. Instead, functional programers deal with iterative calculations by translating mathematical induction directly into code, so that they can reason about sequences as mathematical values. The implement mathematical induction by folding, scanning and iterating.
Ouch - a couple of occurrences of 'mathematical' are misspelled (missing h) :-(

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - Part ...

(download for flawless image quality) Can a left fold ever work over an infinite list? What about a right fold? Find out.
Learn about the other two functions used by functional programmers to implement mathematical induction: iterating and scanning.
Learn about the limitations of the accumulator technique and about tupling, a technique that is the dual of the accumulator trick.

Stack queue

The document discusses stacks and queues as data structures. It begins by defining a Node struct and List class to implement a linked list. It then provides an overview of stacks, including common stack operations like push and pop. Stacks follow LIFO order and can be implemented using arrays or linked lists. The document also discusses queue operations like enqueue and dequeue. Queues follow FIFO order and can also be implemented using arrays or linked lists. It provides examples of implementing both stacks and queues as classes with the appropriate member functions.

Csharp_List

This document provides an overview of programming with lists in C#. It discusses how to create and populate lists, add and remove items, and use built-in list methods like IndexOf, Sort, and Reverse. Contact information is provided for Micheal Ogundero of the Systems Engineering Department at University of Lagos, Nigeria for any questions.

Haskell

Some notes about the Haskell programming language and Functional Programming for intermediate programmers

LEC3-DS ALGO(updated).pdf

The document discusses circular linked lists and stacks. It begins by explaining circular linked lists, how they differ from regular singly and doubly linked lists, and how to implement operations like insertion and deletion in a circular linked list. It then covers stacks, including common stack operations like push and pop. Stacks can be implemented using either arrays or linked lists. The document provides examples of how to represent a stack using each data structure and perform operations on it. It also discusses applications of stacks, like evaluating arithmetic expressions in postfix notation using a stack.

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - Part 4

(download for flawless image quality) Can a left fold ever work over an infinite list? What about a right fold? Find out.
Learn about the other two functions used by functional programmers to implement mathematical induction: iterating and scanning.
Learn about the limitations of the accumulator technique and about tupling, a technique that is the dual of the accumulator trick.

The Functional Programming Triad of Folding, Scanning and Iteration - a first...

This slide deck can work both as an aide mémoire (memory jogger), or as a first (not completely trivial) example of using left folds, left scans and iteration, to implement mathematical induction.
Errata: on almost half of the slides there is some minor typo or imperfection or in some cases a minor error and in one case, an omission. See a later version for corrections and some improvements.
(for best quality images, either download or view here: https://philipschwarz.dev/fpilluminated/?page_id=455)
Scala code for latest version: https://github.com/philipschwarz/fp-fold-scan-iterate-triad-a-first-example-scala

Basic Sorting algorithms csharp

This slide explains three (3) basic sorting algorithms with codes on github. Bubble sort, Selection sort and insertion sort.
visit https://github.com/EngrMikolo/BasicSortingAlgorithms to checkout the codes

U3.stack queue

A queue is a data structure that follows the first-in, first-out (FIFO) principle. Elements are added to the rear of the queue and removed from the front. A queue can be implemented using an array, with indexes to track the front and rear elements. When an element is added (enqueued), the rear index is incremented; when an element is removed (dequeued), the front index is incremented and the element at that index is returned. The queue has a limited capacity based on the size of the array.

Reasoning about laziness

This document discusses reasoning about laziness in Haskell. It explains that functions and data constructors don't evaluate their arguments until needed. This laziness allows separating producers and consumers efficiently. However, laziness can also cause problems like space leaks from unevaluated thunks. The document demonstrates techniques like using seq, bang patterns and strict data types to control evaluation order and avoid space leaks. It also discusses how to determine which arguments a function evaluates strictly.

Monad Fact #4

Download for flawless quality (slides viewed online look a bit grainy and out of focus). A monad is an implementation of one of the minimal sets of monadic combinators, satisfying the laws of associativity and identity - see how compositional responsibilities are distributed in each combinator set

Scala 3 enum for a terser Option Monad Algebraic Data Type

(download for flawless slides)
* Explore a terser definition of the Option Monad that uses a Scala 3 enum as an Algebraic Data Type.
* In the process, have a tiny bit of fun with Scala 3 enums.
* Get a refresher on the Functor and Monad laws.
* See how easy it is to use Scala 3 extension methods, e.g. to add convenience methods and infix operators.
The diagrams for function composition and Kleisli composition were made using https://q.uiver.app/ by https://twitter.com/varkora.
Source code: https://github.com/philipschwarz/scala-3-enum-for-terser-option-monad-algebraic-data-type
Errata:
slide 14 is an unwanted leftover - it is the same as slide 15 minus a diagram.
on slide 19, the colons in the extension method declarations are not needed

Open addressiing &rehashing,extendiblevhashing

The document discusses various hash table implementation techniques. It describes open addressing hashing which resolves collisions by probing to the next empty cell. Linear probing is discussed as a collision resolution strategy where the next probe is the current index plus one. The document also covers separate chaining hashing which uses linked lists at each index to handle collisions, and double hashing which uses two hash functions to determine probe sequences.

PERL for QA - Important Commands and applications

This document provides an overview of the Perl programming language. It discusses where Perl is commonly used, its key features like text processing and database access. It then covers various Perl concepts like scalars, variables, user input, strings, conditionals, loops, arrays, hashes, file handling and regular expressions. It provides examples for working with scalars, strings, conditionals, loops and arrays. It also discusses the special $_ variable and functions like pop, push, shift and unshift for manipulating arrays. The document concludes with a brief discussion of subroutines.

Distributive Property

Refresh on Distributive Property. Lecture given on Sept. 22nd, 2008. Adaptation of previously created power point.

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - with ...

(download for perfect quality) - See how recursive functions and structural induction relate to recursive datatypes.
Follow along as the fold abstraction is introduced and explained.
Watch as folding is used to simplify the definition of recursive functions over recursive datatypes
Part 1 - through the work of Richard Bird and Graham Hutton.
This version corrects the following issues:
slide 7, 11 fib(0) is 0,rather than 1
slide 23: was supposed to be followed by 2-3 slides recapitulating definitions of factorial and fibonacci with and without foldr, plus translation to scala
slide 36: concat not invoked in concat example
slides 48 and 49: unwanted 'm' in definition of sum
throughout: a couple of typographical errors
throughout: several aesthetic imperfections (wrong font, wrong font colour)

Functional programming with haskell

This document provides an overview of functional programming with Haskell. It discusses key concepts of functional programming like immutable data structures and pure functions. It introduces Haskell types including basic types, tuples, lists, data types, and type classes. It covers Haskell functions like pattern matching, guards, and higher order functions. It also discusses Haskell concepts like laziness, currying, and polymorphism. Finally, it provides an introduction to monads in Haskell and discusses Haskell tools, frameworks, and performance.

The Functional Programming Triad of Folding, Scanning and Iteration - a first...

The document discusses implementing various functional programming concepts like folding, scanning, and iteration to solve problems involving converting between digit sequences and integers. It provides examples in Scala and Haskell of using fold left to implement a digits-to-integer function and the iterate function to implement an integer-to-digits function. It also discusses using techniques like pipes in Scala and the $ operator in Haskell to improve readability by ordering function applications in the sequence they will be executed.

Programming Paradigms Which One Is The Best?

The document discusses different programming paradigms and which one may be best. It describes object-oriented programming, imperative programming, and declarative programming. For each, it provides examples in code to illustrate the paradigm. It argues that while imperative programming is popular and easy, it can be error-prone and not scale well. Declarative programming is described as simpler, safer, and more scalable by declaring intent rather than implementation. In the end, the document concludes that no single paradigm is best, and that they are often used together in practice.

Introduction to Functional Languages

The document provides information about functional programming languages and concepts including:
1) Haskell and ML are introduced as functional languages with features like strong typing, algebraic data types, and pattern matching.
2) Core functional programming concepts are explained like referential transparency, higher-order functions, and recursion instead of iteration.
3) Fold functions are summarized as a way to iterate over lists in functional languages in both a left and right oriented way.

Sierpinski Triangle - Polyglot FP for Fun and Profit - Haskell and Scala

Take the very first baby steps on the path to doing graphics in Haskell and Scala.
Learn about a simple yet educational recursive algorithm producing images that are pleasing to the eye.
Learn how functional programs deal with the side effects required to draw images.
See how libraries like Gloss and Doodle make drawing Sierpinski’s triangle a doddle.
Code for this slide deck:
https://github.com/philipschwarz/sierpinski-triangle-haskell-gloss
https://github.com/philipschwarz/sierpinski-triangle-scala-cats-io
https://github.com/philipschwarz/sierpinski-triangle-scala-awt-and-doodle
Errata:
1. the title 'Sierpinski Triangle' on the front slide could be improved by replacing it with 'Sierpinski's Triangle'.
2. a couple of typos on two slides
3. the triangles drawn using Doodle are not equilateral, as intended but isosceles.
(UPDATE 2021-06-15 I opened PR https://github.com/creativescala/doodle/pull/99 and as a result, an equilateral triangle has now been added to Doodle: https://github.com/creativescala/doodle/commit/30d20efebcc2016942e9cdbae85fefca5b95fa3c).
Here is a corrected version of the deck: https://www.slideshare.net/pjschwarz/sierpinski-triangle-polyglot-fp-for-fun-and-profit-haskell-and-scala-with-minor-corrections

The Functional Programming Triad of fold, scan and iterate

In the functional programming paradigm, the programmer does not need to write any loops or use array indices. Instead, functional programers deal with iterative calculations by translating mathematical induction directly into code, so that they can reason about sequences as mathematical values. The implement mathematical induction by folding, scanning and iterating.
Ouch - a couple of occurrences of 'mathematical' are misspelled (missing h) :-(

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - Part ...

(download for flawless image quality) Can a left fold ever work over an infinite list? What about a right fold? Find out.
Learn about the other two functions used by functional programmers to implement mathematical induction: iterating and scanning.
Learn about the limitations of the accumulator technique and about tupling, a technique that is the dual of the accumulator trick.

Stack queue

The document discusses stacks and queues as data structures. It begins by defining a Node struct and List class to implement a linked list. It then provides an overview of stacks, including common stack operations like push and pop. Stacks follow LIFO order and can be implemented using arrays or linked lists. The document also discusses queue operations like enqueue and dequeue. Queues follow FIFO order and can also be implemented using arrays or linked lists. It provides examples of implementing both stacks and queues as classes with the appropriate member functions.

Csharp_List

This document provides an overview of programming with lists in C#. It discusses how to create and populate lists, add and remove items, and use built-in list methods like IndexOf, Sort, and Reverse. Contact information is provided for Micheal Ogundero of the Systems Engineering Department at University of Lagos, Nigeria for any questions.

Haskell

Some notes about the Haskell programming language and Functional Programming for intermediate programmers

LEC3-DS ALGO(updated).pdf

The document discusses circular linked lists and stacks. It begins by explaining circular linked lists, how they differ from regular singly and doubly linked lists, and how to implement operations like insertion and deletion in a circular linked list. It then covers stacks, including common stack operations like push and pop. Stacks can be implemented using either arrays or linked lists. The document provides examples of how to represent a stack using each data structure and perform operations on it. It also discusses applications of stacks, like evaluating arithmetic expressions in postfix notation using a stack.

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - Part 4(download for flawless image quality) Can a left fold ever work over an infinite list? What about a right fold? Find out.
Learn about the other two functions used by functional programmers to implement mathematical induction: iterating and scanning.
Learn about the limitations of the accumulator technique and about tupling, a technique that is the dual of the accumulator trick.

The Functional Programming Triad of Folding, Scanning and Iteration - a first...

This slide deck can work both as an aide mémoire (memory jogger), or as a first (not completely trivial) example of using left folds, left scans and iteration, to implement mathematical induction.
Errata: on almost half of the slides there is some minor typo or imperfection or in some cases a minor error and in one case, an omission. See a later version for corrections and some improvements.
(for best quality images, either download or view here: https://philipschwarz.dev/fpilluminated/?page_id=455)
Scala code for latest version: https://github.com/philipschwarz/fp-fold-scan-iterate-triad-a-first-example-scala

Basic Sorting algorithms csharp

This slide explains three (3) basic sorting algorithms with codes on github. Bubble sort, Selection sort and insertion sort.
visit https://github.com/EngrMikolo/BasicSortingAlgorithms to checkout the codes

U3.stack queue

A queue is a data structure that follows the first-in, first-out (FIFO) principle. Elements are added to the rear of the queue and removed from the front. A queue can be implemented using an array, with indexes to track the front and rear elements. When an element is added (enqueued), the rear index is incremented; when an element is removed (dequeued), the front index is incremented and the element at that index is returned. The queue has a limited capacity based on the size of the array.

Reasoning about laziness

This document discusses reasoning about laziness in Haskell. It explains that functions and data constructors don't evaluate their arguments until needed. This laziness allows separating producers and consumers efficiently. However, laziness can also cause problems like space leaks from unevaluated thunks. The document demonstrates techniques like using seq, bang patterns and strict data types to control evaluation order and avoid space leaks. It also discusses how to determine which arguments a function evaluates strictly.

Monad Fact #4

Download for flawless quality (slides viewed online look a bit grainy and out of focus). A monad is an implementation of one of the minimal sets of monadic combinators, satisfying the laws of associativity and identity - see how compositional responsibilities are distributed in each combinator set

Scala 3 enum for a terser Option Monad Algebraic Data Type

(download for flawless slides)
* Explore a terser definition of the Option Monad that uses a Scala 3 enum as an Algebraic Data Type.
* In the process, have a tiny bit of fun with Scala 3 enums.
* Get a refresher on the Functor and Monad laws.
* See how easy it is to use Scala 3 extension methods, e.g. to add convenience methods and infix operators.
The diagrams for function composition and Kleisli composition were made using https://q.uiver.app/ by https://twitter.com/varkora.
Source code: https://github.com/philipschwarz/scala-3-enum-for-terser-option-monad-algebraic-data-type
Errata:
slide 14 is an unwanted leftover - it is the same as slide 15 minus a diagram.
on slide 19, the colons in the extension method declarations are not needed

Open addressiing &rehashing,extendiblevhashing

The document discusses various hash table implementation techniques. It describes open addressing hashing which resolves collisions by probing to the next empty cell. Linear probing is discussed as a collision resolution strategy where the next probe is the current index plus one. The document also covers separate chaining hashing which uses linked lists at each index to handle collisions, and double hashing which uses two hash functions to determine probe sequences.

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - with ...

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - with ...

Functional programming with haskell

Functional programming with haskell

The Functional Programming Triad of Folding, Scanning and Iteration - a first...

The Functional Programming Triad of Folding, Scanning and Iteration - a first...

Programming Paradigms Which One Is The Best?

Programming Paradigms Which One Is The Best?

Introduction to Functional Languages

Introduction to Functional Languages

Sierpinski Triangle - Polyglot FP for Fun and Profit - Haskell and Scala

Sierpinski Triangle - Polyglot FP for Fun and Profit - Haskell and Scala

The Functional Programming Triad of fold, scan and iterate

The Functional Programming Triad of fold, scan and iterate

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - Part ...

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - Part ...

Stack queue

Stack queue

Csharp_List

Csharp_List

Haskell

Haskell

LEC3-DS ALGO(updated).pdf

LEC3-DS ALGO(updated).pdf

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - Part 4

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala - Part 4

The Functional Programming Triad of Folding, Scanning and Iteration - a first...

The Functional Programming Triad of Folding, Scanning and Iteration - a first...

Basic Sorting algorithms csharp

Basic Sorting algorithms csharp

U3.stack queue

U3.stack queue

Reasoning about laziness

Reasoning about laziness

Monad Fact #4

Monad Fact #4

Scala 3 enum for a terser Option Monad Algebraic Data Type

Scala 3 enum for a terser Option Monad Algebraic Data Type

Open addressiing &rehashing,extendiblevhashing

Open addressiing &rehashing,extendiblevhashing

PERL for QA - Important Commands and applications

This document provides an overview of the Perl programming language. It discusses where Perl is commonly used, its key features like text processing and database access. It then covers various Perl concepts like scalars, variables, user input, strings, conditionals, loops, arrays, hashes, file handling and regular expressions. It provides examples for working with scalars, strings, conditionals, loops and arrays. It also discusses the special $_ variable and functions like pop, push, shift and unshift for manipulating arrays. The document concludes with a brief discussion of subroutines.

Distributive Property

Refresh on Distributive Property. Lecture given on Sept. 22nd, 2008. Adaptation of previously created power point.

Linear Programming- Leacture-16-lp1.pptx

This is a linear programing lecture notes

Section 8: Symmetric Groups

The document discusses symmetric groups and permutations. Some key points:
- A symmetric group SX is the group of all permutations of a set X under function composition.
- Sn, the symmetric group of degree n, represents permutations of the set {1,2,...,n}.
- Permutations can be written using cycle notation, such as (1 2 3) or (1 4).
- Disjoint cycles commute; the product of two permutations is their composition as functions.
- Any permutation can be written as a product of disjoint cycles of length ≥2. Cycles of even length decompose into an odd number of transpositions, and vice versa for odd cycles.

Functional Concepts for OOP Developers

The document provides an overview of functional programming concepts including:
- Functional languages like Haskell, Scala, Clojure, F#, Erlang, and Lisp/Scheme
- Concepts of immutability, concurrency, side effects, and using monads to deal with side effects
- Examples demonstrating functional programming techniques like pattern matching, immutable collections, message passing actors, and software transactional memory (STM)

Algorithim lec1.pptx

The document discusses algorithms analysis and sorting algorithms. It introduces insertion sort and merge sort, and analyzes their time complexities. Insertion sort runs in O(n^2) time in the worst case, while merge sort runs in O(n log n) time in the worst case, which grows more slowly. Therefore, asymptotically merge sort performs better than insertion sort for large data sets. The document also covers asymptotic analysis, recurrences, and using recursion trees to solve recurrences.

Slope

This document discusses slope and how to calculate it. It defines slope as the ratio of the rise over the run. It instructs students to take notes on slides with yellow backgrounds in their notes page and information on slides with blue backgrounds go in their foldable. It provides examples of calculating slope from a graph, table of ordered pairs, and two separate ordered pairs using the slope formula. It emphasizes slope can be negative and provides an example. Finally, it assigns homework problems calculating slope from data and illustrating a real world example of slope.

MA3696 Lecture 5

The document discusses more advanced looping techniques in VBA, including looping through userform controls, generalizing loops, nested for-next loops, and one-dimensional arrays. It provides examples of declaring and filling 1D arrays, as well as using for-next loops to output array values to cells or ranges. Exercises are included to practice these skills by rewriting code using arrays and loops.

Stacks Implementation and Examples

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.

Thinking Functionally In Ruby

The document discusses functional programming concepts in Ruby. It begins by stating that functional programming and Enumerable methods can be useful in Ruby. It then provides examples of various Enumerable methods like zip, select, partition, map, and inject. It encourages thinking functionally by avoiding side effects, mutating values, and using functional parts of the standard library. The document concludes by suggesting learning a true functional language to further improve functional programming skills.

Oct8 - 131 slid

This document contains notes from several coding lectures and labs. It discusses using loops to draw different shapes on a 2D grid, including lines, squares, and diagonals using only a single loop. Methods for drawing horizontal, vertical, and diagonal lines are explained. Transformations like moving, flipping, and rotating shapes on the grid are also covered through examples of changing the row and column indices in the drawing loops.

RubyConf Argentina 2011

The document discusses regular expressions and finite state machines, showing examples of parsing routes with Journey and building non-deterministic and deterministic finite automata to represent the routes. It demonstrates how to simulate finite state machines and convert a non-deterministic finite automaton to a deterministic one to recognize route patterns more efficiently.

A Scala Corrections Library

A number of examples why Scala is in my rear view mirror, and a few ideas on how to improve the collections.

Unit-1 Basic Concept of Algorithm.pptx

The document discusses various topics related to algorithms including algorithm design, real-life applications, analysis, and implementation. It specifically covers four algorithms - the taxi algorithm, rent-a-car algorithm, call-me algorithm, and bus algorithm - for getting from an airport to a house. It also provides examples of simple multiplication methods like the American, English, and Russian approaches as well as the divide and conquer method.

Ruby Gotchas

This document summarizes common Ruby "gotchas", or unexpected behaviors that can trip up developers. It covers topics like string interpolation requiring double quotes, truthiness of values other than false and nil, differences between symbols and strings, accessing characters in strings, variable scope in blocks, freezing arrays, and initializing arrays and hashes with the same object. The goal is to explain behaviors that may surprise those from other languages and help developers avoid potential pitfalls.

Advanced s and s algorithm.ppt

This document provides an overview of several advanced sorting algorithms: Shell sort, Quick sort, Heap sort, and Merge sort. It describes the key ideas, time complexities, and provides examples of implementing each algorithm to sort sample data sets. Shell sort improves on insertion sort by sorting elements in a two-dimensional array. Quick sort uses a pivot element and partitions elements into left and right subsets. Heap sort uses a heap data structure and sorts by swapping elements. Merge sort divides the list recursively and then merges the sorted halves.

INTRODUCTION TO MATLAB presentation.pptx

Here are the steps to solve this problem numerically in MATLAB:
1. Define the 2nd order ODE for the pendulum as two first order equations:
y1' = y2
y2' = -sin(y1)
2. Create an M-file function pendulum.m that returns the right hand side:
function dy = pendulum(t,y)
dy = [y(2); -sin(y(1))];
end
3. Use an ODE solver like ode45 to integrate from t=0 to t=6pi with initial conditions y1(0)=pi, y2(0)=0:
[t,y] = ode45

8.1 Powerpoint

The document discusses using the superposition principle to add functions. It provides an example of finding the total cost function C(n), revenue function R(n), and profit function P(n) for selling zombie merchandise. The functions C(n)=200+5n and R(n)=8n are graphed and their point of intersection represents the number of items that must be sold for revenue to equal cost. The profit function is defined as P(n)=R(n)-C(n)=3n-200 and graphed. It is determined that at least 68 items must be sold to avoid a loss and start making a profit.

one main advantage of bubble sort as compared to others

Bubble sort is a simple sorting algorithm that compares adjacent elements and swaps them if they are in the wrong order. It repeats this process, making multiple passes through the list, until it is fully sorted. While simple to implement, bubble sort has a poor worst-case performance of O(n2) time complexity, making it impractical for large datasets. It is often used to introduce sorting concepts but not recommended for real-world use due to its inefficient runtime.

Alegebra Powers Substitution

The document provides examples and step-by-step workings for evaluating algebraic expressions by substituting number values for variables. It demonstrates evaluating expressions including powers, integers, fractions, and evaluating expressions to find volumes. The examples show applying order of operations and substitution to simplify expressions down to a single numerical value.

PERL for QA - Important Commands and applications

PERL for QA - Important Commands and applications

Distributive Property

Distributive Property

Linear Programming- Leacture-16-lp1.pptx

Linear Programming- Leacture-16-lp1.pptx

Section 8: Symmetric Groups

Section 8: Symmetric Groups

Functional Concepts for OOP Developers

Functional Concepts for OOP Developers

Algorithim lec1.pptx

Algorithim lec1.pptx

Slope

Slope

MA3696 Lecture 5

MA3696 Lecture 5

Stacks Implementation and Examples

Stacks Implementation and Examples

Thinking Functionally In Ruby

Thinking Functionally In Ruby

Oct8 - 131 slid

Oct8 - 131 slid

RubyConf Argentina 2011

RubyConf Argentina 2011

A Scala Corrections Library

A Scala Corrections Library

Unit-1 Basic Concept of Algorithm.pptx

Unit-1 Basic Concept of Algorithm.pptx

Ruby Gotchas

Ruby Gotchas

Advanced s and s algorithm.ppt

Advanced s and s algorithm.ppt

INTRODUCTION TO MATLAB presentation.pptx

INTRODUCTION TO MATLAB presentation.pptx

8.1 Powerpoint

8.1 Powerpoint

one main advantage of bubble sort as compared to others

one main advantage of bubble sort as compared to others

Alegebra Powers Substitution

Alegebra Powers Substitution

How to win the game of trade-offs

Delivered at the Serverless Summit 2022. Learn how to design serverless systems and tip the balance of trade-offs in your favour.
To learn how to build production-grade serverless applications, check out my upcoming workshops at productionreadyserverless.com and get 15% off with the code "serverlesssummit22".

How to choose the right messaging service

At the heart of every event-driven architecture is a conduit for messages to flow through. AWS offers many services that can act as such conduit - EventBridge, SNS, SQS, Kinesis, DynamoDB streams, MSK, IOT Core and Amazon MQ just to name a few! These services have different characteristics and trade-offs around performance, scalability and cost. Picking the right service for your workload is not always easy. In this talk, let’s talk about how to pick the right messaging service to use in your event-driven architecture and play the game of trade-offs to your advantage.

How to choose the right messaging service for your workload

At the heart of every event-driven architecture is a conduit for messages to flow through. AWS offers many services that can act as such conduit - EventBridge, SNS, SQS, Kinesis, DynamoDB streams, MSK, IOT Core and Amazon MQ just to name a few! These services have different characteristics and trade-offs around performance, scalability and cost. Picking the right service for your workload is not always easy. In this talk, let’s talk about how to pick the right messaging service to use in your event-driven architecture and play the game of trade-offs to your advantage.

Patterns and practices for building resilient serverless applications.pdf

Lambda gives you multi-AZ out-of-the-box, but still, things can go wrong in production. There are region-wide outages, and performance degradation in services your function depends on can cause it to time out or error. And what if you're dealing with downstream systems that just aren't as scalable and can't handle the load you put on them? The bottom line is many things can go wrong and they often do at the worst of times. The goal of building resilient systems is not to prevent failures, but to build systems that can withstand these failures. In this talk, we will look at a number of practices and architectural patterns that can help you build more resilient serverless applications. Such as multi-region, active-active, employing DLQs and surge queues. We'll also see how we can use chaos experiments to help us identify failure modes before they manifest in production.

Lambda and DynamoDB best practices

This document contains a summary of best practices for using Lambda and DynamoDB presented by Yan Cui. Some key recommendations include implementing observability from the start by using metrics and alerts to monitor performance, creating separate AWS accounts for each team and environment, loading secrets securely from SSM Parameter Store at runtime, following the principle of least privilege with IAM policies, parallelizing functions where possible, and various DynamoDB optimizations like using DocumentClient and PAY_PER_REQUEST billing. The document emphasizes that best practices depend on individual contexts and situations.

Lessons from running AppSync in prod

This document provides lessons learned from running three AppSync projects in production over 18 months. It discusses preferences for using VTL over Lambda resolvers for CRUD operations due to VTL being faster, cheaper and simpler. It also recommends per-resolver caching over full request caching. Other tips include not leaving logging on full in production, handling user errors gracefully, planning for nested CloudFormation stacks for large projects, and modeling multi-tenancy using Cognito groups and attributes.

Serverless observability - a hero's perspective

Yan Cui, an AWS Serverless Hero, will talk about the learnings from using serverless at scale.
He will cover the challenges for observability in serverless asynchronous workloads and the patterns to address those challenges, like using centralized logging, correlation IDs, tracing, lambda extensions.

How to ship customer value faster with step functions

Learn all about AWS Step Functions and how to use them to model business workflows and ship customer values quickly. In this session, we will talk about what is Step Functions, how to model business workflows as state machines, real-world case studies, and design patterns. By the end of this webinar, you should have a good idea of where Step Functions fit into your application and why you should use them (and why not!) to model workflows instead of building a custom solution yourself.

How serverless changes the cost paradigm

One of the key characteristics of serverless components is the pay-per-use pricing model. For example, with AWS Lambda, you don’t pay for the uptime of the underlying infrastructure but for the no. of invocations and how long your code actually runs for.
This important characteristic removes the need for many premature micro-optimizations as your cost is always tightly linked to usage and minimizes waste. As a result, many applications would run at a fraction of the cost if they were moved to serverless.
The pay-per-use pricing model also enables more accurate cost prediction and monitoring based on your application’s throughput. This gives rise to the notion of FinDev, where finance and development can intersect and allows optimization to be targeted to give the optimal return-on-invest on the engineering efforts.
And by building your application on serverless components, you can also leverage it as a business advantage and offer a more competitive, usage-based pricing to your customers. Which is going to be crucial at a time when businesses all around the world are affected by COVID and are looking for better efficiencies.
In this webinar, we will cover topics such as:
- How does the cost of serverless differ from serverful applications?
- How to predict and monitor cost in serverless applications?
- When should you optimize for cost?
- How can you leverage usage-based pricing as a business advantage?

Why your next serverless project should use AWS AppSync

In this webinar, Yan Cui and Lumigo Software Engineer Guy Moses will discuss some of the power of GraphQL and AppSync and why AppSync + Lambda + DynamoDB should be your stack of choice in 2021 and beyond!

Build social network in 4 weeks

Serverless technologies drastically simplify the task of building modern, scalable APIs in the cloud, and GraphQL makes it easy for frontend teams to consume these APIs and to iterate quickly on your product idea. Together, they are a perfect combination for a product-focused, full-stack team to deliver customer values quickly.
In this talk, see how we built a new social network mobile app in under 4 weeks using Lambda, AppSync, DynamoDB and Algolia. How we approached CI/CD, testing, authentication and lessons we learnt along the way.
Real-world serverless podcast: https://realworldserverless.com
Learn Lambda best practices: https://lambdabestpractice.com
Blog: https://theburningmonk.com
Consulting services: https://theburningmonk.com/hire-me
Production-Ready Serverless workshop: https://productionreadyserverless.com

Patterns and practices for building resilient serverless applications

Lambda gives you multi-AZ out-of-the-box, but still, things can go wrong in production. There are region-wide outages, and performance degradation in services your function depends on can cause it to time out or error. And what if you're dealing with downstream systems that just aren't as scalable and can't handle the load you put on them? The bottom line is many things can go wrong and they often do at the worst of times. The goal of building resilient systems is not to prevent failures, but to build systems that can withstand these failures. In this talk, we will look at a number of practices and architectural patterns that can help you build more resilient serverless applications. Such as multi-region, active-active, employing DLQs and surge queues. We'll also see how we can use chaos experiments to help us identify failure modes before they manifest in production

How to bring chaos engineering to serverless

You might have heard about chaos engineering in the context of Netflix and Amazon, and how they kill EC2 servers in production at random to verify that their systems can stay up in the face of infrastructure failures. But did you know that the same ideas can be applied to serverless applications? Yes, despite not having access to the underlying servers, we can still apply principles of chaos engineering to uncover failure modes in our system (and there are plenty!) so we can build a defence against them and make our serverless applications more robust and more resilient!

Migrating existing monolith to serverless in 8 steps

The document discusses refactoring a monolithic application to a serverless architecture in 8 steps. It covers identifying service boundaries, organizing code into separate repositories for each service, choosing deployment tools, keeping functions simple and single-purpose, and migrating features to new services incrementally while maintaining compatibility with the existing monolith. The goal is to break the application into small, autonomous services that can be developed and deployed independently for improved scalability, resilience and development velocity.

Building a social network in under 4 weeks with Serverless and GraphQL

This document discusses how a social network was built in under 4 weeks using serverless architecture and GraphQL. A small team including 1 full-time front-end developer for mobile, 1 full-time front-end developer for CMS, and 1 part-time back-end developer completed the project in approximately 7, 3, and 4 weeks respectively. AWS services like Cognito, AppSync, DynamoDB, Lambda, S3, and CloudFront were used to build the backend. An AWS organization structure was also implemented for production, staging, and development environments.

FinDev as a business advantage in the post covid19 economy

The document discusses how businesses can gain a competitive advantage in the post-COVID economy through the use of serverless technologies on AWS. It notes that consumers and businesses will have less revenue due to the pandemic, requiring companies to become more efficient. Serverless computing allows companies to focus on business logic rather than infrastructure management and reduces costs since customers only pay for resources used. This creates an opportunity for new variable cost business models and more agile, competitive companies through the use of serverless technologies like AWS Lambda and API Gateway.

How to improve lambda cold starts

AWS has improved Lambda cold starts by leaps and bounds in the last year. But for performance-sensitive applications such as user-facing APIs, Lambda cold starts are still a thorn in one’s side, especially when working with languages such as Java and .Net Core.
In this webinar, we will dive into strategies for improving cold start latency and how to mitigate them altogether with Provisioned Concurrency, and how Lumigo helps you optimize your use of Provisioned Concurrency.

What can you do with lambda in 2020

In this session, we will look at 10 common use cases for AWS Lambda such as REST APIs, WebSockets, IoT and building event-driven systems. We will also touch on some of the latest platform features such as Provisioned Concurrency, EFS integration and Lambda Destinations and when and where we should use them.

A chaos experiment a day, keeping the outage away

Presented at ServerlessDays Warsaw
Recording: https://youtu.be/21HprKZQczs
You might have heard about chaos engineering in the context of Netflix and Amazon, and how they kill EC2 servers in production at random to verify that their systems can stay up in the face of infrastructure failures. But did you know that the same ideas can be applied to serverless applications? Yes, despite not having access to the underlying servers, we can still apply principles of chaos engineering to uncover failure modes in our system (and there are plenty!) so we can build defence against them and make our serverless applications more robust and more resilient!

How to debug slow lambda response times

One of the most common performance issues in serverless architectures is elevated latencies from external services, such as DynamoDB, ElasticSearch or Stripe.
In this webinar, we will show you how to quickly identify and debug these problems, and some best practices for dealing with poor performing 3rd party services.

How to win the game of trade-offs

How to win the game of trade-offs

How to choose the right messaging service

How to choose the right messaging service

How to choose the right messaging service for your workload

How to choose the right messaging service for your workload

Patterns and practices for building resilient serverless applications.pdf

Patterns and practices for building resilient serverless applications.pdf

Lambda and DynamoDB best practices

Lambda and DynamoDB best practices

Lessons from running AppSync in prod

Lessons from running AppSync in prod

Serverless observability - a hero's perspective

Serverless observability - a hero's perspective

How to ship customer value faster with step functions

How to ship customer value faster with step functions

How serverless changes the cost paradigm

How serverless changes the cost paradigm

Why your next serverless project should use AWS AppSync

Why your next serverless project should use AWS AppSync

Build social network in 4 weeks

Build social network in 4 weeks

Patterns and practices for building resilient serverless applications

Patterns and practices for building resilient serverless applications

How to bring chaos engineering to serverless

How to bring chaos engineering to serverless

Migrating existing monolith to serverless in 8 steps

Migrating existing monolith to serverless in 8 steps

Building a social network in under 4 weeks with Serverless and GraphQL

Building a social network in under 4 weeks with Serverless and GraphQL

FinDev as a business advantage in the post covid19 economy

FinDev as a business advantage in the post covid19 economy

How to improve lambda cold starts

How to improve lambda cold starts

What can you do with lambda in 2020

What can you do with lambda in 2020

A chaos experiment a day, keeping the outage away

A chaos experiment a day, keeping the outage away

How to debug slow lambda response times

How to debug slow lambda response times

[OReilly Superstream] Occupy the Space: A grassroots guide to engineering (an...

The typical problem in product engineering is not bad strategy, so much as “no strategy”. This leads to confusion, lack of motivation, and incoherent action. The next time you look for a strategy and find an empty space, instead of waiting for it to be filled, I will show you how to fill it in yourself. If you’re wrong, it forces a correction. If you’re right, it helps create focus. I’ll share how I’ve approached this in the past, both what works and lessons for what didn’t work so well.

Call Girls Chandigarh🔥7023059433🔥Agency Profile Escorts in Chandigarh Availab...

Call Girls Chandigarh🔥7023059433🔥Agency Profile Escorts in Chandigarh Available 24/7

GNSS spoofing via SDR (Criptored Talks 2024)

In the realm of cybersecurity, offensive security practices act as a critical shield. By simulating real-world attacks in a controlled environment, these techniques expose vulnerabilities before malicious actors can exploit them. This proactive approach allows manufacturers to identify and fix weaknesses, significantly enhancing system security.
This presentation delves into the development of a system designed to mimic Galileo's Open Service signal using software-defined radio (SDR) technology. We'll begin with a foundational overview of both Global Navigation Satellite Systems (GNSS) and the intricacies of digital signal processing.
The presentation culminates in a live demonstration. We'll showcase the manipulation of Galileo's Open Service pilot signal, simulating an attack on various software and hardware systems. This practical demonstration serves to highlight the potential consequences of unaddressed vulnerabilities, emphasizing the importance of offensive security practices in safeguarding critical infrastructure.

What is an RPA CoE? Session 2 – CoE Roles

In this session, we will review the players involved in the CoE and how each role impacts opportunities.
Topics covered:
• What roles are essential?
• What place in the automation journey does each role play?
Speaker:
Chris Bolin, Senior Intelligent Automation Architect Anika Systems

Harnessing the Power of NLP and Knowledge Graphs for Opioid Research

Gursev Pirge, PhD
Senior Data Scientist - JohnSnowLabs

QR Secure: A Hybrid Approach Using Machine Learning and Security Validation F...

QR Secure: A Hybrid Approach Using Machine Learning and Security Validation Functions to Prevent Interaction with Malicious QR Codes.
Aim of the Study: The goal of this research was to develop a robust hybrid approach for identifying malicious and insecure URLs derived from QR codes, ensuring safe interactions.
This is achieved through:
Machine Learning Model: Predicts the likelihood of a URL being malicious.
Security Validation Functions: Ensures the derived URL has a valid certificate and proper URL format.
This innovative blend of technology aims to enhance cybersecurity measures and protect users from potential threats hidden within QR codes 🖥 🔒
This study was my first introduction to using ML which has shown me the immense potential of ML in creating more secure digital environments!

"What does it really mean for your system to be available, or how to define w...

We will talk about system monitoring from a few different angles. We will start by covering the basics, then discuss SLOs, how to define them, and why understanding the business well is crucial for success in this exercise.

"NATO Hackathon Winner: AI-Powered Drug Search", Taras Kloba

This is a session that details how PostgreSQL's features and Azure AI Services can be effectively used to significantly enhance the search functionality in any application.
In this session, we'll share insights on how we used PostgreSQL to facilitate precise searches across multiple fields in our mobile application. The techniques include using LIKE and ILIKE operators and integrating a trigram-based search to handle potential misspellings, thereby increasing the search accuracy.
We'll also discuss how the azure_ai extension on PostgreSQL databases in Azure and Azure AI Services were utilized to create vectors from user input, a feature beneficial when users wish to find specific items based on text prompts. While our application's case study involves a drug search, the techniques and principles shared in this session can be adapted to improve search functionality in a wide range of applications. Join us to learn how PostgreSQL and Azure AI can be harnessed to enhance your application's search capability.

Dandelion Hashtable: beyond billion requests per second on a commodity server

This slide deck presents DLHT, a concurrent in-memory hashtable. Despite efforts to optimize hashtables, that go as far as sacrificing core functionality, state-of-the-art designs still incur multiple memory accesses per request and block request processing in three cases. First, most hashtables block while waiting for data to be retrieved from memory. Second, open-addressing designs, which represent the current state-of-the-art, either cannot free index slots on deletes or must block all requests to do so. Third, index resizes block every request until all objects are copied to the new index. Defying folklore wisdom, DLHT forgoes open-addressing and adopts a fully-featured and memory-aware closed-addressing design based on bounded cache-line-chaining. This design offers lock-free index operations and deletes that free slots instantly, (2) completes most requests with a single memory access, (3) utilizes software prefetching to hide memory latencies, and (4) employs a novel non-blocking and parallel resizing. In a commodity server and a memory-resident workload, DLHT surpasses 1.6B requests per second and provides 3.5x (12x) the throughput of the state-of-the-art closed-addressing (open-addressing) resizable hashtable on Gets (Deletes).

Christine's Product Research Presentation.pptx

How I do my Product Research

Day 2 - Intro to UiPath Studio Fundamentals

In our second session, we shall learn all about the main features and fundamentals of UiPath Studio that enable us to use the building blocks for any automation project.
📕 Detailed agenda:
Variables and Datatypes
Workflow Layouts
Arguments
Control Flows and Loops
Conditional Statements
💻 Extra training through UiPath Academy:
Variables, Constants, and Arguments in Studio
Control Flow in Studio

LF Energy Webinar: Carbon Data Specifications: Mechanisms to Improve Data Acc...

This LF Energy webinar took place June 20, 2024. It featured:
-Alex Thornton, LF Energy
-Hallie Cramer, Google
-Daniel Roesler, UtilityAPI
-Henry Richardson, WattTime
In response to the urgency and scale required to effectively address climate change, open source solutions offer significant potential for driving innovation and progress. Currently, there is a growing demand for standardization and interoperability in energy data and modeling. Open source standards and specifications within the energy sector can also alleviate challenges associated with data fragmentation, transparency, and accessibility. At the same time, it is crucial to consider privacy and security concerns throughout the development of open source platforms.
This webinar will delve into the motivations behind establishing LF Energy’s Carbon Data Specification Consortium. It will provide an overview of the draft specifications and the ongoing progress made by the respective working groups.
Three primary specifications will be discussed:
-Discovery and client registration, emphasizing transparent processes and secure and private access
-Customer data, centering around customer tariffs, bills, energy usage, and full consumption disclosure
-Power systems data, focusing on grid data, inclusive of transmission and distribution networks, generation, intergrid power flows, and market settlement data

Leveraging the Graph for Clinical Trials and Standards

Katja Glaß
OpenStudyBuilder Community Manager - Katja Glaß Consulting
Marius Conjeaud
Principal Consultant - Neo4j

Northern Engraving | Nameplate Manufacturing Process - 2024

Manufacturing custom quality metal nameplates and badges involves several standard operations. Processes include sheet prep, lithography, screening, coating, punch press and inspection. All decoration is completed in the flat sheet with adhesive and tooling operations following. The possibilities for creating unique durable nameplates are endless. How will you create your brand identity? We can help!

Getting the Most Out of ScyllaDB Monitoring: ShareChat's Tips

ScyllaDB monitoring provides a lot of useful information. But sometimes it’s not easy to find the root of the problem if something is wrong or even estimate the remaining capacity by the load on the cluster. This talk shares our team's practical tips on: 1) How to find the root of the problem by metrics if ScyllaDB is slow 2) How to interpret the load and plan capacity for the future 3) Compaction strategies and how to choose the right one 4) Important metrics which aren’t available in the default monitoring setup.

"Choosing proper type of scaling", Olena Syrota

Imagine an IoT processing system that is already quite mature and production-ready and for which client coverage is growing and scaling and performance aspects are life and death questions. The system has Redis, MongoDB, and stream processing based on ksqldb. In this talk, firstly, we will analyze scaling approaches and then select the proper ones for our system.

Poznań ACE event - 19.06.2024 Team 24 Wrapup slidedeck

ACE Poznań event slidedeck

GlobalLogic Java Community Webinar #18 “How to Improve Web Application Perfor...

Під час доповіді відповімо на питання, навіщо потрібно підвищувати продуктивність аплікації і які є найефективніші способи для цього. А також поговоримо про те, що таке кеш, які його види бувають та, основне — як знайти performance bottleneck?
Відео та деталі заходу: https://bit.ly/45tILxj

AppSec PNW: Android and iOS Application Security with MobSF

Mobile Security Framework - MobSF is a free and open source automated mobile application security testing environment designed to help security engineers, researchers, developers, and penetration testers to identify security vulnerabilities, malicious behaviours and privacy concerns in mobile applications using static and dynamic analysis. It supports all the popular mobile application binaries and source code formats built for Android and iOS devices. In addition to automated security assessment, it also offers an interactive testing environment to build and execute scenario based test/fuzz cases against the application.
This talk covers:
Using MobSF for static analysis of mobile applications.
Interactive dynamic security assessment of Android and iOS applications.
Solving Mobile app CTF challenges.
Reverse engineering and runtime analysis of Mobile malware.
How to shift left and integrate MobSF/mobsfscan SAST and DAST in your build pipeline.

Session 1 - Intro to Robotic Process Automation.pdf

👉 Check out our full 'Africa Series - Automation Student Developers (EN)' page to register for the full program:
https://bit.ly/Automation_Student_Kickstart
In this session, we shall introduce you to the world of automation, the UiPath Platform, and guide you on how to install and setup UiPath Studio on your Windows PC.
📕 Detailed agenda:
What is RPA? Benefits of RPA?
RPA Applications
The UiPath End-to-End Automation Platform
UiPath Studio CE Installation and Setup
💻 Extra training through UiPath Academy:
Introduction to Automation
UiPath Business Automation Platform
Explore automation development with UiPath Studio
👉 Register here for our upcoming Session 2 on June 20: Introduction to UiPath Studio Fundamentals: https://community.uipath.com/events/details/uipath-lagos-presents-session-2-introduction-to-uipath-studio-fundamentals/

[OReilly Superstream] Occupy the Space: A grassroots guide to engineering (an...

[OReilly Superstream] Occupy the Space: A grassroots guide to engineering (an...

Call Girls Chandigarh🔥7023059433🔥Agency Profile Escorts in Chandigarh Availab...

Call Girls Chandigarh🔥7023059433🔥Agency Profile Escorts in Chandigarh Availab...

GNSS spoofing via SDR (Criptored Talks 2024)

GNSS spoofing via SDR (Criptored Talks 2024)

What is an RPA CoE? Session 2 – CoE Roles

What is an RPA CoE? Session 2 – CoE Roles

Harnessing the Power of NLP and Knowledge Graphs for Opioid Research

Harnessing the Power of NLP and Knowledge Graphs for Opioid Research

QR Secure: A Hybrid Approach Using Machine Learning and Security Validation F...

QR Secure: A Hybrid Approach Using Machine Learning and Security Validation F...

"What does it really mean for your system to be available, or how to define w...

"What does it really mean for your system to be available, or how to define w...

"NATO Hackathon Winner: AI-Powered Drug Search", Taras Kloba

"NATO Hackathon Winner: AI-Powered Drug Search", Taras Kloba

Dandelion Hashtable: beyond billion requests per second on a commodity server

Dandelion Hashtable: beyond billion requests per second on a commodity server

Christine's Product Research Presentation.pptx

Christine's Product Research Presentation.pptx

Day 2 - Intro to UiPath Studio Fundamentals

Day 2 - Intro to UiPath Studio Fundamentals

LF Energy Webinar: Carbon Data Specifications: Mechanisms to Improve Data Acc...

LF Energy Webinar: Carbon Data Specifications: Mechanisms to Improve Data Acc...

Leveraging the Graph for Clinical Trials and Standards

Leveraging the Graph for Clinical Trials and Standards

Northern Engraving | Nameplate Manufacturing Process - 2024

Northern Engraving | Nameplate Manufacturing Process - 2024

Getting the Most Out of ScyllaDB Monitoring: ShareChat's Tips

Getting the Most Out of ScyllaDB Monitoring: ShareChat's Tips

"Choosing proper type of scaling", Olena Syrota

"Choosing proper type of scaling", Olena Syrota

Poznań ACE event - 19.06.2024 Team 24 Wrapup slidedeck

Poznań ACE event - 19.06.2024 Team 24 Wrapup slidedeck

GlobalLogic Java Community Webinar #18 “How to Improve Web Application Perfor...

GlobalLogic Java Community Webinar #18 “How to Improve Web Application Perfor...

AppSec PNW: Android and iOS Application Security with MobSF

AppSec PNW: Android and iOS Application Security with MobSF

Session 1 - Intro to Robotic Process Automation.pdf

Session 1 - Intro to Robotic Process Automation.pdf

- 1. Fear and Loathing with APL
- 2. Hi, my name is Yan Cui aka @theburningmonk
- 3. What is APL? created at IBM in 1957, by Ken Iverson designed to simplify math notations “A Programming Language”
- 4. What is APL? famed for use of special symbols array programming influenced Mathematica, Matlab, etc.
- 6. what the hell is an APL?
- 8. Conway’s Game of Life https://www.youtube.com/watch?v=a9xAKttWgP4
- 10. “Beauty is in the Eye of the Beholder” beauty doesn't exist on its own but is created by observers
- 11. “…We followed up with two studies on the accuracy rates of novices using a total of six programming languages: Ruby, Java, Perl, Python, Randomo, and Quorum. Randomo was designed by randomly choosing some keywords from the ASCII table (a metaphorical placebo). To our surprise, we found that languages using a more traditional C-style syntax (both Perl and Java) did not afford accuracy rates significantly higher than a language with randomly generated keywords, …” “An Empirical Investigation into Programming Language Syntax” - Andreas Stefik and Susanna Siebert
- 12. “…We followed up with two studies on the accuracy rates of novices using a total of six programming languages: Ruby, Java, Perl, Python, Randomo, and Quorum. Randomo was designed by randomly choosing some keywords from the ASCII table (a metaphorical placebo). To our surprise, we found that languages using a more traditional C-style syntax (both Perl and Java) did not afford accuracy rates significantly higher than a language with randomly generated keywords, …” “An Empirical Investigation into Programming Language Syntax” - Andreas Stefik and Susanna Siebert
- 14. “A language that doesn't affect the way you think about programming, is not worth knowing.” - Alan Perlis
- 15. “in an era of mainstream programming languages, APL is a rare opportunity to truly challenge the way you think about programming” - me
- 18. Let’s learn some APL http://tryapl.org/
- 19. 2 + 2 4 4 - 1 3 + and - works the way you expect
- 20. 2 * 3 8 4 * 4 256 but * means power
- 21. 2 / 3 3 3 and / means replicate it means replicate the scalar value 3, 2 times and returns an array of 2 elements
- 22. 2 × 2 4 4 ÷ 2 2 multiplication (×) and division (÷) just like in Maths!
- 23. x ← 42 y ← 1 2 3 4 assignment (←) variable names are case sensitive
- 24. variables are mutable x ← 42 x ← 1 2 3 4 x 1 2 3 4
- 25. assign multiple values at once (kinda like pattern matching) x y z ← 1 2 3 x 1 y 2
- 26. but the patterns must match x y ← 1 2 3 LENGTH ERROR x y ← 1 2 3
- 27. 1 2 3 - 3 2 1 ¯2 0 2 1 2 3 × 3 2 1 3 4 3 arithmetic operations work on arrays too
- 28. 1 2 3 + 1 2 3 4 2 × 1 2 3 2 4 6 if one side is scalar then the other side can be any shape
- 29. 4 ⌊ 2 2 4 ⌈ 2 4 min (⌊) and max (⌈)
- 30. 1 2 3 4 5 ⌈ 4 4 4 4 4 5 1 2 3 ⌈ 3 2 1 3 2 3 min (⌊) and max (⌈) same rules apply for arrays
- 33. dyadic 2 ⌈ 4 1 2 ⌈ 3 1 monadic ⌈ 2 ⌈ 1 3
- 34. ⌊ 3 4.1 4.5 5.6 3 4 4 5 monadically, ⌊ means floor
- 35. ⌈ 3 4.1 4.5 5.6 3 5 5 6 and ⌈ means ceiling
- 37. 3 2 ⍴ 1 2 3 4 5 6 1 2 3 4 5 6 dyadically, ⍴ reshapes right hand side rows columns
- 38. ⍴ 1 2 3 3 ⍴ (3 2 ⍴ 1 2 3 4 5 6) 3 2 monadically, ⍴ returns shape of argument
- 39. 3 2 ⍴ 1 2 3 1 2 3 1 2 3 ⍴ recycles elements to fill space
- 40. 2 2 ⍴ 1 2 3 4 5 6 1 2 3 4 and ignores additional elements
- 41. 3 3 ⍴ 1 0 0 0 1 0 0 0 1 0 0 0 1 here’s a neat trick to get diagonals :-P
- 42. ⍴ 2 2 ⍴ 0 1 0 2 2 ⍴ (2 2 ⍴ 0 1 0) 2 2 oh, and APL is read from RIGHT-TO-LEFT
- 43. ⍴ 2 2 ⍴ 0 1 0 2 2 ⍴ (2 2 ⍴ 0 1 0) 2 2 oh, and APL is read from RIGHT-TO-LEFT
- 44. +/ 1 2 3 6 btw, / also means reduce ie, reduce over the array [1, 2, 3] with the plus function
- 45. ×/ 1 2 3 4 5 120 btw, / also means reduce and here’s factorials!
- 47. Avg ← { (+/ ⍵) ÷ ⍴⍵ } anatomy of a defined function function name assignment function body
- 48. Avg ← { (+/ ⍵) ÷ ⍴⍵ } Avg 1 2 3 anatomy of a defined function omega ⍵ represents the right argument
- 49. Diff ← { (+/ ⍺) - (+/ ⍵) } 3 4 5 Diff 1 2 3 anatomy of a defined function alpha ⍺ represents the left argument
- 50. Plus ← { ⍺ + ⍵ } Plus/ 1 2 3 6 defined functions can be used with / too
- 52. Xs ← 1 2 3 Xs[2] 2 APL is one-indexed!
- 53. Xs[1 2 1] 1 2 1 Xs[2 2 ⍴ 1 2] 1 2 1 2 indices can be array too
- 54. Xs[3 2] ← 6 4 Xs 1 4 6 updating an array
- 56. ⍳9 1 2 3 4 5 6 7 8 9 index generator
- 57. Booleans
- 58. 1 < 2 1 1 2 3 < 3 2 1 1 0 0 1 is true, 0 is false yup, works with arrays too ;-)
- 59. ~1 0 ~1 0 1 0 1 0 monadically, ~ means negate
- 60. (1 2 3 < 3 2 1) ∧ (1 1 1) 1 0 0 (1 2 3 < 3 2 1) ∨ (1 1 1) 1 1 1 logical AND ∧ and logical OR ∨
- 61. (⍳10) > 7 0 0 0 0 0 0 0 1 1 1 +/ (⍳10) > 7 3 count no. of positives
- 62. (⍳10) > 7 0 0 0 0 0 0 0 1 1 1 ⍳10 > 7 ? are these two expression equivalent?
- 63. (⍳10) > 7 0 0 0 0 0 0 0 1 1 1 ⍳10 > 7 1 are these two expression equivalent? nope! remember, APL reads from RIGHT-TO-LEFT!
- 64. (⍳10) > 7 0 0 0 0 0 0 0 1 1 1 7 < ⍳10 0 0 0 0 0 0 0 1 1 1 are these two expression equivalent?
- 66. 1 0 1 / 3 2 1 3 1 1 0 1 / 'iou' i u booleans can be used to as a mask
- 67. Values ← 1 3 5 7 9 Values > 4 0 0 1 1 1 (Values > 4) / Values 5 7 9 a LINQ-style Where can be written as
- 68. Values > 4 0 0 1 1 1 ⍳⍴Values 1 2 3 4 5 (Values > 4) / (⍳⍴Values) 3 4 5 and to get the indices instead
- 69. 1 2 3 ~ 3 4 3 5 1 2 ‘ab’ ‘cd’ ‘ef’ ~ ‘cd’ ‘ef’ ab dyadically, ~ means without
- 71. 1 1 3 5 3 7 ∊ 1 2 3 1 1 1 0 1 0 'hello world' ∊ 'aeiou' 0 1 0 0 1 0 0 1 0 0 0 dyadically, ∊ checks for membership
- 72. Phrase ← ‘hello world’ (Phrase ∊ 'aeiou') / Phrase eoo which vowels appeared in a phrase?
- 73. 2 2 ⍴ 1 2 1 2 1 2 ∊ 2 2 ⍴ 1 2 1 2 1 2 monadically, ∊ flattens a matrix
- 74. Take & Drop
- 75. 2 ↑ 1 2 3 4 1 2 2 2 ↑ (3 3 ⍴ ⍳9) 1 2 4 5 ↑ to take items from an array !?
- 76. 3 3 ⍴ ⍳9 1 2 3 4 5 6 7 8 9
- 77. 2 2 ↑ 3 3 ⍴ ⍳9 1 2 3 4 5 6 7 8 9 take a 2 (rows) by 2 (cols) matrix
- 78. 2 ↓ 1 2 3 4 3 4 2 2 ↓ (3 3 ⍴ ⍳9) 9 ↓ to drop items from an array !?
- 79. 3 3 ⍴ ⍳9 1 2 3 4 5 6 7 8 9
- 80. 2 2 ↓ 3 3 ⍴ ⍳9 1 2 3 4 5 6 7 8 9 drop first 2 rows and 2 cols
- 81. ¯2 ↑ 1 2 3 4 3 4 ¯2 ↓ 1 2 3 4 1 2 use negative count to take/drop from end of array
- 82. ¯2 2 ↑ (3 3 ⍴ ⍳9) ? ¯2 2 ↓ (3 3 ⍴ ⍳9) ? what about these? http://tryapl.org/ try it out yourself
- 84. 3 3 ⍴ ⍳9 1 2 3 4 5 6 7 8 9 given a matrix
- 85. 3 3 ⍴ ⍳9 3 2 1 6 5 4 9 8 7 mirrors the matrix horizontally
- 86. 3 3 ⍴ ⍳9 7 8 9 4 5 6 1 2 3 mirrors the matrix vertically
- 87. ⍉ 3 3 ⍴ ⍳9 1 4 7 2 5 8 3 6 9 transposes the matrix⍉
- 88. Outer Products
- 90. 1 2 3 .+ 4 5 6 5 6 7 6 7 8 7 8 9 . creates a cartesian product
- 91. 1 2 3 .× 4 5 6 4 5 6 8 10 12 12 15 18 . creates a cartesian product
- 92. (⍳3) .= (⍳3) 1 0 0 0 1 0 0 0 1 . creates a cartesian product
- 93. (⍳3) .< (⍳3) 0 1 1 0 0 1 0 0 0 . creates a cartesian product
- 94. (⍳3) .⌈ (⍳3) 1 2 3 2 2 3 3 3 3 . creates a cartesian product
- 95. (⍳3) .+ (⍳3) 2 3 4 3 4 5 4 5 6 . creates a cartesian product
- 96. what about this? http://tryapl.org/ try it out yourself ∊ (⍳3) .× (⍳5) ?
- 97. Demo Time…
- 98. Conclusions
- 99. should I learn APL? absolutely! it’s the shock to the system your brain needs
- 100. is it gonna help my career? does it matter?