Slides of my talk as Devoxx 2015. How to set up asynchronous data processing pipelines using the CompletionStage / CompletableFuture API, including how to control threads and how to handle exceptions.
The aggregate is dead! Long live the aggregate! - SpringIO.pdfSara Pellegrini
https://2023.springio.net/sessions/the-aggregate-is-dead-long-live-the-aggregate/
SARA PELLEGRINI - AXONIQ
MILAN SAVIC - AXONIQ
DDD’s definition of Aggregate may seem somewhat confusing - “An aggregate is a cluster of associated objects that we treat as a unit for the purpose of data changes.” Okay, let’s try to clarify - “You should consider your aggregate as a unit of consistency in your Domain.”. That doesn’t help either. As a matter of fact, while modeling our systems, we tend to group together events related to the same domain concept; we tend to define groups based on the nouns we find inside our events’ name: saying “this is our aggregate!”. According to the aggregate definition, we should instead ignore these nouns, and put together the data that change together. Easier said than done: in the modeling phase it is easy to make mistakes trying to identify the boundaries of our aggregates based on this rule. If we opt for saving the state of our aggregate as a series of events, we are in big trouble - any (serious) refactoring of the aggregate structure becomes close to impossible. The reason for this trouble is that we have to make a decision in the design phase for which we cannot be lenient. We are basically married to this decision forever. Due to the aforementioned reasons (and many others), people struggle with the Aggregate pattern. Some even say it is unnecessary, we are one of those. Let’s see whether we can model our business constraints without aggregates. Could we be more relaxed when consistency is in question? Join us to discover how!
Design functional solutions in Java, a practical exampleMarian Wamsiedel
Starting with a simple programming task I present here some solutions based on functional programming and a standard object oriented one.
The code samples are written in Java. A github repository contains the complete code implementation.
The aggregate is dead! Long live the aggregate! - SpringIO.pdfSara Pellegrini
https://2023.springio.net/sessions/the-aggregate-is-dead-long-live-the-aggregate/
SARA PELLEGRINI - AXONIQ
MILAN SAVIC - AXONIQ
DDD’s definition of Aggregate may seem somewhat confusing - “An aggregate is a cluster of associated objects that we treat as a unit for the purpose of data changes.” Okay, let’s try to clarify - “You should consider your aggregate as a unit of consistency in your Domain.”. That doesn’t help either. As a matter of fact, while modeling our systems, we tend to group together events related to the same domain concept; we tend to define groups based on the nouns we find inside our events’ name: saying “this is our aggregate!”. According to the aggregate definition, we should instead ignore these nouns, and put together the data that change together. Easier said than done: in the modeling phase it is easy to make mistakes trying to identify the boundaries of our aggregates based on this rule. If we opt for saving the state of our aggregate as a series of events, we are in big trouble - any (serious) refactoring of the aggregate structure becomes close to impossible. The reason for this trouble is that we have to make a decision in the design phase for which we cannot be lenient. We are basically married to this decision forever. Due to the aforementioned reasons (and many others), people struggle with the Aggregate pattern. Some even say it is unnecessary, we are one of those. Let’s see whether we can model our business constraints without aggregates. Could we be more relaxed when consistency is in question? Join us to discover how!
Design functional solutions in Java, a practical exampleMarian Wamsiedel
Starting with a simple programming task I present here some solutions based on functional programming and a standard object oriented one.
The code samples are written in Java. A github repository contains the complete code implementation.
Commands, events, queries - three types of messages that travel through your application. Some originate from the web, some from the command-line. Your application sends some of them to a database, or a message queue. What is the ideal infrastructure for an application to support this on-going stream of messages? What kind of architectural design fits best?
This talk provides answers to these questions: we take the *hexagonal* approach to software architecture. We look at messages, how they cross boundaries and how you can make steady communication lines between your application and other systems, like web browsers, terminals, databases and message queues. You will learn how to separate the technical aspects of these connections from the core behavior of your application by implementing design patterns like the *command bus*, and design principles like *dependency inversion*.
React Components Lifecycle | React Tutorial for Beginners | ReactJS Training ...Edureka!
This Edureka tutorial on React Components will help you in understanding the fundamentals of components in ReactJS. This tutorial helps you learn the following topics:
1. React Components
2. Props
3. State
4. Flow Of Stateless & Stateful Component
5. Lifecycle Of Component
We like the architecture of our applications to revolve around the business logic, not around technical details (and especially not around the database).
In my team at Sky Network Services we use the Clean Architecture and it has given us a great deal of benefits: the business logic is explicit, we are free to change our technical decisions, the app is easy to test, working on it is faster and scalable, it’s hard to do the wrong thing, and many more.
But it comes at a cost, of course. In this talk I’ll tell you the story of our experience with Clean Architecture and give you some tips to get the most out of it.
Example Project
https://github.com/mattia-battiston/clean-architecture-example
Downloads
Online: https://goo.gl/DTxftJ
PDF: https://goo.gl/ZAtdBN
Powerpoint: https://goo.gl/D54wdZ (but you need to install these fonts to see it properly: https://goo.gl/iH8SO5)
Clean Pragmatic Architecture - Avoiding a MonolithVictor Rentea
Talk built based on several of my trainings: http://www.victorrentea.ro/#training
Covers: Clean/Onion/Hexagonal Architecture, Domain Entities, Value Objects, Repository, Extract When it Grows Principle, Dependency Inversion Principle, Clean Code and Design Patterns.
These are the backing slides of the talks given at JPoint 2017 and Devoxx PL 2017: https://www.youtube.com/embed/4-4ahz7zDiQ
A Practical Guide to Domain Driven Design: Presentation Slidesthinkddd
Tonight I presented on Domain Driven Design to the Alt.Net group in Sydney at the invite of Richard Banks.
As a follow up, attached are the slides I used, feel free to distribute and use on the Creative Commons Licence
Watch this talk here: https://www.confluent.io/online-talks/apache-kafka-architecture-and-fundamentals-explained-on-demand
This session explains Apache Kafka’s internal design and architecture. Companies like LinkedIn are now sending more than 1 trillion messages per day to Apache Kafka. Learn about the underlying design in Kafka that leads to such high throughput.
This talk provides a comprehensive overview of Kafka architecture and internal functions, including:
-Topics, partitions and segments
-The commit log and streams
-Brokers and broker replication
-Producer basics
-Consumers, consumer groups and offsets
This session is part 2 of 4 in our Fundamentals for Apache Kafka series.
Explanation of the fundamentals of Redux with additional tips and good practices. Presented in the Munich React Native Meetup, so the sample code is using React Native. Additional code: https://github.com/nacmartin/ReduxIntro
Resilience4j is a lightweight fault tolerance library that provides a variety of fault tolerance and stability patterns to a web application. In this knolx session, we'll learn how to use this library with a simple Spring Boot application.
Top Angular Interview Questions and answers would help freshers and experienced candidates clear any Angular interview .Do let us know the Angular questions you faced in the interview that are covered ...
The Spring IoC container is at the core of the Spring Framework. The container will create the objects, wire them together, configure them, and manage their complete life cycle from creation till destruction. The Spring container uses dependency injection (DI) to manage the components that make up an application.
This talk introduces Spring's REST stack - Spring MVC, Spring HATEOAS, Spring Data REST, Spring Security OAuth and Spring Social - while refining an API to move higher up the Richardson maturity model
Spring Web MVC is the original web framework built on the Servlet API and has been included in the Spring Framework from the very beginning. The formal name, “Spring Web MVC,” comes from the name of its source module (spring-webmvc), but it is more commonly known as “Spring MVC”.
Parallel to Spring Web MVC, Spring Framework 5.0 introduced a reactive-stack web framework whose name, “Spring WebFlux,” is also based on its source module (spring-webflux). This section covers Spring Web MVC.
Commands, events, queries - three types of messages that travel through your application. Some originate from the web, some from the command-line. Your application sends some of them to a database, or a message queue. What is the ideal infrastructure for an application to support this on-going stream of messages? What kind of architectural design fits best?
This talk provides answers to these questions: we take the *hexagonal* approach to software architecture. We look at messages, how they cross boundaries and how you can make steady communication lines between your application and other systems, like web browsers, terminals, databases and message queues. You will learn how to separate the technical aspects of these connections from the core behavior of your application by implementing design patterns like the *command bus*, and design principles like *dependency inversion*.
React Components Lifecycle | React Tutorial for Beginners | ReactJS Training ...Edureka!
This Edureka tutorial on React Components will help you in understanding the fundamentals of components in ReactJS. This tutorial helps you learn the following topics:
1. React Components
2. Props
3. State
4. Flow Of Stateless & Stateful Component
5. Lifecycle Of Component
We like the architecture of our applications to revolve around the business logic, not around technical details (and especially not around the database).
In my team at Sky Network Services we use the Clean Architecture and it has given us a great deal of benefits: the business logic is explicit, we are free to change our technical decisions, the app is easy to test, working on it is faster and scalable, it’s hard to do the wrong thing, and many more.
But it comes at a cost, of course. In this talk I’ll tell you the story of our experience with Clean Architecture and give you some tips to get the most out of it.
Example Project
https://github.com/mattia-battiston/clean-architecture-example
Downloads
Online: https://goo.gl/DTxftJ
PDF: https://goo.gl/ZAtdBN
Powerpoint: https://goo.gl/D54wdZ (but you need to install these fonts to see it properly: https://goo.gl/iH8SO5)
Clean Pragmatic Architecture - Avoiding a MonolithVictor Rentea
Talk built based on several of my trainings: http://www.victorrentea.ro/#training
Covers: Clean/Onion/Hexagonal Architecture, Domain Entities, Value Objects, Repository, Extract When it Grows Principle, Dependency Inversion Principle, Clean Code and Design Patterns.
These are the backing slides of the talks given at JPoint 2017 and Devoxx PL 2017: https://www.youtube.com/embed/4-4ahz7zDiQ
A Practical Guide to Domain Driven Design: Presentation Slidesthinkddd
Tonight I presented on Domain Driven Design to the Alt.Net group in Sydney at the invite of Richard Banks.
As a follow up, attached are the slides I used, feel free to distribute and use on the Creative Commons Licence
Watch this talk here: https://www.confluent.io/online-talks/apache-kafka-architecture-and-fundamentals-explained-on-demand
This session explains Apache Kafka’s internal design and architecture. Companies like LinkedIn are now sending more than 1 trillion messages per day to Apache Kafka. Learn about the underlying design in Kafka that leads to such high throughput.
This talk provides a comprehensive overview of Kafka architecture and internal functions, including:
-Topics, partitions and segments
-The commit log and streams
-Brokers and broker replication
-Producer basics
-Consumers, consumer groups and offsets
This session is part 2 of 4 in our Fundamentals for Apache Kafka series.
Explanation of the fundamentals of Redux with additional tips and good practices. Presented in the Munich React Native Meetup, so the sample code is using React Native. Additional code: https://github.com/nacmartin/ReduxIntro
Resilience4j is a lightweight fault tolerance library that provides a variety of fault tolerance and stability patterns to a web application. In this knolx session, we'll learn how to use this library with a simple Spring Boot application.
Top Angular Interview Questions and answers would help freshers and experienced candidates clear any Angular interview .Do let us know the Angular questions you faced in the interview that are covered ...
The Spring IoC container is at the core of the Spring Framework. The container will create the objects, wire them together, configure them, and manage their complete life cycle from creation till destruction. The Spring container uses dependency injection (DI) to manage the components that make up an application.
This talk introduces Spring's REST stack - Spring MVC, Spring HATEOAS, Spring Data REST, Spring Security OAuth and Spring Social - while refining an API to move higher up the Richardson maturity model
Spring Web MVC is the original web framework built on the Servlet API and has been included in the Spring Framework from the very beginning. The formal name, “Spring Web MVC,” comes from the name of its source module (spring-webmvc), but it is more commonly known as “Spring MVC”.
Parallel to Spring Web MVC, Spring Framework 5.0 introduced a reactive-stack web framework whose name, “Spring WebFlux,” is also based on its source module (spring-webflux). This section covers Spring Web MVC.
This Presentation presents how Data science can bring manifold benefits to Retail Broking. Machine Learning & Text Analytics can impact your business in many positive ways- gives you that competitive edge and gains you customer satisfaction & loyalty
First appeal under RTI Act 2005 against Registrar (J-I) Supreme Court of Indi...Om Prakash Poddar
First appeal under RTI Act 2005 against Registrar (J-I) Supreme Court of India for REFUSAL OF REGISTRATION OF WRIT CRIMINAL AGAINST UNION OF INDIA D.NO.2188 OF 2017
Aggrieved by the reply of Adl. Registrar & CPIO, Supreme Court of India dated 04.03.2017, appellant preferred First Appeal against CPIO of Supreme Court of India dated 07.03.2017 before Ld. Registrar (Admin) & First Appellate Authority (FAA) Supreme Court of India at New Delhi.
Transformation structurelle et émergence au Sénégal - Madaniou DIEMEMadaniou DIEME
Dans un contexte marqué par la vision d’un Sénégal émergent (émergence économique) et la lutte contre la pauvreté (émergence sociale), l’étude sur la transformation structurelle pour l’émergence du Sénégal, trouve toute sa justification empirique et toute son actualité.
There are a lot of great things about the cloud, but the "destroy and rebuild" philosophy which is really good for building a continuous delivery pipeline, really sucks when applied to troubleshooting production problems. When your application goes haywire, the most valuable engineering skill is not the the ability to bring up a copy of your system or even the knowledge of your technology stack (although it doesn't hurt). It is the skill of understanding and solving problems.
Finding the root cause of the issue and mitigating it with minimal disruption in production is a must-have skill for engineers responsible for managing and maintaining production systems, which nowadays includes ops, dbas and devs alike. In this talk I will discuss the skills required to troubleshoot complex systems, traits that prevent engineers from being successful at troubleshooting and discuss some techniques and tips and trick for troubleshooting complex systems in production.
DevOpsDays Baltimore March 2017 - Continuous Integration: A bittersweet love ...Suzie Prince
This is the bittersweet story of Continuous Integration. CI is practice that we fell in love with, embraced and then never fully committed to. I’ll share with you the current state of CI, what we think we are doing when we say CI and what we are really doing in terms of CI. Then I’ll remind us all why we fell in love with CI in the first place and make some suggestions on how to get back to the good stuff.
Updated for 2017. Presented at DevOpsDays Baltimore 2017.
Leveraging Completable Futures to handle your query results AsynchrhonouslyDavid Gómez García
The challenges of developing applications recently have increased. With the popularity of cloud environments, the scalability required by new architectures and the need to support more load efficiently, there has been an increase in attention that we need to pay to concurrency and efficiency.
One strategy to achieve that efficiency consists of distributing the modules of your application in several different smaller components running concurrently. But one of the problems that arise from such distribution of running modules comes when you need to send a request (and wait for the response) to several different modules. How do you design that request(s)-response(s) to be as efficient as possible?
CompletableFutures was introduced with Java 8 but has evolved over the years with every new version of Java released. In this talk, we will take a look at it, to:
understand how to use CompletableFutures,
how they can help us to split our workload into different request and coordinate them asynchronously and concurrently
How you can chain behavior to the responses.
How you can use CompletableFuture in your design to create APIs that enable your users to get the most of your Component/library/module.
Leverage CompletableFutures to handle async queries. DevNexus 2022David Gómez García
Slides used at DevNexus 22 talk.
Completable futures were introduced in Java 8, and they are a powerful mechanism to add concurrency (not parallelism) to your application logic, and it may be handy when dealing with multiple queries to different systems.
If you are a developer, you may make your code more performant by using CompletableFutures where it makes sense.
If you are a library developer, it may be a good thing to offer an API that returns CompletableFutures so that your users will be able to benefit from it.
Functional Programming is preferred since it uses pure functions and values and keeps side effects at bay. However, while building real-life applications, side effects are often needed in the scenario when, say, one needs to query a database or read from or write to the stream.
If you’re facing this challenge in your projects too, then IO Monads can come to your rescue. Explore how using IO Monads, Scala developers can smoothly encapsulate side effects and write graceful programs while maintaining purity in Functional programming.
1. How to deal with side-effects in Scala in a purely functional way?
2. Important features like
a) Synchronous and asynchronous computations
b) Error handling
c) Concurrency
d) Parallelism
e) Cancellation
Java 8 Puzzlers as it was presented at Codemash 2017Baruch Sadogursky
We aren’t sure about you, but working with Java 8 made one of the speakers lose all of his hair and the other lose his sleep (or was it the jetlag?). If you still haven’t reached the level of Brian Goetz in mastering lambdas and strings, this talk is for you. And if you think you have, we have some bad news for you, you should attend as well. Baruch and Viktor will show you some surprising, bizarre, and inconceivable parts of Java 8 and make sure that you won’t be (too) surprised when it hits you in production. As with any other puzzlers talk, there will be two speakers, lots of puzzling questions, answers by the audience, T-shirts flying around, and a lot of fun, all for one purpose—to help you better understand Java 8.
Writing a REST Interconnection Library in SwiftPablo Villar
(a.k.a. #warilis) This is a talk I gave on our first SwiftBA Meetup event on June 8th, 2016 at Inaka's Offices.
In this talk, I covered 3 main aspects:
1. Motivation: How does our need for such a library emerge? Why should we need it? What should or goals be?
2. Architectural Concept: How do we architecture this library? Which design patterns could help us?
3. Implementation: How do we code this library in a Swifty manner? How can we take advantage of Swift's powerful features?
At the very end, I conclude presenting Jayme: (https://github.com/inaka/Jayme), a real case open-source library that I've developed with help of some of my workmates at Inaka, in which I based this talk's concepts and code snippets.
P.S.: My apologies, I couldn't find a way to export this PDF respecting the stages of each slide, so they were exported without animations.
Java APIs- The missing manual (concurrency)Hendrik Ebbers
This isn’t a talk about microservices, NoSQL, container solutions or hip new frameworks. This talk will show some of the standard Java APIs that are part of Java since version 5, 6, 7 or 8. All those features are very helpful to create maintainable and future-proof applications, regardless of whether JavaEE, Spring, JavaFX or any other framework is used. The talk will give an overview of some important standard concepts and APIs of Java like annotations, null values and concurrency.
Ultimate Node.js countdown: the coolest Application Express examplesAlan Arentsen
Node.js is hot and that's not without a reason. There are numerous examples of large websites using Node.js and there is some pretty cool stuff out there.
Since Application Express is officially 'Awesome' and Node.js is 'hot', why not combine the two? With node-oracledb and websockets you can do awesome things, but there is more Node.js has to offer!
In this presentation you will get a short introduction on Node.js. After that I will show you a handful of Node.js applications in Application Express sorted on awesomeness from cool to sub zero.
어느덧 스무살이 된 자바. 좋든싫든 프로그래밍의 세계에 몸담고 있는 이상 부딪히지 않을 수 없는 언어인데요, 이 자바에 대한 올바른 모습의 이해화 앞으로 나아가야 할 방향을 모색해본다는 의미에서 "모던 자바의 역습"이라는 타이틀로 실시한 온라인 세미나의 슬라이드 자료입니다.
진행자: 김대우(http://lekdw.blogspot.kr/)
정도현(http://moreagile.net)
이번 세미나는 게임개발자이신 김대우님을 모시고 진행하게 되었는데요 자바 언어와 관련 하여 다음과 같은 주제로 두시간에 걸쳐 발표를 진행합니다.
- 간단히 살펴보는 자바20년의 발자취
- 자바를 둘러싼 진실 혹은 거짓(성능,생산성,품질)
- SI영역 이외에서 자바의 가치
- 모던자바의 역습: 자바8과 함수형 프로그래밍
- 자바 개발의 새로운 패러다임들
The Loom project has been under work for many years, and just delivered Virtual Threads as a preview feature in the JDK 19. We now have a very precise idea of what they are and what you can do with them. Our good old Threads, created more than 25 years ago, will see a new kind of lightweight threads. This presentation shows you that creating a thread is easier and much cheaper, allowing the creation of millions of them in a single JVM. These virtual threads can be block at almost no cost. These new virtual threads bring with them new notions that will be covered in this talk. Loom threads are coming, and they will change the landscape of concurrent programming in Java.
The features released between Java 11 and Java 17 have brought a greater opportunity for developers to improve application development productivity as well and code expressiveness and readability. In this deep-dive session, you will discover all the recent Project Amber features added to the Java language such as Text blocks, Records (including Records serialization), Pattern Matching for instanceof, switch expression, sealed classes, and pattern matching for switch. The main goal of the Amber Project is to bring Pattern Matching to the Java platform, which will impact both the language and the JDK APIs. You will discover record patterns, array patterns, as well as deconstruction patterns, through constructors, factory methods, and deconstructors.
The Future of Java: Records, Sealed Classes and Pattern MatchingJosé Paumard
The release of the JDK 17 brings interesting features in the Java language: sealed types and pattern matching for switch. Along with the introduction of records, the implementation of pattern matching in the Java language begins to take shape. This presentation shows you how records, sealed types, and pattern matching can change the way we write Java code, on real patterns. It also shows you what we can expect to see on this topic in the future. It is mostly a live coding presentation, with some slides when the code is shown cannot be executed.
The features released between Java 11 and Java 17 have brought a greater opportunity for developers to improve application development productivity as well and code expressiveness and readability. In this deep-dive session, you will discover all the recent Project Amber features added to the Java language such as Records (including Records serialization), Pattern Matching for `instanceof`, switch expression, sealed classes, and hidden classes. The main goal of the Amber Project is to bring Pattern Matching to the Java platform, which will impact both the language and the JDK APsI. You will discover record patterns, array patterns, as well as deconstruction patterns, through constructors, factory methods, and deconstructors.
You can find the code shown here: https://github.com/JosePaumard/devoxx-uk-2021
Designing functional and fluent API: application to some GoF patternsJosé Paumard
These are the slides of my Devnexus 2020 talk. The code is avaiblable on my GitHub account: https://github.com/JosePaumard/devnexus-2020-visitor-lambda. You can see a replay of this talk (in a slightly different version) here: https://youtu.be/gq23w9nycBs
Those are the slides of the presentation we made with Maurice Naftalin à Goto: Copenhagen 2019.
Functional programmers have been saying for decades that they know the way to the future. Clearly they've been wrong, since imperative languages are still far more popular. Clearly they've also been right, as the advantages of functional programming have become increasingly obvious. Is it possible to combine the two models? Scala is one language that does this, and Java too has been on a journey, which still continues, of learning from functional languages and carefully adding features from them. In this talk, we'll review what Java has learned from functional languages, what it can still learn, and how its added features compare to Scala's original ones.
Slides from the talk we did with Maurice Naftalin for Devoxx Belgium 2019.
Functional programmers have been saying for decades that they know the way to the future.
Clearly they have been wrong, since imperative languages are still far more popular.
Clearly they have also been right, as the advantages of functional programming have become increasingly obvious. Is it possible to face both ways, and combine the two models?
Scala is one language that does this, and Java too has been on a journey, which still continues, of learning from functional languages and carefully adding features from them.
In this talk, we will review what Java has learned from functional languages, what it can still learn, and how its added features compare to Scala's original ones.
Designing functional and fluent API: example of the Visitor PatternJosé Paumard
This is the slide deck of my talk from Devoxx Belgium 2019. You can watch the video here https://www.youtube.com/watch?v=gq23w9nycBs and get the code here: https://github.com/JosePaumard/devoxx-belgium-2019-visitor-lambda.
Among the patterns from the GoF, the Visitor is probably the more complex to implement. One of the difficulties is that you need to implement it in your object model, leading to complex refactoring for legacy applications. Based on the use of all the nifty tools brought by functional programming: chaining, composition, and partial application, you can implement Visitors without having to change your object model, using a functional and fluent API. This approach can be used to implement other patterns: Builder and Validator. Using this way of designing API leads to readable and robust code, designed following the GoF patterns.
Les slides du Tools in Action que j'ai donné à Devoxx France 2019.
Le JDK est open source et son développement aussi. L'ensemble des nouveautés vit sur des branches Mercurial qui peuvent être téléchargées et compilées à la demande. Cela permet de jouer avec des fonctionnalités encore en chantier, de regarder comment les nouvelles syntaxes fonctionneront, bref, de jouer avec un JDK du futur, qui n'existera peut-être jamais. L'objet de ce tools in action est simple : montrer comment tout ceci fonctionne, de l'installation d'une machine Ubuntu à l'exécution d'un JDK recompilé maison.
Le slide deck de l'Université que nous avons donnée avec Rémi Forax à Devoxx France 2019.
Comme promis, Java sort sa version majeure tous les 6 mois. Le train passe et amène son lot de nouveautés. Parmi elles, certaines sont sorties : une nouvelle syntaxe pour les clauses switch et l'instruction de byte code CONSTANT_DYNAMIC. D'autres sont en chantier, plus ou moins avancé : une nouvelle façon d'écrire des méthodes de façon condensée, un instanceof 'intelligent', des constantes évaluées au moment où elles sont utilisées. Les projets progressent. Loom, et son nouveau modèle de programmation concurrente que l'ont peut tester avec Jetty. Amber, qui introduit les data types et des nouvelles syntaxes. Valhalla, dont les value types donnent leurs premiers résultats. S'il est difficile de prévoir une date de sortie pour ces nouveautés, on sait en revanche qu'une fois prêtes elles sortiront en moins de 6 mois. De tout ceci nous parlerons donc au futur et en public, avec des démonstrations de code, des slides, du code, de la joie et de la bonne humeur !
Lambdas and Streams Master Class Part 2José Paumard
These are the slides of the talk we made with Stuart Marks at Devoxx Belgium 2018. This second part covers the Stream API, reduction and the Collector API.
What is the state of lambda expressions in Java 11? Lambda expressions are the major feature of Java 8, having an impact on most of the API, including the Streams and Collections API. We are now living the Java 11 days; new features have been added and new patterns have emerged. This highly technical Deep Dive session will visit all these patterns, the well-known ones and the new ones, in an interactive hybrid of lecture and laboratory. We present a technique and show how it helps solve a problem. We then present another problem, and give you some time to solve it yourself. Finally, we present a solution, and open for questions, comments, and discussion. Bring your laptop set up with JDK 11 and your favorite IDE, and be prepared to think!
Lambda and Stream Master class - part 1José Paumard
These are the slides of the talk we made with Stuart Marks at Devoxx Belgium 2018. This first part covers Lambda Expressions and API design with functional interfaces.
What is the state of lambda expressions in Java 11? Lambda expressions are the major feature of Java 8, having an impact on most of the API, including the Streams and Collections API. We are now living the Java 11 days; new features have been added and new patterns have emerged. This highly technical Deep Dive session will visit all these patterns, the well-known ones and the new ones, in an interactive hybrid of lecture and laboratory. We present a technique and show how it helps solve a problem. We then present another problem, and give you some time to solve it yourself. Finally, we present a solution, and open for questions, comments, and discussion. Bring your laptop set up with JDK 11 and your favorite IDE, and be prepared to think!
Slides of the talk we gave with David Delabassee at Oracle Code One 2018.
The FnProject was released about a year ago, proposing new ways to design asynchronous systems in a very flexible way. This tutorial shows you how to set up a Fn Server on a local development machine running Windows with a first simple function. Then we cover the design of multi-functions systems, connected together in an asynchronous way, leveraging the Fn Flow API. This API is first presented, including how it compares to the the Java 8 CompletableFuture API. We then set up a real example made of several functions, producing multiple results and see how we can leverage their asynchronous nature to make a non-blocking system, handling errors in a simple and intuitive way. Most of the examples are shown both on slides and live coding parts.
Avec la version 9 sortie en septembre 2017, Java appuie sur la pédale ! Le rythme des livraisons passe à une version majeure tous les 6 mois. Java 10 est sorti en mars, prochaine version en septembre. Java 10 apporte le 'var' et l'inférence de type pour les variables locales. D'autres nouveautés sont en préparation : les constantes dynamiques, les classes de données, un nouveau switch à base de lambda, des interfaces fermées, de nouvelles choses du coté des génériques et bien plus encore.
Cela viendra-t-il en 11, 12, 15 ? Ne spéculons pas, mais quand ces nouveautés seront prêtes, elles sortiront en quelques mois. On se propose de présenter ces nouveautés, celles qui sont presque prêtes, celles qui seront prêtes bientôt, et celles qui ne seront pas prêtes avant un moment. Quels seront les impacts sur le langage, sur la JVM et donc sur les performances ? Que cela va-t-il nous apporter au quotidien, en tant que développeurs ? Quels seront les nouveaux patterns ? Voici le programme de cette présentation, avec des slides, du code, de la joie et de la bonne humeur !
JAX-RS and CDI Bike the (Reactive) BridgeJosé Paumard
This session explains how JAX-RS and CDI became reactive capable in Java EE 8. We put some new features of JAX-RS 2.1 and CDI 2.0 into perspective and show some reactive patterns to improve your application. Add Java 8 CompletionStage to the mix and this API trio becomes your best bet to easily go reactive without leaving the Java EE train.
The slides of my talk at Devoxx BE 2017. This in depth talk is all about collectors: those available, because we need to know them, those that we can create, those we had no idea they could be created, and the others, as there is in fact no limit to what can be done with this API. The concept of downstream collector will be used to show how we can write entire data processing pipelines using collectors only, and pass them as parameters to other pipelines.
The slides of my Java One 2017 talk about the Spliterator Patterns, or, how to extend the Stream API using the Spliterator API.
The video is available on YouTube: https://www.youtube.com/watch?v=xgHGpsubL5M
The slides of my JavaOne 2017 talk. It describes how you can create API using functional interfaces, default and static methods starting with Java 8. You can watch the video here: https://www.youtube.com/watch?v=64UO1YjVcZ0
Les slides de ma présentation à Devoxx France 2017.
Introduite en Java 8, l'API Collector vit dans l'ombre de l'API Stream, ce qui est logique puisqu'un collecteur doit se connecter à un stream pour fonctionner. Le JDK est organisé de sorte que l'on utilise surtout les collectors sur étagère : groupingBy, counting et quelques autres. Ces deux éléments masquent non seulement le modèle de traitement de données des collectors, mais aussi sa puissance et ses performances.
Ces présentation parle des collectors qui existent et qu'il faut connaître, ceux que l'on peut créer, ceux dont on se doute que l'on peut les créer une fois que l'on comprend un peu les choses, et les autres, tant les possibilités offertes par cette API sont illimitées.
Operation “Blue Star” is the only event in the history of Independent India where the state went into war with its own people. Even after about 40 years it is not clear if it was culmination of states anger over people of the region, a political game of power or start of dictatorial chapter in the democratic setup.
The people of Punjab felt alienated from main stream due to denial of their just demands during a long democratic struggle since independence. As it happen all over the word, it led to militant struggle with great loss of lives of military, police and civilian personnel. Killing of Indira Gandhi and massacre of innocent Sikhs in Delhi and other India cities was also associated with this movement.
Instructions for Submissions thorugh G- Classroom.pptxJheel Barad
This presentation provides a briefing on how to upload submissions and documents in Google Classroom. It was prepared as part of an orientation for new Sainik School in-service teacher trainees. As a training officer, my goal is to ensure that you are comfortable and proficient with this essential tool for managing assignments and fostering student engagement.
Welcome to TechSoup New Member Orientation and Q&A (May 2024).pdfTechSoup
In this webinar you will learn how your organization can access TechSoup's wide variety of product discount and donation programs. From hardware to software, we'll give you a tour of the tools available to help your nonprofit with productivity, collaboration, financial management, donor tracking, security, and more.
The French Revolution, which began in 1789, was a period of radical social and political upheaval in France. It marked the decline of absolute monarchies, the rise of secular and democratic republics, and the eventual rise of Napoleon Bonaparte. This revolutionary period is crucial in understanding the transition from feudalism to modernity in Europe.
For more information, visit-www.vavaclasses.com
Unit 8 - Information and Communication Technology (Paper I).pdfThiyagu K
This slides describes the basic concepts of ICT, basics of Email, Emerging Technology and Digital Initiatives in Education. This presentations aligns with the UGC Paper I syllabus.
The Roman Empire A Historical Colossus.pdfkaushalkr1407
The Roman Empire, a vast and enduring power, stands as one of history's most remarkable civilizations, leaving an indelible imprint on the world. It emerged from the Roman Republic, transitioning into an imperial powerhouse under the leadership of Augustus Caesar in 27 BCE. This transformation marked the beginning of an era defined by unprecedented territorial expansion, architectural marvels, and profound cultural influence.
The empire's roots lie in the city of Rome, founded, according to legend, by Romulus in 753 BCE. Over centuries, Rome evolved from a small settlement to a formidable republic, characterized by a complex political system with elected officials and checks on power. However, internal strife, class conflicts, and military ambitions paved the way for the end of the Republic. Julius Caesar’s dictatorship and subsequent assassination in 44 BCE created a power vacuum, leading to a civil war. Octavian, later Augustus, emerged victorious, heralding the Roman Empire’s birth.
Under Augustus, the empire experienced the Pax Romana, a 200-year period of relative peace and stability. Augustus reformed the military, established efficient administrative systems, and initiated grand construction projects. The empire's borders expanded, encompassing territories from Britain to Egypt and from Spain to the Euphrates. Roman legions, renowned for their discipline and engineering prowess, secured and maintained these vast territories, building roads, fortifications, and cities that facilitated control and integration.
The Roman Empire’s society was hierarchical, with a rigid class system. At the top were the patricians, wealthy elites who held significant political power. Below them were the plebeians, free citizens with limited political influence, and the vast numbers of slaves who formed the backbone of the economy. The family unit was central, governed by the paterfamilias, the male head who held absolute authority.
Culturally, the Romans were eclectic, absorbing and adapting elements from the civilizations they encountered, particularly the Greeks. Roman art, literature, and philosophy reflected this synthesis, creating a rich cultural tapestry. Latin, the Roman language, became the lingua franca of the Western world, influencing numerous modern languages.
Roman architecture and engineering achievements were monumental. They perfected the arch, vault, and dome, constructing enduring structures like the Colosseum, Pantheon, and aqueducts. These engineering marvels not only showcased Roman ingenuity but also served practical purposes, from public entertainment to water supply.
A Strategic Approach: GenAI in EducationPeter Windle
Artificial Intelligence (AI) technologies such as Generative AI, Image Generators and Large Language Models have had a dramatic impact on teaching, learning and assessment over the past 18 months. The most immediate threat AI posed was to Academic Integrity with Higher Education Institutes (HEIs) focusing their efforts on combating the use of GenAI in assessment. Guidelines were developed for staff and students, policies put in place too. Innovative educators have forged paths in the use of Generative AI for teaching, learning and assessments leading to pockets of transformation springing up across HEIs, often with little or no top-down guidance, support or direction.
This Gasta posits a strategic approach to integrating AI into HEIs to prepare staff, students and the curriculum for an evolving world and workplace. We will highlight the advantages of working with these technologies beyond the realm of teaching, learning and assessment by considering prompt engineering skills, industry impact, curriculum changes, and the need for staff upskilling. In contrast, not engaging strategically with Generative AI poses risks, including falling behind peers, missed opportunities and failing to ensure our graduates remain employable. The rapid evolution of AI technologies necessitates a proactive and strategic approach if we are to remain relevant.
Model Attribute Check Company Auto PropertyCeline George
In Odoo, the multi-company feature allows you to manage multiple companies within a single Odoo database instance. Each company can have its own configurations while still sharing common resources such as products, customers, and suppliers.
11. @JosePaumard#Devoxx #J8Async
Difference with the synchronous multithreaded model?
1) The async engine decides to switch from one context to
another
2) Single threaded = no issue with atomicity or visibility
Performances?
No multithreaded « context switch »
Asynchronous
14. @JosePaumard#Devoxx #J8Async
Pattern
Callback or task: lambda expression
When the result is available, then we can continue with the
next task
Asynchronous
queryEngine.select("select user from User")
.forEach(user -> System.out.prinln(user)) ;
15. @JosePaumard#Devoxx #J8Async
Pattern
Callback or task: lambda expression
When the result is available, then we can continue with the
next task
Now how can we write that in Java?
Asynchronous
queryEngine.select("select user from User")
.forEach(user -> System.out.prinln(user)) ;
16. @JosePaumard#Devoxx #J8Async
A task in Java
Since Java 1: Runnable
Since Java 5: Callable
In Java 5 we have the ExecutorService (pool of threads)
We give a task and get back a Future
17. @JosePaumard#Devoxx #J8Async
A task in Java
Pattern
Callable<String> task = () -> "select user from User" ;
Future<String> future = executorService.submit(task) ;
18. @JosePaumard#Devoxx #J8Async
A task in Java
Pattern
Callable<String> task = () -> "select user from User" ;
Future<String> future = executorService.submit(task) ;
List<User> users = future.get() ; // blocking
users.forEach(System.out::println) ;
19. @JosePaumard#Devoxx #J8Async
A task in Java
Pattern
Passing an object from one task to another has to be handled
in the « master » thread
Callable<String> task = () -> "select user from User" ;
Future<String> future = executorService.submit(task) ;
List<User> users = future.get() ; // blocking
users.forEach(System.out::println) ;
25. @JosePaumard#Devoxx #J8Async
Creation of an asynchronous task
The Jersey way to create an asynchronous call
@Path("/resource")
public class AsyncResource {
@GET
public void asyncGet(@Suspended final AsyncResponse asyncResponse) {
new Thread(new Runnable() {
public void run() {
String result = longOperation();
asyncResponse.resume(result);
}
}).start();
}
}
26. @JosePaumard#Devoxx #J8Async
Creation of an asynchronous task
(let us fix this code, this is Java 8)
@Path("/resource")
public class AsyncResource {
@Inject private Executor executor;
@GET
public void asyncGet(@Suspended final AsyncResponse asyncResponse) {
executor.execute(() -> {
String result = longOperation();
asyncResponse.resume(result);
});
}
}
27. @JosePaumard#Devoxx #J8Async
How to test it?
The question is: how can we test that code?
We want to check if the result object
is passed to the resume() method of the asyncResponse
28. @JosePaumard#Devoxx #J8Async
How to test it?
We have mocks for that!
It is a very basic test, but tricky to write since we are in an
asynchronous world
29. @JosePaumard#Devoxx #J8Async
How to test it?
Let us give one more look at the code
@Path("/resource")
public class AsyncResource {
@GET
public void asyncGet(@Suspended final AsyncResponse asyncResponse) {
executor.execute(() -> { // executed in the main thread
String result = longOperation(); // executed in another thread
asyncResponse.resume(result);
});
}
}
30. @JosePaumard#Devoxx #J8Async
How to test it?
We have mocks to check if resume() is properly called with
result
It is a very basic test, but tricky to write since we are in an
asynchronous world
31. @JosePaumard#Devoxx #J8Async
How to test it?
We can inject a mock AsyncResponse, even mock the result
@Path("/resource")
public class AsyncResource {
@GET
public void asyncGet(@Suspended final AsyncResponse asyncResponse) {
executor.execute(() -> {
String result = longOperation();
asyncResponse.resume(result);
});
}
}
32. @JosePaumard#Devoxx #J8Async
How to test it?
We can inject a mock AsyncResponse, even mock the result
Then verify the correct interaction:
But:
- we need to verify this once the run() method has been
called
Mockito.verify(mockAsyncResponse).resume(result);
33. @JosePaumard#Devoxx #J8Async
How to test it?
We can inject a mock AsyncResponse, even mock the result
Then verify the correct interaction:
But:
- we need to verify this once the run() method has been
called
- and take into account the multithreaded aspect… the read /
writes on the mock should be « visible »!
Mockito.verify(mockAsyncResponse).resume(result);
34. @JosePaumard#Devoxx #J8Async
How to test it?
So our constraints are the following:
- we need to verify this once the run() method has been
called
- we need to read / write on our mocks in the same thread as
the one which runs the task we want to test
35. @JosePaumard#Devoxx #J8Async
How to test it?
This is where CompletionStage comes to the rescue!
@Path("/resource")
public class AsyncResource {
@Inject ExecutorService executor;
@GET
public void asyncGet(@Suspended final AsyncResponse asyncResponse) {
executor.submit(() -> {
String result = longOperation();
asyncResponse.resume(result);
});
}
}
36. @JosePaumard#Devoxx #J8Async
How to test it?
This pattern:
executor.submit(() -> {
String result = longOperation();
asyncResponse.resume(result);
});
37. @JosePaumard#Devoxx #J8Async
How to test it?
This pattern:
Becomes this one:
And does basically the same thing
executor.submit(() -> {
String result = longOperation();
asyncResponse.resume(result);
});
CompletableFuture.runAsync(() -> {
String result = longOperation();
asyncResponse.resume(result);
}, executor);
38. @JosePaumard#Devoxx #J8Async
How to test it?
But the nice thing is:
CompletableFuture<Void> completableFuture =
CompletableFuture.runAsync(() -> {
String result = longOperation();
asyncResponse.resume(result);
}, executor);
39. @JosePaumard#Devoxx #J8Async
How to test it?
But the nice thing is:
And on this object we can call:
CompletableFuture<Void> completableFuture =
CompletableFuture.runAsync(() -> {
String result = longOperation();
asyncResponse.resume(result);
}, executor);
completableFuture
.thenRun(() -> {
Mockito.verify(mockAsyncResponse).resume(result);
}
);
40. @JosePaumard#Devoxx #J8Async
How to test it?
Be careful of visibility issues
1) It’s simpler to run everything in the same thread
2) Create, train and check our mocks in this thread
41. @JosePaumard#Devoxx #J8Async
CompletionStage / CompletableFuture
Two elements in this API:
- an interface: CompletionStage
- an implementing class: CompletableFuture
The interface depends on CompletableFuture:
public CompletableFuture<T> toCompletableFuture();
42. @JosePaumard#Devoxx #J8Async
What is a CompletionStage?
A model for a task:
- that performs an action an may return a value when another
completion stage completes
- that may trigger other tasks
So a completion stage is an element of a chain
44. @JosePaumard#Devoxx #J8Async
What is a CompletableFuture?
A class that implements both Future and CompletionStage
It has a state:
- the task may be running
- the task may have complete normally
- the task may have complete exceptionnaly
47. @JosePaumard#Devoxx #J8Async
Methods from Future
Five methods:
boolean cancel(boolean mayInterruptIfRunning) ;
boolean isCanceled() ;
boolean isDone() ;
V get() ; // blocking call
V get(long timeout, TimeUnit timeUnit) ; // may throw a checked exception
throws InterruptedException, ExecutionException, TimeoutException ;
48. @JosePaumard#Devoxx #J8Async
More from CompletableFuture
Future-like methods:
V join() ; // may throw an unchecked exception
V getNow(V valueIfAbsent) ; // returns immediately
49. @JosePaumard#Devoxx #J8Async
More from CompletableFuture
Future-like methods:
V join() ; // may throw an unchecked exception
V getNow(V valueIfAbsent) ; // returns immediately
boolean complete(V value) ; // sets the returned value is not returned
void obtrudeValue(V value) ; // resets the returned value
50. @JosePaumard#Devoxx #J8Async
More from CompletableFuture
Future-like methods:
V join() ; // may throw an unchecked exception
V getNow(V valueIfAbsent) ; // returns immediately
boolean complete(V value) ; // sets the returned value is not returned
void obtrudeValue(V value) ; // resets the returned value
boolean completeExceptionnaly(Throwable t) ; // sets an exception
void obtrudeException(Throwable t) ; // resets with an exception
51. @JosePaumard#Devoxx #J8Async
How to create a CompletableFuture?
A completed CompletableFuture
public static <U> CompletableFuture<U> completedFuture(U value) ;
52. @JosePaumard#Devoxx #J8Async
How to create a CompletableFuture?
A CompletableFuture from a Runnable or a Supplier
public static CompletableFuture<Void>
runAsync(Runnable runnable, Executor executor) ;
public static <U> CompletableFuture<U>
supplyAsync(Supplier<U> value, Executor executor) ;
53. @JosePaumard#Devoxx #J8Async
Building CompletionStage chains
A CompletionStage is a step in a chain
- it can be triggered by a previous CompletionStage
- it can trigger another CompletionStage
- it can be executed in a given Executor
55. @JosePaumard#Devoxx #J8Async
Building CompletionStage chains
What kind of operation does it support?
- chaining (1 – 1)
- composing (1 – 1)
- combining, waiting for both result (2 – 1)
- combining, triggered on the first available result (2 – 1)
56. @JosePaumard#Devoxx #J8Async
Building CompletionStage chains
What kind of operation does it support?
- chaining (1 – 1)
- composing (1 – 1)
- combining, waiting for both result (2 – 1)
- combining, triggered on the first available result (2 – 1)
All this gives… 36 methods!
57. @JosePaumard#Devoxx #J8Async
Building CompletionStage chains
In what thread can it be executed?
- In the same executor as the caller
- In a new executor, passed as a parameter
- Asynchronously, ie in the common fork join pool
All this gives… 36 methods!
59. @JosePaumard#Devoxx #J8Async
CompletionStage – patterns
Some 1 – 1 patterns
public <U> CompletionStage<U>
thenApply(Function<? super T,? extends U> fn);
public CompletionStage<Void>
thenRunAsync(Runnable action, Executor executor);
60. @JosePaumard#Devoxx #J8Async
CompletionStage – patterns
Some 1 – 1 patterns
public <U> CompletionStage<U>
thenApply(Function<? super T,? extends U> fn);
public CompletionStage<Void>
thenRunAsync(Runnable action, Executor executor);
public CompletionStage<Void>
thenComposeAsync(
Function<? super T, ? extends CompletionStage<U>> fn);
61. @JosePaumard#Devoxx #J8Async
CompletionStage – patterns
Some 2 – 1 patterns
public <U, V> CompletionStage<V> thenCombineAsync
(CompletionStage<U> other,
BiFunction<T, U, V> function) ;
62. @JosePaumard#Devoxx #J8Async
CompletionStage – patterns
Some 2 – 1 patterns
public <U, V> CompletionStage<V> thenCombineAsync
(CompletionStage<U> other,
BiFunction<T, U, V> function) ;
public <U> CompletionStage<Void> thenAcceptBoth
(CompletionStage<U> other,
BiConsumer<T, U> action) ;
63. @JosePaumard#Devoxx #J8Async
CompletionStage – patterns
Some 2 – 1 patterns
public <U, V> CompletionStage<V> thenCombineAsync
(CompletionStage<U> other,
BiFunction<T, U, V> function) ;
public <U> CompletionStage<Void> thenAcceptBoth
(CompletionStage<U> other,
BiConsumer<T, U> action) ;
public CompletionStage<Void> runAfterBothAsync
(CompletionStage<?> other,
Runnable action, Executor executor) ;
64. @JosePaumard#Devoxx #J8Async
CompletionStage – patterns
Some more 2 – 1 patterns
public <U> CompletionStage<U> applyToEither
(CompletionStage<? extends T> other,
Function<T, U> function) ;
65. @JosePaumard#Devoxx #J8Async
CompletionStage – patterns
Some more 2 – 1 patterns
public <U> CompletionStage<U> applyToEither
(CompletionStage<? extends T> other,
Function<T, U> function) ;
public CompletionStage<Void> acceptEitherAsync
(CompletionStage<? extends T> other,
Consumer<? extends T> consumer) ;
66. @JosePaumard#Devoxx #J8Async
CompletionStage – patterns
Some more 2 – 1 patterns
public <U> CompletionStage<U> applyToEither
(CompletionStage<? extends T> other,
Function<T, U> function) ;
public CompletionStage<Void> acceptEitherAsync
(CompletionStage<? extends T> other,
Consumer<? extends T> consumer) ;
public CompletionStage<Void> runAfterEitherAsync
(CompletionStage<U> other,
Runnable action, Executor executor) ;
67. @JosePaumard#Devoxx #J8Async
Back to our first example
So the complete pattern becomes this one
1) First we create our mocks
String result = Mockito.mock(String.class);
AsyncResponse response = Mockito.mock(AsyncResponse.class);
Runnable train = () -> Mockito.doReturn(result).when(response).longOperation();
Runnable verify = () -> Mockito.verify(response).resume(result);
68. @JosePaumard#Devoxx #J8Async
Back to our first example
So the complete pattern becomes this one
2) Then we create the call & verify
Runnable callAndVerify = () -> {
asyncResource.executeAsync(response).thenRun(verify);
}
69. @JosePaumard#Devoxx #J8Async
Back to our first example
So the complete pattern becomes this one
3) Then we create the task
ExecutorService executor = Executors.newSingleThreadExecutor();
AsyncResource asyncResource = new AsyncResource();
asyncResource.setExecutorService(executor);
CompletableFuture
.runAsync(train, executor) // this trains our mocks
.thenRun(callAndVerify); // this verifies our mocks
70. @JosePaumard#Devoxx #J8Async
Back to our first example
Since a CompletableFuture is also a Future, we can fail with
a timeout if the test does not complete fast enough
ExecutorService executor = Executors.newSingleThreadExecutor();
AsyncResource asyncResource = new AsyncResource();
asyncResource.setExecutorService(executor);
CompletableFuture
.runAsync(train, executor) // this trains our mocks
.thenRun(callAndVerify) // this verifies our mocks
.get(10, TimeUnit.SECONDS);
72. @JosePaumard#Devoxx #J8Async
A second example
Async analysis of a web page
CompletableFuture.supplyAsync(
() -> readPage("http://whatever.com/")
)
.thenApply(page -> linkParser.getLinks(page))
73. @JosePaumard#Devoxx #J8Async
A second example
Async analysis of a web page
CompletableFuture.supplyAsync(
() -> readPage("http://whatever.com/")
)
.thenApply(page -> linkParser.getLinks(page))
.thenAccept(
links -> displayPanel.display(links) // in the right thread!
) ;
74. @JosePaumard#Devoxx #J8Async
A second example
Async analysis of a web page
CompletableFuture.supplyAsync(
() -> readPage("http://whatever.com/")
)
.thenApply(page -> linkParser.getLinks(page))
.thenAcceptAsync(
links -> displayPanel.display(links),
executor
) ;
76. @JosePaumard#Devoxx #J8Async
A second example
Async analysis of a web page
public interface Executor {
void execute(Runnable command);
}
Executor executor = runnable -> SwingUtilities.invokeLater(runnable) ;
77. @JosePaumard#Devoxx #J8Async
A second example
Async analysis of a web page
CompletableFuture.supplyAsync(
() -> readPage("http://whatever.com/")
)
.thenApply(page -> linkParser.getLinks(page))
.thenAcceptAsync(
links -> displayPanel.display(links),
runnable -> SwingUtilities.invokeLater(runnable)
) ;
78. @JosePaumard#Devoxx #J8Async
A second example
Async analysis of a web page
CompletableFuture.supplyAsync(
() -> readPage("http://whatever.com/")
)
.thenApply(Parser::getLinks)
.thenAcceptAsync(
DisplayPanel::display,
SwingUtilities::invokeLater
) ;
79. @JosePaumard#Devoxx #J8Async
A last example
Async events in CDI
@Inject
Event<String> event ;
event.fire("some event") ; // returns void
public void observes(@Observes String payload) {
// handle the event, called in the firing thread
}
80. @JosePaumard#Devoxx #J8Async
A last example
Async events in CDI
public void observes(@Observes String payload) {
// handle the event, called in the firing thread
CompletableFuture.anyOf(/* some task */) ;
}
81. @JosePaumard#Devoxx #J8Async
A last example
Async events in CDI
@Inject
Event<String> event ;
event.fireAsync("some event") ; // returns CompletionStage<Object>
public void observes(@ObservesAsync String payload) {
// handle the event in another thread
}
82. @JosePaumard#Devoxx #J8Async
A last example
Async events in CDI
@Inject
Event<String> event ;
Executor executor = SwingUtilities::invokeLater
event.fireAsync("some event", executor) ;
83. @JosePaumard#Devoxx #J8Async
A last example
Async events in CDI
@Inject
Event<String> event ;
Executor executor = SwingUtilities::invokeLater
CompletionStage<Object> cs =
event.fireAsync("some event", executor) ;
cs.whenComplete(...); // handle the exceptions
84. @JosePaumard#Devoxx #J8Async
CompletionStage – last patterns
Static methods
public static CompletableFuture<Void>
allOf(CompletableFuture<?>... cfs) ;
public static CompletableFuture<Object>
anyOf(CompletableFuture<?>... cfs) ;
91. @JosePaumard#Devoxx #J8Async
Exception handling
Which means that:
- the call to isCompletedExceptionnaly() returns true
- the call to get() throws an ExecutionException which cause
is the root Exception
CompletableFuture can handle exceptions
95. @JosePaumard#Devoxx #J8Async
Exception handling
Suppose CF30 has been created with exceptionnaly()
If CF21 completes normally, then CF30 just transmits the value
If it raises an exception, then CF30 handles it and generate a
value for CF31
CF1 CF21
CF22
CF31
CF32
CF41
exceptionnaly()
CF30
97. @JosePaumard#Devoxx #J8Async
Exception handling
There are three methods to handle an exception
handle() has also asynchronous versions
CompletionStage<T> exceptionally(
Function<Throwable, ? extends T> function);
<U> CompletionStage<U> handle(
BiFunction<? super T, Throwable, ? extends U> bifunction);
98. @JosePaumard#Devoxx #J8Async
Exception handling
There are three methods to handle an exception
whenComplete() has also asynchronous versions
CompletionStage<T> exceptionally(
Function<Throwable, ? extends T> function);
<U> CompletionStage<U> handle(
BiFunction<? super T, Throwable, ? extends U> bifunction);
CompletionStage<T> whenComplete(
BiConsumer<? super T, Throwable> action);
99. @JosePaumard#Devoxx #J8Async
A very last example
CompletableFuture<String> closing = new CompletableFuture<String>() ;
Stream<String> manyStrings = Stream.of("one", "two", "three") ;
100. @JosePaumard#Devoxx #J8Async
A very last example
CompletableFuture<String> closing = new CompletableFuture<String>() ;
Stream<String> manyStrings = Stream.of("one", "two", "three") ;
manyStrings
.onClose(() -> { closing.complete(""); })
101. @JosePaumard#Devoxx #J8Async
A very last example
CompletableFuture<String> closing = new CompletableFuture<String>() ;
Stream<String> manyStrings = Stream.of("one", "two", "three") ;
manyStrings
.onClose(() -> { closing.complete(""); })
.map(CompletableFuture::completedFuture)
102. @JosePaumard#Devoxx #J8Async
A very last example
CompletableFuture<String> closing = new CompletableFuture<String>() ;
Stream<String> manyStrings = Stream.of("one", "two", "three") ;
manyStrings
.onClose(() -> { closing.complete(""); })
.map(CompletableFuture::completedFuture)
.filter(cf -> cf.get().length() < 20)
103. @JosePaumard#Devoxx #J8Async
A very last example
CompletableFuture<String> closing = new CompletableFuture<String>() ;
Stream<String> manyStrings = Stream.of("one", "two", "three") ;
manyStrings
.onClose(() -> { closing.complete(""); })
.map(CompletableFuture::completedFuture)
.filter(cf -> cf.get().length() < 20)
.reduce(
closing,
(cf1, cf2) -> cf1.thenCombine(cf2, binaryOperator) // concatenation
);
104. @JosePaumard#Devoxx #J8Async
A very last example
CompletableFuture<String> closing = new CompletableFuture<String>() ;
Stream<String> manyStrings = Stream.of("one", "two", "three") ;
CompletableFuture<String> reduce =
manyStrings
.onClose(() -> { closing.complete(""); })
.map(CompletableFuture::completedFuture)
.filter(cf -> cf.get().length() < 20)
.reduce(
closing,
(cf1, cf2) -> cf1.thenCombine(cf2, binaryOperator) // concatenation
);
105. @JosePaumard#Devoxx #J8Async
A very last example
CompletableFuture<String> closing = new CompletableFuture<String>() ;
Stream<String> manyStrings = Stream.of("one", "two", "three") ;
CompletableFuture<String> reduce =
manyStrings
.onClose(() -> { closing.complete(""); })
.map(CompletableFuture::completedFuture)
.filter(cf -> cf.get().length() < 20)
.reduce(
closing,
(cf1, cf2) -> cf1.thenCombine(cf2, binaryOperator) // concatenation
);
manyStrings.close();
106. @JosePaumard#Devoxx #J8Async
A very last example
CompletableFuture<String> closing = new CompletableFuture<String>() ;
Stream<String> manyStrings = Stream.of("one", "two", "three") ;
CompletableFuture<String> reduce =
manyStrings
.onClose(() -> { closing.complete(""); })
.map(CompletableFuture::completedFuture)
.filter(cf -> cf.get().length() < 20)
.reduce(
closing,
(cf1, cf2) -> cf1.thenCombine(cf2, binaryOperator) // concatenation
);
manyStrings.close();
107. @JosePaumard#Devoxx #J8Async
A very last example
CompletableFuture<String> closing = new CompletableFuture<String>() ;
Stream<String> manyStrings = Stream.of("one", "two", "three") ;
CompletableFuture<String> reduce =
manyStrings.parallel()
.onClose(() -> { closing.complete(""); })
.map(CompletableFuture::completedFuture)
.filter(cf -> cf.get().length() < 20)
.reduce(
closing,
(cf1, cf2) -> cf1.thenCombine(cf2, binaryOperator) // concatenation
);
manyStrings.close();
113. @JosePaumard#Devoxx #J8Async
Conclusion
We have an API for async computations in the JDK!
Very rich, many methods which makes it complex
Built on lambdas
Gives a fine control over threads
114. @JosePaumard#Devoxx #J8Async
Conclusion
We have an API for async computations in the JDK!
Very rich, many methods which makes it complex
Built on lambdas
Gives a fine control over threads
Handle chaining, composition
115. @JosePaumard#Devoxx #J8Async
Conclusion
We have an API for async computations in the JDK!
Very rich, many methods which makes it complex
Built on lambdas
Gives a fine control over threads
Handle chaining, composition
Very clean way of handling exceptions