The document discusses monads and functional programming concepts. It begins by explaining that monads are structures that put values in computational contexts. It then provides a technical definition of a monad involving endofunctors, natural transformations, and laws. Several examples are given to illustrate monads, including the Optional monad in Java to handle null values, and the Stream monad to represent sequences. The document advocates using monads to make aspects like errors, state, and effects explicit in a program's type system.
The document discusses clean coding practices for Java developers. It covers topics such as choosing meaningful names for variables, methods, and classes; writing code that is easy for others to understand; breaking methods down into single logical steps; and using fluent APIs to make code more readable. The presentation provides examples of clean code and ways to refactor code to follow best practices.
Optional was introduced in Java 8 to help deal with null references in a safer way. Optional wraps an object that may or may not be present, and supports methods like map, filter, and flatMap to operate on the wrapped value in a functional style. Using Optional helps avoid NullPointerExceptions and makes it clear whether a value is present or absent, improving code readability and safety over directly using null references.
Functional Programming 101 with Scala and ZIO @FunctionalWorld
This document provides an overview of functional programming concepts and the ZIO library. It discusses the characteristics of pure functions, including being total, deterministic, and having no side effects. It contrasts functional programming with object-oriented programming. Benefits of the functional paradigm discussed include local reasoning, referential transparency, conciseness, easier testing, and support for parallel programming. The document then introduces the ZIO library, describing how it allows building resilient, asynchronous, and efficient applications using functional principles. It outlines ZIO's data type and how it represents effects.
Presented on 27th September 2017 to a joint meeting of 'Cork Functional Programmers' and the 'Cork Java Users Group'
Based on the Kotlin Language programming course from Instil. For more details see https://instil.co/courses/kotlin-development/
Kotlin Bytecode Generation and Runtime Performance
In this talk, we'll dive into the details of how various language features supported by Kotlin are translated to Java bytecode. We'll use the JMH microbenchmarking tool to study the relative performance of various constructs and to understand how we can ensure top performance of the Kotlin code that we write.
The Functional Programming Triad of Map, Filter and Fold
This slide deck is my homage to SICP, the book which first introduced me to the Functional Programming triad of map, filter and fold.
It was during my Computer Science degree that a fellow student gave me a copy of the first edition, not long after the book came out.
I have not yet come across a better introduction to these three functions.
The upcoming slides are closely based on the second edition of the book, a free online copy of which can be found here:
https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book.html.
Download for original image quality.
Errata:
slide 20: the Clojure map function is in fact the Scheme one repeated - see code below for correction.
Scheme code: https://github.com/philipschwarz/the-fp-triad-of-map-filter-and-fold-scheme
Clojure code: https://github.com/philipschwarz/the-fp-triad-of-map-filter-and-fold-clojure
The document discusses object-oriented programming concepts in C#, including defining classes, constructors, properties, static members, interfaces, inheritance, and polymorphism. It provides examples of defining a simple Cat class with fields, a constructor, properties, and methods. It also demonstrates using the Dog class by creating dog objects, setting their properties, and calling their bark method.
The document discusses principles and best practices for writing clean code, including using meaningful names, separating commands and queries, avoiding repetition, using exceptions instead of return codes, and following object-oriented principles like polymorphism instead of switch statements on objects. It provides examples of good and bad code for concepts like single responsibility, primitive obsession, and refused bequest. The overall goal is to write code that is readable, maintainable, and extendable.
The document provides an overview of object-oriented programming concepts in .NET such as classes, objects, methods, constructors, destructors, inheritance, polymorphism, interfaces, access modifiers, and static members. It defines each concept and provides examples to illustrate how they are implemented in C#.
Retrofit is a type-safe REST client library for Android and Java that allows defining REST APIs as Java interfaces. It simplifies HTTP communication by converting remote APIs into declarative interfaces. It supports synchronous, asynchronous, and observable API consumption. The Retrofit library was created by Square.
N-Queens Combinatorial Problem - Polyglot FP for Fun and Profit – Haskell and...
First see the problem solved using the List monad and a Scala for comprehension.
Then see the Scala program translated into Haskell, both using a do expressions and using a List comprehension.
Understand how the Scala for comprehension is desugared, and what role the withFilter function plays.
Also understand how the Haskell do expressions and List comprehension are desugared, and what role the guard function plays.
Scala code for Part 1: https://github.com/philipschwarz/n-queens-combinatorial-problem-scala-part-1
Errata: on slide 30, the resulting lists should be Haskell ones rather than Scala ones.
The document discusses variables and operators in Java. It defines variables as containers that store data like numbers and letters, and notes that data types determine what values can be stored. It then covers various data types including primitive types like int and float, and reference types like Strings and Arrays. The document also discusses operators like arithmetic, logical, and assignment operators. It provides examples of declaring and using variables and operators in Java code.
Most of us use Design Patterns on a daily basis without noticing. Design patterns are commonly defined as solutions to recurring design problems. Frameworks like Laravel use Design Patterns throughout the codebase to keep structure and maintainability. In this talk we will explore the Design Patterns used in Laravel.
The document discusses idiomatic Kotlin programming. It covers several topics including:
- Using expressions idiomatically in Kotlin like if/when expressions
- Examples of idiomatic patterns from the Kotlin standard library
- Best practices for null safety using safe calls, let, elvis operator
- Idiomatic use of classes, functions, and data classes
- Leveraging the Kotlin standard library
The document discusses monads and functional programming concepts. It begins by introducing monads and defining them mathematically. It then provides examples of monads in Java like Optional and Stream. It discusses how monads can be used to make errors, null values, and asynchronous behavior explicit in code through types. The document also shows how to create a custom Validation monad to handle errors from functions. Overall, it promotes using monads and the type system to build robust and readable functional code.
La teoria delle categorie sta alla programmazione funzionale come i GoF design pattern stanno a quella ad oggetti. Vista l’imminente introduzione delle lambda expression, è tempo anche per gli sviluppatori Java di imparare qualcosa in più riguardo ai più comuni pattern di programmazione funzionale. Le monadi sono probabilmente le più espressive (e forse le più incomprese) fra questi pattern, per cui lo scopo del talk è quello di introdurle, chiarendo con esempi pratici come e quando dovrebbero essere usate, sottolineando i loro vantaggi e mostrando come possono essere implementate in Java8.
Java 8 introduced several new features including lambda expressions, which allow functional-style programming in Java through functional interfaces containing a single abstract method, streams, which provide a way to process collections of objects in a declarative way, and default and static methods in interfaces to enable multiple inheritance. The document provides examples of using these new Java 8 features such as lambda expressions, functional interfaces, streams, and default and static methods in interfaces.
Java 8 introduced several new features including lambda expressions, functional interfaces, and streams to support functional programming. Interfaces can now contain default and static methods to allow multiple inheritance. Streams provide a way to process collections of data elements sequentially and support parallel processing.
This presentation provides an overview of key topics in Java class design; also covers best practices/tips and quiz questions. Based on our OCP 8 book.
Laziness, trampolines, monoids and other functional amenities: this is not yo...
by Mario Fusco - Lambdas are the main feature introduced with Java 8, but the biggest part of Java developers are still not very familliar with the most common functional idioms and patterns. The purpose of this talk is presenting with practical examples concepts like high-order functions, currying, functions composition, persistent data structures, lazy evaluation, recursion, trampolines and monoids showing how to implement them in Java and how thinking functionally can help us to design and develop more readable, reusable, performant, parallelizable and in a word better, code.
Java 8 new features or the ones you might actually use
Lambda expressions allow passing functions as arguments and simplify anonymous classes. Functional interfaces define a single abstract method that lambda expressions or method references can implement. Default methods enable adding new methods to interfaces without breaking existing code. Streams provide a declarative way to process collections through pipelines of intermediate and terminal operations. Other new features include date/time API improvements and the Optional class for null handling.
This document discusses the history and evolution of functional programming in Java, including lambda expressions and streams. It describes how lambda expressions allow passing behaviors as arguments to methods like normal data. This improves API design, opportunities for optimization, and code readability. Streams encourage a lazy, pipelined style and can execute operations in parallel. Functional idioms like immutability and pure functions help enforce correctness and isolation of side effects.
This document discusses parallel programming tools in Java. It covers the Fork/Join framework and Parallel Arrays API introduced in JDK 6 and 7. It also discusses stream parallelism introduced in JDK 8 for parallel collection processing. Some performance caveats of parallel programming discussed include lack of associativity and potential overhead of parallelization. Examples shown include parallel sorting of large lists and parallel reduction of stream elements.
Pro typescript.ch03.Object Orientation in TypeScript
The document discusses object-oriented programming concepts in TypeScript such as classes, inheritance, polymorphism, and mixins. It provides code examples of implementing interfaces and classes to demonstrate inheritance and composition. Mixins are discussed as a way to reuse behavior across class hierarchies by applying multiple base classes to a derived class using a mixin function. The examples show how to define mixin behaviors as classes and apply them to implementing classes to achieve multiple inheritance in TypeScript.
Столпы функционального программирования для адептов ООП, Николай Мозговой
This document provides an overview of functional programming concepts for object-oriented programmers. It discusses the fundamentals of FP including immutability, purity, first-class and higher-order functions, closures, and recursion. It provides examples of these concepts in languages like Lisp, F#, C#, and JavaScript. The document also compares OO and FP concepts and discusses derived FP concepts like partial application, lazy evaluation, and pattern matching.
The program defines a Car class with private String and double variables for model and price. It includes getter and setter methods for these variables. It constructs a Car object, sets its model and price using the setter methods, then prints the model and price using the getter methods. Between setting and getting, it checks if the price could be changed by calling the setter and printing a message if it returns false.
Object Oriented Programming_Chapter 3 (Two Lectures)
1- Let’s think on Inheritance
2- Let’s focus on Superclass’s Constructor
الكلية الجامعية للعلوم والتكنولوجيا - خان يونس
University college of science & technology
This document discusses methods in Java programming. It defines methods as collections of statements grouped together to perform operations. Methods can take parameters and return values. When a method is invoked, an activation record is created on the call stack to store its parameters and variables. The document discusses defining methods, passing arguments, return values, and method overloading. It also provides examples of tracing method calls and return values on the call stack.
This document contains solutions to exam problems related to recursion, induction, and object-oriented programming concepts in Java. It includes code for recursive methods to reverse a Word class, a proof of correctness for the reverse method using structural induction, code for Instrument, StringInstrument and PercussionInstrument classes in an inheritance hierarchy, and short answers explaining concepts like encapsulation, access modifiers, and abstract classes and methods.
The document discusses defining and using methods in Java. It defines what a method is and its key components like the method signature, return type, parameters, and body. It then demonstrates a sample max method to return the maximum of two numbers and traces the steps of invoking the method from the main method, including passing arguments, executing the method body, and returning the result. The document aims to explain the basics of methods in Java, including how to define reusable methods and invoke them to perform certain tasks.
The document discusses business automation in the cloud using Kogito. It begins with an introduction to business automation concepts like processes, rules, and workflows. It then provides an overview of Kogito, describing it as a cloud-native development, deployment and execution platform for business automation that uses technologies like Drools, jBPM, and Quarkus under the hood. The document also demonstrates a sample serverless workflow built with Kogito.
How and why I turned my old Java projects into a first-class serverless compo...
Mario Fusco discusses turning old Java rule engine projects into serverless components by refactoring them to run natively on GraalVM and integrate with Quarkus. He describes the limitations of ahead-of-time compilation with GraalVM, such as lack of dynamic classloading. He details refactoring Drools to use an executable model and removing dependencies on dynamic class definition. This allows Drools to natively compile on GraalVM. He also discusses integrating the refactored Drools with Quarkus.
The document discusses object-oriented programming (OOP) and functional programming (FP). It argues that OOP and FP are not opposites and can be effectively combined. It addresses common myths about FP, such as that it is new, hard, or only suitable for mathematical problems. The document also compares how OOP and FP approach concepts like decomposition, composition, error handling, and mutability/referential transparency. While both approaches have merits, the document concludes there is no single best approach and the choice depends on the problem and programmer preferences.
The document provides an overview of key features and internals of the Drools 6 rule engine, including:
- The Phreak algorithm, which is faster than ReteOO and uses set-based propagation for improved performance on large data sets.
- The deployment model which uses kjar modules that are self-contained, versioned JAR files containing rules, models, and configuration. This allows for incremental compilation and use of the KieScanner for automatic updates.
- Changes to type declarations which are now compiled into the kjar, allowing them to be used directly in Java code without reflection.
The story of Simon, an experienced OOP Java developer, exposed to the new lambda features of JDK 8. His friend Mario, a long-bearded FP geek, will try to convince him that FP can help him develop more readable and maintainable code. A journey into the discovery of the main new feature - lambda expressions - of JDK 8
This document compares different concurrency models on the JVM, including the native Java concurrency model based on threads, semaphores, and locks. It discusses the pros and cons of threads and locks, including issues around non-determinism from shared mutable state. Functional programming with immutable data and internal iteration is presented as an alternative that allows for free parallelism. The document also covers actors and their message passing approach, as well as software transactional memory.
The document discusses several key concepts in functional programming including:
1) Pure functions that are referentially transparent and have no side effects like modifying variables or data structures.
2) Immutable data and persistent data structures that allow for sharing without synchronization.
3) Separating computational logic from side effects improves modularity and allows for parallelization.
4) A pure functional core can be wrapped with functions that have side effects to push effects to the outer layers.
Real world DSL - making technical and business people speaking the same language
This document discusses domain specific languages (DSLs). It defines a DSL as a computer programming language with limited expressiveness focused on a particular domain to improve communication. The document discusses why DSLs are used to improve communication and maintainability. It also covers different types of DSLs, including internal and external DSLs. Examples of DSLs like Hibernate queries, jMock, and lambdaj are provided to illustrate DSL design patterns.
Drools was created as a rule engine but has expanded to become a business modeling platform through the integration of business rule management, business process management, and complex event processing. It achieves this through modules like Drools Expert (rules), Drools Flow (processes), Drools Fusion (events), and Drools Planner (planning). Drools Guvnor provides a centralized repository for managing knowledge bases. The platform uses a declarative approach to represent business logic and processes through rules, events, and planning constraints.
The document summarizes new features in Java 7-8 including lambda expressions, switch on strings, try-with-resources, and the fork/join framework. Java 8 will focus on lambda expressions to provide functional programming capabilities and default methods to allow interfaces to have default implementations without breaking existing implementations. Java 9 may include additional modularization support.
Hammurabi is an internal domain-specific language (DSL) for rule-based programming implemented in Scala. It allows domain experts to write rules in plain Scala code without learning a new language. Rules are evaluated by a rule engine that executes matching rules on a working memory of facts. The DSL aims to be readable, flexible and leverage Scala features like autocompletion. It also supports priorities, selecting objects, and exiting or failing evaluation. The architecture uses actors for concurrent rule evaluation. Future work includes improving performance using RETE algorithm and providing alternative selection methods.
This document summarizes Spring features for building loosely coupled, maintainable applications. It discusses how Spring promotes loose coupling through dependency injection and application events. It also describes how to implement workflows with jBPM and manage transactions declaratively in Spring.
Lambdaj is an internal DSL that allows manipulating collections without loops. It provides static methods to filter, sort, extract, and otherwise operate on collections. By treating collections as single objects and allowing method references, lambdaj can concisely represent operations that would otherwise require loops. While lambdaj is generally 4-6 times slower than iterative versions, it improves readability of collection operations.
Concurrency, Scalability & Fault-tolerance 2.0 with Akka Actors & STM
This document discusses concurrency, scalability, and fault tolerance using actors and software transactional memory (STM) in Akka. It describes how actors provide message-passing concurrency by isolating processes and avoiding shared state. Actors allow easy reasoning about concurrency by preventing issues like race conditions and deadlocks. The document also covers how Akka implements actors, typed actors, remote actors, supervisor hierarchies for fault tolerance, and STM for coordinating concurrent changes to shared state transactionally. Combining actors with STM results in "transactors" that allow building distributed, concurrent, and fault-tolerant applications.
The document provides an overview of a two-day training course on Scala that covers topics like object orientation, functional programming, pattern matching, generics, traits, case classes, tuples, collections, concurrency, options and monads. The course aims to show how Scala combines object-oriented and functional programming approaches and provides examples of commonly used Scala features like classes, traits, pattern matching, generics and collections.
The document discusses the introduction and advantages of lambda expressions and functional programming in Java 8. Some key points include:
- Lambda expressions allow passing behaviors as arguments to methods, simplifying code by removing bulky anonymous class syntax. This enables more powerful and expressive APIs.
- Streams provide a way to process collections of data in a declarative way, leveraging laziness to improve efficiency. Operations can be pipelined for fluent processing.
- Functional programming with immutable data and avoidance of side effects makes code more modular and easier to reason about, enabling optimizations like parallelism. While not natively supported, Java 8 features like lambda expressions facilitate a more functional approach.
Let's make a contract: the art of designing a Java APIMario Fusco
The document discusses best practices for designing Java APIs. It emphasizes making APIs intuitive, consistent, discoverable and easy to use. Some specific tips include using static factories to create objects, promoting fluent interfaces, using the weakest possible types, supporting lambdas, avoiding checked exceptions and properly managing resources using try-with-resources. The goal is to design APIs that are flexible, evolvable and minimize surprises for developers.
Monoids - Part 1 - with examples using Scalaz and CatsPhilip Schwarz
A monoid is an algebraic structure consisting of a set and a binary operation that is associative and has an identity element. Some key properties of monoids include:
1) A monoid consists of a type A, a binary operation op that combines two values of type A, and a zero value that acts as an identity.
2) The binary operation must be associative, meaning op(op(x,y),z) = op(x,op(y,z)).
3) The zero value must satisfy the identity laws: op(x, zero) = x and op(zero, x) = x.
4) Common examples of monoids include string concatenation
The document discusses clean coding practices for Java developers. It covers topics such as choosing meaningful names for variables, methods, and classes; writing code that is easy for others to understand; breaking methods down into single logical steps; and using fluent APIs to make code more readable. The presentation provides examples of clean code and ways to refactor code to follow best practices.
Optional was introduced in Java 8 to help deal with null references in a safer way. Optional wraps an object that may or may not be present, and supports methods like map, filter, and flatMap to operate on the wrapped value in a functional style. Using Optional helps avoid NullPointerExceptions and makes it clear whether a value is present or absent, improving code readability and safety over directly using null references.
Functional Programming 101 with Scala and ZIO @FunctionalWorldJorge Vásquez
This document provides an overview of functional programming concepts and the ZIO library. It discusses the characteristics of pure functions, including being total, deterministic, and having no side effects. It contrasts functional programming with object-oriented programming. Benefits of the functional paradigm discussed include local reasoning, referential transparency, conciseness, easier testing, and support for parallel programming. The document then introduces the ZIO library, describing how it allows building resilient, asynchronous, and efficient applications using functional principles. It outlines ZIO's data type and how it represents effects.
Presented on 27th September 2017 to a joint meeting of 'Cork Functional Programmers' and the 'Cork Java Users Group'
Based on the Kotlin Language programming course from Instil. For more details see https://instil.co/courses/kotlin-development/
Kotlin Bytecode Generation and Runtime Performanceintelliyole
In this talk, we'll dive into the details of how various language features supported by Kotlin are translated to Java bytecode. We'll use the JMH microbenchmarking tool to study the relative performance of various constructs and to understand how we can ensure top performance of the Kotlin code that we write.
The Functional Programming Triad of Map, Filter and FoldPhilip Schwarz
This slide deck is my homage to SICP, the book which first introduced me to the Functional Programming triad of map, filter and fold.
It was during my Computer Science degree that a fellow student gave me a copy of the first edition, not long after the book came out.
I have not yet come across a better introduction to these three functions.
The upcoming slides are closely based on the second edition of the book, a free online copy of which can be found here:
https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book.html.
Download for original image quality.
Errata:
slide 20: the Clojure map function is in fact the Scheme one repeated - see code below for correction.
Scheme code: https://github.com/philipschwarz/the-fp-triad-of-map-filter-and-fold-scheme
Clojure code: https://github.com/philipschwarz/the-fp-triad-of-map-filter-and-fold-clojure
The document discusses object-oriented programming concepts in C#, including defining classes, constructors, properties, static members, interfaces, inheritance, and polymorphism. It provides examples of defining a simple Cat class with fields, a constructor, properties, and methods. It also demonstrates using the Dog class by creating dog objects, setting their properties, and calling their bark method.
The document discusses principles and best practices for writing clean code, including using meaningful names, separating commands and queries, avoiding repetition, using exceptions instead of return codes, and following object-oriented principles like polymorphism instead of switch statements on objects. It provides examples of good and bad code for concepts like single responsibility, primitive obsession, and refused bequest. The overall goal is to write code that is readable, maintainable, and extendable.
The document provides an overview of object-oriented programming concepts in .NET such as classes, objects, methods, constructors, destructors, inheritance, polymorphism, interfaces, access modifiers, and static members. It defines each concept and provides examples to illustrate how they are implemented in C#.
Retrofit is a type-safe REST client library for Android and Java that allows defining REST APIs as Java interfaces. It simplifies HTTP communication by converting remote APIs into declarative interfaces. It supports synchronous, asynchronous, and observable API consumption. The Retrofit library was created by Square.
N-Queens Combinatorial Problem - Polyglot FP for Fun and Profit – Haskell and...Philip Schwarz
First see the problem solved using the List monad and a Scala for comprehension.
Then see the Scala program translated into Haskell, both using a do expressions and using a List comprehension.
Understand how the Scala for comprehension is desugared, and what role the withFilter function plays.
Also understand how the Haskell do expressions and List comprehension are desugared, and what role the guard function plays.
Scala code for Part 1: https://github.com/philipschwarz/n-queens-combinatorial-problem-scala-part-1
Errata: on slide 30, the resulting lists should be Haskell ones rather than Scala ones.
The document discusses variables and operators in Java. It defines variables as containers that store data like numbers and letters, and notes that data types determine what values can be stored. It then covers various data types including primitive types like int and float, and reference types like Strings and Arrays. The document also discusses operators like arithmetic, logical, and assignment operators. It provides examples of declaring and using variables and operators in Java code.
Most of us use Design Patterns on a daily basis without noticing. Design patterns are commonly defined as solutions to recurring design problems. Frameworks like Laravel use Design Patterns throughout the codebase to keep structure and maintainability. In this talk we will explore the Design Patterns used in Laravel.
The document discusses idiomatic Kotlin programming. It covers several topics including:
- Using expressions idiomatically in Kotlin like if/when expressions
- Examples of idiomatic patterns from the Kotlin standard library
- Best practices for null safety using safe calls, let, elvis operator
- Idiomatic use of classes, functions, and data classes
- Leveraging the Kotlin standard library
The document discusses monads and functional programming concepts. It begins by introducing monads and defining them mathematically. It then provides examples of monads in Java like Optional and Stream. It discusses how monads can be used to make errors, null values, and asynchronous behavior explicit in code through types. The document also shows how to create a custom Validation monad to handle errors from functions. Overall, it promotes using monads and the type system to build robust and readable functional code.
La teoria delle categorie sta alla programmazione funzionale come i GoF design pattern stanno a quella ad oggetti. Vista l’imminente introduzione delle lambda expression, è tempo anche per gli sviluppatori Java di imparare qualcosa in più riguardo ai più comuni pattern di programmazione funzionale. Le monadi sono probabilmente le più espressive (e forse le più incomprese) fra questi pattern, per cui lo scopo del talk è quello di introdurle, chiarendo con esempi pratici come e quando dovrebbero essere usate, sottolineando i loro vantaggi e mostrando come possono essere implementate in Java8.
Java 8 introduced several new features including lambda expressions, which allow functional-style programming in Java through functional interfaces containing a single abstract method, streams, which provide a way to process collections of objects in a declarative way, and default and static methods in interfaces to enable multiple inheritance. The document provides examples of using these new Java 8 features such as lambda expressions, functional interfaces, streams, and default and static methods in interfaces.
Java 8 introduced several new features including lambda expressions, functional interfaces, and streams to support functional programming. Interfaces can now contain default and static methods to allow multiple inheritance. Streams provide a way to process collections of data elements sequentially and support parallel processing.
This presentation provides an overview of key topics in Java class design; also covers best practices/tips and quiz questions. Based on our OCP 8 book.
Laziness, trampolines, monoids and other functional amenities: this is not yo...Codemotion
by Mario Fusco - Lambdas are the main feature introduced with Java 8, but the biggest part of Java developers are still not very familliar with the most common functional idioms and patterns. The purpose of this talk is presenting with practical examples concepts like high-order functions, currying, functions composition, persistent data structures, lazy evaluation, recursion, trampolines and monoids showing how to implement them in Java and how thinking functionally can help us to design and develop more readable, reusable, performant, parallelizable and in a word better, code.
Java 8 new features or the ones you might actually useSharon Rozinsky
Lambda expressions allow passing functions as arguments and simplify anonymous classes. Functional interfaces define a single abstract method that lambda expressions or method references can implement. Default methods enable adding new methods to interfaces without breaking existing code. Streams provide a declarative way to process collections through pipelines of intermediate and terminal operations. Other new features include date/time API improvements and the Optional class for null handling.
This document discusses the history and evolution of functional programming in Java, including lambda expressions and streams. It describes how lambda expressions allow passing behaviors as arguments to methods like normal data. This improves API design, opportunities for optimization, and code readability. Streams encourage a lazy, pipelined style and can execute operations in parallel. Functional idioms like immutability and pure functions help enforce correctness and isolation of side effects.
JDK8 : parallel programming made (too ?) easyJosé Paumard
This document discusses parallel programming tools in Java. It covers the Fork/Join framework and Parallel Arrays API introduced in JDK 6 and 7. It also discusses stream parallelism introduced in JDK 8 for parallel collection processing. Some performance caveats of parallel programming discussed include lack of associativity and potential overhead of parallelization. Examples shown include parallel sorting of large lists and parallel reduction of stream elements.
Pro typescript.ch03.Object Orientation in TypeScriptSeok-joon Yun
The document discusses object-oriented programming concepts in TypeScript such as classes, inheritance, polymorphism, and mixins. It provides code examples of implementing interfaces and classes to demonstrate inheritance and composition. Mixins are discussed as a way to reuse behavior across class hierarchies by applying multiple base classes to a derived class using a mixin function. The examples show how to define mixin behaviors as classes and apply them to implementing classes to achieve multiple inheritance in TypeScript.
Столпы функционального программирования для адептов ООП, Николай МозговойSigma Software
This document provides an overview of functional programming concepts for object-oriented programmers. It discusses the fundamentals of FP including immutability, purity, first-class and higher-order functions, closures, and recursion. It provides examples of these concepts in languages like Lisp, F#, C#, and JavaScript. The document also compares OO and FP concepts and discusses derived FP concepts like partial application, lazy evaluation, and pattern matching.
The program defines a Car class with private String and double variables for model and price. It includes getter and setter methods for these variables. It constructs a Car object, sets its model and price using the setter methods, then prints the model and price using the getter methods. Between setting and getting, it checks if the price could be changed by calling the setter and printing a message if it returns false.
Object Oriented Programming_Chapter 3 (Two Lectures)
1- Let’s think on Inheritance
2- Let’s focus on Superclass’s Constructor
الكلية الجامعية للعلوم والتكنولوجيا - خان يونس
University college of science & technology
This document discusses methods in Java programming. It defines methods as collections of statements grouped together to perform operations. Methods can take parameters and return values. When a method is invoked, an activation record is created on the call stack to store its parameters and variables. The document discusses defining methods, passing arguments, return values, and method overloading. It also provides examples of tracing method calls and return values on the call stack.
This document contains solutions to exam problems related to recursion, induction, and object-oriented programming concepts in Java. It includes code for recursive methods to reverse a Word class, a proof of correctness for the reverse method using structural induction, code for Instrument, StringInstrument and PercussionInstrument classes in an inheritance hierarchy, and short answers explaining concepts like encapsulation, access modifiers, and abstract classes and methods.
The document discusses defining and using methods in Java. It defines what a method is and its key components like the method signature, return type, parameters, and body. It then demonstrates a sample max method to return the maximum of two numbers and traces the steps of invoking the method from the main method, including passing arguments, executing the method body, and returning the result. The document aims to explain the basics of methods in Java, including how to define reusable methods and invoke them to perform certain tasks.
Kogito: cloud native business automationMario Fusco
The document discusses business automation in the cloud using Kogito. It begins with an introduction to business automation concepts like processes, rules, and workflows. It then provides an overview of Kogito, describing it as a cloud-native development, deployment and execution platform for business automation that uses technologies like Drools, jBPM, and Quarkus under the hood. The document also demonstrates a sample serverless workflow built with Kogito.
How and why I turned my old Java projects into a first-class serverless compo...Mario Fusco
Mario Fusco discusses turning old Java rule engine projects into serverless components by refactoring them to run natively on GraalVM and integrate with Quarkus. He describes the limitations of ahead-of-time compilation with GraalVM, such as lack of dynamic classloading. He details refactoring Drools to use an executable model and removing dependencies on dynamic class definition. This allows Drools to natively compile on GraalVM. He also discusses integrating the refactored Drools with Quarkus.
The document discusses object-oriented programming (OOP) and functional programming (FP). It argues that OOP and FP are not opposites and can be effectively combined. It addresses common myths about FP, such as that it is new, hard, or only suitable for mathematical problems. The document also compares how OOP and FP approach concepts like decomposition, composition, error handling, and mutability/referential transparency. While both approaches have merits, the document concludes there is no single best approach and the choice depends on the problem and programmer preferences.
The document provides an overview of key features and internals of the Drools 6 rule engine, including:
- The Phreak algorithm, which is faster than ReteOO and uses set-based propagation for improved performance on large data sets.
- The deployment model which uses kjar modules that are self-contained, versioned JAR files containing rules, models, and configuration. This allows for incremental compilation and use of the KieScanner for automatic updates.
- Changes to type declarations which are now compiled into the kjar, allowing them to be used directly in Java code without reflection.
OOP and FP - Become a Better ProgrammerMario Fusco
The story of Simon, an experienced OOP Java developer, exposed to the new lambda features of JDK 8. His friend Mario, a long-bearded FP geek, will try to convince him that FP can help him develop more readable and maintainable code. A journey into the discovery of the main new feature - lambda expressions - of JDK 8
Comparing different concurrency models on the JVMMario Fusco
This document compares different concurrency models on the JVM, including the native Java concurrency model based on threads, semaphores, and locks. It discusses the pros and cons of threads and locks, including issues around non-determinism from shared mutable state. Functional programming with immutable data and internal iteration is presented as an alternative that allows for free parallelism. The document also covers actors and their message passing approach, as well as software transactional memory.
Why we cannot ignore Functional ProgrammingMario Fusco
The document discusses several key concepts in functional programming including:
1) Pure functions that are referentially transparent and have no side effects like modifying variables or data structures.
2) Immutable data and persistent data structures that allow for sharing without synchronization.
3) Separating computational logic from side effects improves modularity and allows for parallelization.
4) A pure functional core can be wrapped with functions that have side effects to push effects to the outer layers.
Real world DSL - making technical and business people speaking the same languageMario Fusco
This document discusses domain specific languages (DSLs). It defines a DSL as a computer programming language with limited expressiveness focused on a particular domain to improve communication. The document discusses why DSLs are used to improve communication and maintainability. It also covers different types of DSLs, including internal and external DSLs. Examples of DSLs like Hibernate queries, jMock, and lambdaj are provided to illustrate DSL design patterns.
Drools was created as a rule engine but has expanded to become a business modeling platform through the integration of business rule management, business process management, and complex event processing. It achieves this through modules like Drools Expert (rules), Drools Flow (processes), Drools Fusion (events), and Drools Planner (planning). Drools Guvnor provides a centralized repository for managing knowledge bases. The platform uses a declarative approach to represent business logic and processes through rules, events, and planning constraints.
Java 7, 8 & 9 - Moving the language forwardMario Fusco
The document summarizes new features in Java 7-8 including lambda expressions, switch on strings, try-with-resources, and the fork/join framework. Java 8 will focus on lambda expressions to provide functional programming capabilities and default methods to allow interfaces to have default implementations without breaking existing implementations. Java 9 may include additional modularization support.
Hammurabi is an internal domain-specific language (DSL) for rule-based programming implemented in Scala. It allows domain experts to write rules in plain Scala code without learning a new language. Rules are evaluated by a rule engine that executes matching rules on a working memory of facts. The DSL aims to be readable, flexible and leverage Scala features like autocompletion. It also supports priorities, selecting objects, and exiting or failing evaluation. The architecture uses actors for concurrent rule evaluation. Future work includes improving performance using RETE algorithm and providing alternative selection methods.
This document summarizes Spring features for building loosely coupled, maintainable applications. It discusses how Spring promotes loose coupling through dependency injection and application events. It also describes how to implement workflows with jBPM and manage transactions declaratively in Spring.
Lambdaj is an internal DSL that allows manipulating collections without loops. It provides static methods to filter, sort, extract, and otherwise operate on collections. By treating collections as single objects and allowing method references, lambdaj can concisely represent operations that would otherwise require loops. While lambdaj is generally 4-6 times slower than iterative versions, it improves readability of collection operations.
This document discusses concurrency, scalability, and fault tolerance using actors and software transactional memory (STM) in Akka. It describes how actors provide message-passing concurrency by isolating processes and avoiding shared state. Actors allow easy reasoning about concurrency by preventing issues like race conditions and deadlocks. The document also covers how Akka implements actors, typed actors, remote actors, supervisor hierarchies for fault tolerance, and STM for coordinating concurrent changes to shared state transactionally. Combining actors with STM results in "transactors" that allow building distributed, concurrent, and fault-tolerant applications.
Scala - where objects and functions meetMario Fusco
The document provides an overview of a two-day training course on Scala that covers topics like object orientation, functional programming, pattern matching, generics, traits, case classes, tuples, collections, concurrency, options and monads. The course aims to show how Scala combines object-oriented and functional programming approaches and provides examples of commonly used Scala features like classes, traits, pattern matching, generics and collections.
How Social Media Hackers Help You to See Your Wife's Message.pdfHackersList
In the modern digital era, social media platforms have become integral to our daily lives. These platforms, including Facebook, Instagram, WhatsApp, and Snapchat, offer countless ways to connect, share, and communicate.
Best Practices for Effectively Running dbt in Airflow.pdfTatiana Al-Chueyr
As a popular open-source library for analytics engineering, dbt is often used in combination with Airflow. Orchestrating and executing dbt models as DAGs ensures an additional layer of control over tasks, observability, and provides a reliable, scalable environment to run dbt models.
This webinar will cover a step-by-step guide to Cosmos, an open source package from Astronomer that helps you easily run your dbt Core projects as Airflow DAGs and Task Groups, all with just a few lines of code. We’ll walk through:
- Standard ways of running dbt (and when to utilize other methods)
- How Cosmos can be used to run and visualize your dbt projects in Airflow
- Common challenges and how to address them, including performance, dependency conflicts, and more
- How running dbt projects in Airflow helps with cost optimization
Webinar given on 9 July 2024
YOUR RELIABLE WEB DESIGN & DEVELOPMENT TEAM — FOR LASTING SUCCESS
WPRiders is a web development company specialized in WordPress and WooCommerce websites and plugins for customers around the world. The company is headquartered in Bucharest, Romania, but our team members are located all over the world. Our customers are primarily from the US and Western Europe, but we have clients from Australia, Canada and other areas as well.
Some facts about WPRiders and why we are one of the best firms around:
More than 700 five-star reviews! You can check them here.
1500 WordPress projects delivered.
We respond 80% faster than other firms! Data provided by Freshdesk.
We’ve been in business since 2015.
We are located in 7 countries and have 22 team members.
With so many projects delivered, our team knows what works and what doesn’t when it comes to WordPress and WooCommerce.
Our team members are:
- highly experienced developers (employees & contractors with 5 -10+ years of experience),
- great designers with an eye for UX/UI with 10+ years of experience
- project managers with development background who speak both tech and non-tech
- QA specialists
- Conversion Rate Optimisation - CRO experts
They are all working together to provide you with the best possible service. We are passionate about WordPress, and we love creating custom solutions that help our clients achieve their goals.
At WPRiders, we are committed to building long-term relationships with our clients. We believe in accountability, in doing the right thing, as well as in transparency and open communication. You can read more about WPRiders on the About us page.
Sustainability requires ingenuity and stewardship. Did you know Pigging Solutions pigging systems help you achieve your sustainable manufacturing goals AND provide rapid return on investment.
How? Our systems recover over 99% of product in transfer piping. Recovering trapped product from transfer lines that would otherwise become flush-waste, means you can increase batch yields and eliminate flush waste. From raw materials to finished product, if you can pump it, we can pig it.
Understanding Insider Security Threats: Types, Examples, Effects, and Mitigat...Bert Blevins
Today’s digitally connected world presents a wide range of security challenges for enterprises. Insider security threats are particularly noteworthy because they have the potential to cause significant harm. Unlike external threats, insider risks originate from within the company, making them more subtle and challenging to identify. This blog aims to provide a comprehensive understanding of insider security threats, including their types, examples, effects, and mitigation techniques.
Coordinate Systems in FME 101 - Webinar SlidesSafe Software
If you’ve ever had to analyze a map or GPS data, chances are you’ve encountered and even worked with coordinate systems. As historical data continually updates through GPS, understanding coordinate systems is increasingly crucial. However, not everyone knows why they exist or how to effectively use them for data-driven insights.
During this webinar, you’ll learn exactly what coordinate systems are and how you can use FME to maintain and transform your data’s coordinate systems in an easy-to-digest way, accurately representing the geographical space that it exists within. During this webinar, you will have the chance to:
- Enhance Your Understanding: Gain a clear overview of what coordinate systems are and their value
- Learn Practical Applications: Why we need datams and projections, plus units between coordinate systems
- Maximize with FME: Understand how FME handles coordinate systems, including a brief summary of the 3 main reprojectors
- Custom Coordinate Systems: Learn how to work with FME and coordinate systems beyond what is natively supported
- Look Ahead: Gain insights into where FME is headed with coordinate systems in the future
Don’t miss the opportunity to improve the value you receive from your coordinate system data, ultimately allowing you to streamline your data analysis and maximize your time. See you there!
Blockchain technology is transforming industries and reshaping the way we conduct business, manage data, and secure transactions. Whether you're new to blockchain or looking to deepen your knowledge, our guidebook, "Blockchain for Dummies", is your ultimate resource.
Kief Morris rethinks the infrastructure code delivery lifecycle, advocating for a shift towards composable infrastructure systems. We should shift to designing around deployable components rather than code modules, use more useful levels of abstraction, and drive design and deployment from applications rather than bottom-up, monolithic architecture and delivery.
Transcript: Details of description part II: Describing images in practice - T...BookNet Canada
This presentation explores the practical application of image description techniques. Familiar guidelines will be demonstrated in practice, and descriptions will be developed “live”! If you have learned a lot about the theory of image description techniques but want to feel more confident putting them into practice, this is the presentation for you. There will be useful, actionable information for everyone, whether you are working with authors, colleagues, alone, or leveraging AI as a collaborator.
Link to presentation recording and slides: https://bnctechforum.ca/sessions/details-of-description-part-ii-describing-images-in-practice/
Presented by BookNet Canada on June 25, 2024, with support from the Department of Canadian Heritage.
Measuring the Impact of Network Latency at TwitterScyllaDB
Widya Salim and Victor Ma will outline the causal impact analysis, framework, and key learnings used to quantify the impact of reducing Twitter's network latency.
TrustArc Webinar - 2024 Data Privacy Trends: A Mid-Year Check-InTrustArc
Six months into 2024, and it is clear the privacy ecosystem takes no days off!! Regulators continue to implement and enforce new regulations, businesses strive to meet requirements, and technology advances like AI have privacy professionals scratching their heads about managing risk.
What can we learn about the first six months of data privacy trends and events in 2024? How should this inform your privacy program management for the rest of the year?
Join TrustArc, Goodwin, and Snyk privacy experts as they discuss the changes we’ve seen in the first half of 2024 and gain insight into the concrete, actionable steps you can take to up-level your privacy program in the second half of the year.
This webinar will review:
- Key changes to privacy regulations in 2024
- Key themes in privacy and data governance in 2024
- How to maximize your privacy program in the second half of 2024
How RPA Help in the Transportation and Logistics Industry.pptxSynapseIndia
Revolutionize your transportation processes with our cutting-edge RPA software. Automate repetitive tasks, reduce costs, and enhance efficiency in the logistics sector with our advanced solutions.
The DealBook is our annual overview of the Ukrainian tech investment industry. This edition comprehensively covers the full year 2023 and the first deals of 2024.
Implementations of Fused Deposition Modeling in real worldEmerging Tech
The presentation showcases the diverse real-world applications of Fused Deposition Modeling (FDM) across multiple industries:
1. **Manufacturing**: FDM is utilized in manufacturing for rapid prototyping, creating custom tools and fixtures, and producing functional end-use parts. Companies leverage its cost-effectiveness and flexibility to streamline production processes.
2. **Medical**: In the medical field, FDM is used to create patient-specific anatomical models, surgical guides, and prosthetics. Its ability to produce precise and biocompatible parts supports advancements in personalized healthcare solutions.
3. **Education**: FDM plays a crucial role in education by enabling students to learn about design and engineering through hands-on 3D printing projects. It promotes innovation and practical skill development in STEM disciplines.
4. **Science**: Researchers use FDM to prototype equipment for scientific experiments, build custom laboratory tools, and create models for visualization and testing purposes. It facilitates rapid iteration and customization in scientific endeavors.
5. **Automotive**: Automotive manufacturers employ FDM for prototyping vehicle components, tooling for assembly lines, and customized parts. It speeds up the design validation process and enhances efficiency in automotive engineering.
6. **Consumer Electronics**: FDM is utilized in consumer electronics for designing and prototyping product enclosures, casings, and internal components. It enables rapid iteration and customization to meet evolving consumer demands.
7. **Robotics**: Robotics engineers leverage FDM to prototype robot parts, create lightweight and durable components, and customize robot designs for specific applications. It supports innovation and optimization in robotic systems.
8. **Aerospace**: In aerospace, FDM is used to manufacture lightweight parts, complex geometries, and prototypes of aircraft components. It contributes to cost reduction, faster production cycles, and weight savings in aerospace engineering.
9. **Architecture**: Architects utilize FDM for creating detailed architectural models, prototypes of building components, and intricate designs. It aids in visualizing concepts, testing structural integrity, and communicating design ideas effectively.
Each industry example demonstrates how FDM enhances innovation, accelerates product development, and addresses specific challenges through advanced manufacturing capabilities.
3. Learning a new language is relatively easy
compared with learning a new paradigm.
new language < new paradigm
Functional Programming is more a new
way of thinking than a new tool set
5. What is a monad?
A monad is a triple (T, η, μ) where T is an endofunctor T: X → X
and η: I → T and μ: T x T → T are 2 natural transformations
satisfying these laws:
Identity law: μ(η(T)) = T = μ(T(η))
Associative law: μ(μ(T × T) × T)) = μ(T × μ(T × T))
In other words: "a monad in X is just a monoid in the category of
endofunctors of X, with product × replaced by composition of
endofunctors and unit set by the identity endofunctor"
What's the problem?
6. … really? do I need to know this?
In order to understand
monads you need to first
learn Cathegory Theory
In order to understand
pizza you need to first
learn Italian
… it's like saying …
8. … no seriously, what is a monad?
A
monad
is a
structure
that puts a
value
in a
computational context
9. … and why should we care about?
Reduce code duplication
Improve maintainability
Increase readability
Remove side effects
Hide complexity
Encapsulate implementation details
Allow composability
10. {
return flatMap( x -> unit( f.apply(x) ) );
}
Monadic Methods
M<A> unit(A a);
M<B> bind(M<A> ma, Function<A, M<B>> f);
interface M {
M<B> map(Function<A, B> f);
M<B> flatMap(Function<A, M<B>> f);
}
map can defined for every monad as
a combination of flatMap and unit
11. public class Person {
private Car car;
public Car getCar() { return car; }
}
public class Car {
private Insurance insurance;
public Insurance getInsurance() { return insurance; }
}
public class Insurance {
private String name;
public String getName() { return name; }
}
Finding Car's Insurance Name
12. String getCarInsuranceName(Person person) {
if (person != null) {
Car car = person.getCar();
if (car != null) {
Insurance insurance = car.getInsurance();
if (insurance != null) {
return insurance.getName()
}
}
}
return "Unknown";
}
Attempt 1: deep doubts
13. Attempt 2: too many choices
String getCarInsuranceName(Person person) {
if (person == null) {
return "Unknown";
}
Car car = person.getCar();
if (car == null) {
return "Unknown";
}
Insurance insurance = car.getInsurance();
if (insurance == null) {
return "Unknown";
}
return insurance.getName()
}
14. What wrong with nulls?
✗
Errors source → NPE is by far the most common exception in Java
✗
Bloatware source → Worsen readability by making necessary to fill our code
with null checks
✗
Breaks Java philosophy → Java always hides pointers to developers, except
in one case: the null pointer
✗
A hole in the type system → Null has the bottom type, meaning that it can
be assigned to any reference type: this is a problem because, when
propagated to another part of the system, you have no idea what that null
was initially supposed to be
✗
Meaningless → Don't have any semantic meaning and in particular are the
wrong way to model the absence of a value in a statically typed language
“Absence of a signal should never be used as a signal“ - J. Bigalow, 1947
Tony Hoare, who invented the null reference in 1965 while working on
an object oriented language called ALGOL W, called its invention his
“billion dollar mistake”
15. Optional Monad to the rescue
public class Optional<T> {
private static final Optional<?> EMPTY = new Optional<>(null);
private final T value;
private Optional(T value) {
this.value = value;
}
public<U> Optional<U> map(Function<? super T, ? extends U> f) {
return value == null ? EMPTY : new Optional(f.apply(value));
}
public<U> Optional<U> flatMap(Function<? super T, Optional<U>> f) {
return value == null ? EMPTY : f.apply(value);
}
}
16. public class Person {
private Optional<Car> car;
public Optional<Car> getCar() { return car; }
}
public class Car {
private Optional<Insurance> insurance;
public Optional<Insurance> getInsurance() { return insurance; }
}
public class Insurance {
private String name;
public String getName() { return name; }
}
Rethinking our model
Using the type system
to model nullable value
27. The Optional Monad
The Optional monad makes
the possibility of missing data
explicit
in the type system, while
hiding
the boilerplate of "if non-null" logic
29. Using map & flatMap with Streams
building.getApartments().stream().
.flatMap(apartment -> apartment.getPersons().stream())
.map(Person::getName);
flatMap( -> )
StreamStream
map( -> )
StreamStream
30. Given n>0 find all pairs i and j
where 1 ≤ j ≤ i ≤ n and i+j is prime
Stream.iterate(1, i -> i+1).limit(n)
.flatMap(i -> Stream.iterate(1, j -> j+1).limit(n)
.map(j -> new int[]{i, j}))
.filter(pair -> isPrime(pair[0] + pair[1]))
.collect(toList());
public boolean isPrime(int n) {
return Stream.iterate(2, i -> i+1)
.limit((long) Math.sqrt(n))
.noneMatch(i -> n % i == 0);
}
31. The Stream Monad
The Stream monad makes
the possibility of multiple data
explicit
in the type system, while
hiding
the boilerplate of nested loops
32. No Monads syntactic sugar in Java :(
for { i <- List.range(1, n)
j <- List.range(1, i)
if isPrime(i + j) } yield {i, j}
List.range(1, n)
.flatMap(i =>
List.range(1, i)
.filter(j => isPrime(i+j))
.map(j => (i, j)))
Scala's for-comprehension
is just syntactic sugar to
manipulate monadstranslated by the compiler in
35. Promise: a monadic CompletableFuture
public class Promise<A> implements Future<A> {
private final CompletableFuture<A> future;
private Promise(CompletableFuture<A> future) {
this.future = future;
}
public static final <A> Promise<A> promise(Supplier<A> supplier) {
return new
Promise<A>(CompletableFuture.supplyAsync(supplier));
}
public <B> Promise<B> map(Function<? super A,? extends B> f) {
return new Promise<B>(future.thenApplyAsync(f));
}
public <B> Promise<B> flatMap(Function<? super A, Promise<B>> f) {
return new Promise<B>(
future.thenComposeAsync(a -> f.apply(a).future));
}
// ... omitting methods delegating the wrapped future
}
36. public int slowLength(String s) {
someLongComputation();
return s.length();
}
public int slowDouble(int i) {
someLongComputation();
return i*2;
}
String s = "Hello";
Promise<Integer> p = promise(() -> slowLength(s))
.flatMap(i -> promise(() -> slowDouble(i)));
Composing long computations
37. The Promise Monad
The Promise monad makes
asynchronous computation
explicit
in the type system, while
hiding
the boilerplate thread logic
39. Lost in Exceptions
public Person validateAge(Person p) throws ValidationException {
if (p.getAge() > 0 && p.getAge() < 130) return p;
throw new ValidationException("Age must be between 0 and 130");
}
public Person validateName(Person p) throws ValidationException {
if (Character.isUpperCase(p.getName().charAt(0))) return p;
throw new ValidationException("Name must start with uppercase");
}
List<String> errors = new ArrayList<String>();
try {
validateAge(person);
} catch (ValidationException ex) {
errors.add(ex.getMessage());
}
try {
validateName(person);
} catch (ValidationException ex) {
errors.add(ex.getMessage());
}
40. public abstract class Validation<L, A> {
protected final A value;
private Validation(A value) {
this.value = value;
}
public abstract <B> Validation<L, B> map(
Function<? super A, ? extends B> mapper);
public abstract <B> Validation<L, B> flatMap(
Function<? super A, Validation<?, ? extends B>> mapper);
public abstract boolean isSuccess();
}
Defining a Validation Monad
41. Success !!!
public class Success<L, A> extends Validation<L, A> {
private Success(A value) { super(value); }
public <B> Validation<L, B> map(
Function<? super A, ? extends B> mapper) {
return success(mapper.apply(value));
}
public <B> Validation<L, B> flatMap(
Function<? super A, Validation<?, ? extends B>> mapper) {
return (Validation<L, B>) mapper.apply(value);
}
public boolean isSuccess() { return true; }
public static <L, A> Success<L, A> success(A value) {
return new Success<L, A>(value);
}
}
42. Failure :(((
public class Failure<L, A> extends Validation<L, A> {
protected final L left;
public Failure(A value, L left) {super(value); this.left = left;}
public <B> Validation<L, B> map(
Function<? super A, ? extends B> mapper) {
return failure(left, mapper.apply(value));
}
public <B> Validation<L, B> flatMap(
Function<? super A, Validation<?, ? extends B>> mapper) {
Validation<?, ? extends B> result = mapper.apply(value);
return result.isSuccess() ?
failure(left, result.value) :
failure(((Failure<L, B>)result).left, result.value);
}
public boolean isSuccess() { return false; }
}
43. The Validation Monad
The Validation monad makes
the possibility of errors
explicit
in the type system, while
hiding
the boilerplate of "try/catch" logic
44. Rewriting validating methods
public Validation<String, Person> validateAge(Person p) {
return (p.getAge() > 0 && p.getAge() < 130) ?
success(p) :
failure("Age must be between 0 and 130", p);
}
public Validation<String, Person> validateName(Person p) {
return Character.isUpperCase(p.getName().charAt(0)) ?
success(p) :
failure("Name must start with uppercase", p);
}
46. Gathering multiple errors - Success
public class SuccessList<L, A> extends Success<List<L>, A> {
public SuccessList(A value) { super(value); }
public <B> Validation<List<L>, B> map(
Function<? super A, ? extends B> mapper) {
return new SuccessList(mapper.apply(value));
}
public <B> Validation<List<L>, B> flatMap(
Function<? super A, Validation<?, ? extends B>> mapper) {
Validation<?, ? extends B> result = mapper.apply(value);
return (Validation<List<L>, B>)(result.isSuccess() ?
new SuccessList(result.value) :
new FailureList<L, B>(((Failure<L, B>)result).left,
result.value));
}
}
47. Gathering multiple errors - Failure
public class FailureList<L, A> extends Failure<List<L>, A> {
private FailureList(List<L> left, A value) { super(left, value); }
public <B> Validation<List<L>, B> map(
Function<? super A, ? extends B> mapper) {
return new FailureList(left, mapper.apply(value));
}
public <B> Validation<List<L>, B> flatMap(
Function<? super A, Validation<?, ? extends B>> mapper) {
Validation<?, ? extends B> result = mapper.apply(value);
return (Validation<List<L>, B>)(result.isSuccess() ?
new FailureList(left, result.value) :
new FailureList<L, B>(new ArrayList<L>(left) {{
add(((Failure<L, B>)result).left);
}}, result.value));
}
}
49. Homework: develop your own
Transaction Monad
The Transaction monad makes
transactionally
explicit
in the type system, while
hiding
the boilerplate propagation of invoking rollbacks
50. Alternative Monads Definitions
Monads are parametric types with two operations
flatMap and unit that obey some algebraic laws
Monads are structures that represent
computations defined as sequences of steps
Monads are chainable containers types that confine
values defining how to transform and combine them
Monads are return types that
guide you through the happy path
52. A OOP BankAccount ...
public class Balance {
final BigDecimal amount;
public Balance( BigDecimal amount ) { this.amount = amount; }
}
public class Account {
private final String owner;
private final String number;
private Balance balance = new Balance(BigDecimal.ZERO);
public Account( String owner, String number ) {
this.owner = owner;
this.number = number;
}
public void credit(BigDecimal value) {
balance = new Balance( balance.amount.add( value ) );
}
public void debit(BigDecimal value) throws InsufficientBalanceException {
if (balance.amount.compareTo( value ) < 0)
throw new InsufficientBalanceException();
balance = new Balance( balance.amount.subtract( value ) );
}
}
Mutability
Error handling
using Exception
53. … and how we can use it
Account a = new Account("Alice", "123");
Account b = new Account("Bob", "456");
Account c = new Account("Charlie", "789");
List<Account> unpaid = new ArrayList<>();
for (Account account : Arrays.asList(a, b, c)) {
try {
account.debit( new BigDecimal( 100.00 ) );
} catch (InsufficientBalanceException e) {
unpaid.add(account);
}
}
List<Account> unpaid = new ArrayList<>();
Stream.of(a, b, c).forEach( account -> {
try {
account.debit( new BigDecimal( 100.00 ) );
} catch (InsufficientBalanceException e) {
unpaid.add(account);
}
} );
Mutation of enclosing scope
Cannot use a parallel Stream
Ugly syntax
54. Error handling with Try monad
public interface Try<A> {
<B> Try<B> map(Function<A, B> f);
<B> Try<B> flatMap(Function<A, Try<B>> f);
boolean isFailure();
}
public Success<A> implements Try<A> {
private final A value;
public Success(A value) { this.value = value; }
public boolean isFailure() { return false; }
public <B> Try<B> map(Function<A, B> f) {
return new Success<>(f.apply(value));
}
public <B> Try<B> flatMap(Function<A, Try<B>> f) {
return f.apply(value);
}
}
public Failure<A> implements Try<T> {
private final Object error;
public Failure(Object error) { this.error = error; }
public boolean isFailure() { return false; }
public <B> Try<B> map(Function<A, B> f) { return (Failure<B>)this; }
public <B> Try<B> flatMap(Function<A, Try<B>> f) { return (Failure<B>)this; }
}
55. A functional BankAccount ...
public class Account {
private final String owner;
private final String number;
private final Balance balance;
public Account( String owner, String number, Balance balance ) {
this.owner = owner;
this.number = number;
this.balance = balance;
}
public Account credit(BigDecimal value) {
return new Account( owner, number,
new Balance( balance.amount.add( value ) ) );
}
public Try<Account> debit(BigDecimal value) {
if (balance.amount.compareTo( value ) < 0)
return new Failure<>( new InsufficientBalanceError() );
return new Success<>(
new Account( owner, number,
new Balance( balance.amount.subtract( value ) ) ) );
}
}
Immutable
Error handling
without Exceptions
56. … and how we can use it
Account a = new Account("Alice", "123");
Account b = new Account("Bob", "456");
Account c = new Account("Charlie", "789");
List<Account> unpaid =
Stream.of( a, b, c )
.map( account ->
new Tuple2<>( account,
account.debit( new BigDecimal( 100.00 ) ) ) )
.filter( t -> t._2.isFailure() )
.map( t -> t._1 )
.collect( toList() );
List<Account> unpaid =
Stream.of( a, b, c )
.filter( account ->
account.debit( new BigDecimal( 100.00 ) )
.isFailure() )
.collect( toList() );
57. From Methods to Functions
public class BankService {
public static Try<Account> open(String owner, String number,
BigDecimal balance) {
if (initialBalance.compareTo( BigDecimal.ZERO ) < 0)
return new Failure<>( new InsufficientBalanceError() );
return new Success<>( new Account( owner, number,
new Balance( balance ) ) );
}
public static Account credit(Account account, BigDecimal value) {
return new Account( account.owner, account.number,
new Balance( account.balance.amount.add( value ) ) );
}
public static Try<Account> debit(Account account, BigDecimal value) {
if (account.balance.amount.compareTo( value ) < 0)
return new Failure<>( new InsufficientBalanceError() );
return new Success<>(
new Account( account.owner, account.number,
new Balance( account.balance.amount.subtract( value ) ) ) );
}
}
58. Decoupling state and behavior
import static BankService.*
Try<Account> account =
open( "Alice", "123", new BigDecimal( 100.00 ) )
.map( acc -> credit( acc, new BigDecimal( 200.00 ) ) )
.map( acc -> credit( acc, new BigDecimal( 300.00 ) ) )
.flatMap( acc -> debit( acc, new BigDecimal( 400.00 ) ) );
The object-oriented paradigm couples state and behavior
Functional programming decouples them
59. … but I need a BankConnection!
What about dependency injection?
60. A naïve solution
public class BankService {
public static Try<Account> open(String owner, String number,
BigDecimal balance, BankConnection bankConnection) {
...
}
public static Account credit(Account account, BigDecimal value,
BankConnection bankConnection) {
...
}
public static Try<Account> debit(Account account, BigDecimal value,
BankConnection bankConnection) {
...
}
}
BankConnection bconn = new BankConnection();
Try<Account> account =
open( "Alice", "123", new BigDecimal( 100.00 ), bconn )
.map( acc -> credit( acc, new BigDecimal( 200.00 ), bconn ) )
.map( acc -> credit( acc, new BigDecimal( 300.00 ), bconn ) )
.flatMap( acc -> debit( acc, new BigDecimal( 400.00 ), bconn ) );
Necessary to create the
BankConnection in advance ...
… and pass it to all methods
61. Making it lazy
public class BankService {
public static Function<BankConnection, Try<Account>>
open(String owner, String number, BigDecimal balance) {
return (BankConnection bankConnection) -> ...
}
public static Function<BankConnection, Account>
credit(Account account, BigDecimal value) {
return (BankConnection bankConnection) -> ...
}
public static Function<BankConnection, Try<Account>>
debit(Account account, BigDecimal value) {
return (BankConnection bankConnection) -> ...
}
}
Function<BankConnection, Try<Account>> f =
(BankConnection conn) ->
open( "Alice", "123", new BigDecimal( 100.00 ) )
.apply( conn )
.map( acc -> credit( acc, new BigDecimal( 200.00 ) ).apply( conn ) )
.map( acc -> credit( acc, new BigDecimal( 300.00 ) ).apply( conn ) )
.flatMap( acc -> debit( acc, new BigDecimal( 400.00 ) ).apply( conn ) );
Try<Account> account = f.apply( new BankConnection() );
62. open
Ctx -> S1
S1
A, B
credit
Ctx
S2
C, D
result
open
S1
A, B, Ctx
injection
credit
C, D, Ctx, S1
resultS2
Pure OOP implementation Static Methods
open
A, B
apply(Ctx)
S1
Ctx -> S2
apply(Ctx)
S2
C, D
Lazy evaluation
Ctx
credit
result
63. Introducing the Reader monad ...
public class Reader<R, A> {
private final Function<R, A> run;
public Reader( Function<R, A> run ) {
this.run = run;
}
public <B> Reader<R, B> map(Function<A, B> f) {
...
}
public <B> Reader<R, B> flatMap(Function<A, Reader<R, B>> f) {
...
}
public A apply(R r) {
return run.apply( r );
}
}
The reader monad provides an environment to
wrap an abstract computation without evaluating it
64. Introducing the Reader monad ...
public class Reader<R, A> {
private final Function<R, A> run;
public Reader( Function<R, A> run ) {
this.run = run;
}
public <B> Reader<R, B> map(Function<A, B> f) {
return new Reader<>((R r) -> f.apply( apply( r ) ));
}
public <B> Reader<R, B> flatMap(Function<A, Reader<R, B>> f) {
return new Reader<>((R r) -> f.apply( apply( r ) ).apply( r ));
}
public A apply(R r) {
return run.apply( r );
}
}
The reader monad provides an environment to
wrap an abstract computation without evaluating it
65. The Reader Monad
The Reader monad makes
a lazy computation
explicit
in the type system, while
hiding
the logic to apply it
In other words the reader monad
allows us to treat functions as
values with a context
We can act as if we already know
what the functions will return.
66. … and combining it with Try
public class TryReader<R, A> {
private final Function<R, Try<A>> run;
public TryReader( Function<R, Try<A>> run ) {
this.run = run;
}
public <B> TryReader<R, B> map(Function<A, B> f) {
...
}
public <B> TryReader<R, B> mapReader(Function<A, Reader<R, B>> f) {
...
}
public <B> TryReader<R, B> flatMap(Function<A, TryReader<R, B>> f) {
...
}
public Try<A> apply(R r) {
return run.apply( r );
}
}
67. … and combining it with Try
public class TryReader<R, A> {
private final Function<R, Try<A>> run;
public TryReader( Function<R, Try<A>> run ) {
this.run = run;
}
public <B> TryReader<R, B> map(Function<A, B> f) {
return new TryReader<R, B>((R r) -> apply( r )
.map( a -> f.apply( a ) ));
}
public <B> TryReader<R, B> mapReader(Function<A, Reader<R, B>> f) {
return new TryReader<R, B>((R r) -> apply( r )
.map( a -> f.apply( a ).apply( r ) ));
}
public <B> TryReader<R, B> flatMap(Function<A, TryReader<R, B>> f) {
return new TryReader<R, B>((R r) -> apply( r )
.flatMap( a -> f.apply( a ).apply( r ) ));
}
public Try<A> apply(R r) {
return run.apply( r );
}
}
68. A more user-friendly API
public class BankService {
public static TryReader<BankConnection, Account>
open(String owner, String number, BigDecimal balance) {
return new TryReader<>( (BankConnection bankConnection) -> ... )
}
public static Reader<BankConnection, Account>
credit(Account account, BigDecimal value) {
return new Reader<>( (BankConnection bankConnection) -> ... )
}
public static TryReader<BankConnection, Account>
debit(Account account, BigDecimal value) {
return new TryReader<>( (BankConnection bankConnection) -> ... )
}
}
TryReader<BankConnection, Account> reader =
open( "Alice", "123", new BigDecimal( 100.00 ) )
.mapReader( acc -> credit( acc, new BigDecimal( 200.00 ) ) )
.mapReader( acc -> credit( acc, new BigDecimal( 300.00 ) ) )
.flatMap( acc -> debit( acc, new BigDecimal( 400.00 ) ) );
Try<Account> account = reader.apply( new BankConnection() );
69. open
Ctx -> S1
S1
A, B
credit
Ctx
S2
C, D
result
open
S1
A, B, Ctx
injection
credit
C, D, Ctx, S1
resultS2
Pure OOP implementation Static Methods
open
A, B
apply(Ctx)
S1
Ctx -> S2
apply(Ctx)
S2
C, D
Lazy evaluation
Ctx
credit
Reader monad
result
Ctx -> S1
A, B C, D
map(credit)
Ctx -> result
apply(Ctx)
open
Ctx -> S2
70. To recap: a Monad is a design
patternAlias
flatMap that shit
Intent
Put a value in a computational context defining the policy
on how to operate on it
Motivations
Reduce code duplication
Improve maintainability
Increase readability
Remove side effects
Hide complexity
Encapusalate implementation details
Allow composability
Known Uses
Optional, Stream, Promise, Validation, Transaction, State, …
71. Use Monads whenever possible
to keep your code clean and
encapsulate repetitive logic
TL;DR
73. Mario Fusco
Red Hat – Senior Software Engineer
mario.fusco@gmail.com
twitter: @mariofusco
Q A
Thanks … Questions?