Asynchronous Programming. Talk from ESUG2024

Talk from ESUG 2024

"Asynchronous Programming"

PDF: http://archive.esug.org/ESUG2024/day2/07-foster-asynchronous.pdf

1. Asynchronous Programming
ESUG 2024, Lille, France
James Foster

2. Agenda
uAsynchronous Programming and Synchronization
uExploring Other Languages
uExploring Smalltalk Implementations
uObservations
uQuestions

3. Asynchronous Programming and
Synchronization
Futures and Promises

4. Synchronous: Blocking
uBlocking & Sequential

5. Asynchronous:
Nonblocking and Parallel
uBlocking & SequentialuNonblocking & Parallel
Fork

6. Asynchronous:
Nonblocking and Concurrent
uBlocking & SequentialuNonblocking & Parallel
Fork
uNonblocking & Concurrent
Fork

7. Synchronization
uCoordinating multiple processes to join up.
Fork
Join

8. Web Server

9. Asynchronous Programming in GemStone
uDemo of WebGS with parallel sessions

10. Futures and Promises
u"Incomputer science,future,promise,delay,
anddeferredrefer to constructs used forsynchronizing
programexecutionin someconcurrent programming
languages. They describe an object that acts as a proxy
for a result that is initially unknown, usually because
thecomputationof its value is not yet complete."
u— https://en.wikipedia.org/wiki/Futures_and_promises

11. Exploring Other Languages
Futures and Promises

12. JavaScript: Promises
uA Promise is in one of these states:
uPending: Initial state, neither fulfilled nor rejected.
uFulfilled: The operation completed successfully.
uRejected: The operation failed.

13. JavaScript: Example
letpromise= newPromise(function(resolve, reject) {
// Asynchronous operation here
if(/* operation successful */) {
resolve(value); // Resolve with a value
} else{
reject(error); // Reject with an error
}
});
promise.then(
function(value) { /* handle a successful operation */},
function(error) { /* handle an error */}
);

14. JavaScript: Summary
•Creating a Promise: ThePromiseconstructor is used to create a promise. It
takes a function (executor) that should start an asynchronous operation and
eventually call either theresolve(to indicate success) orreject(to indicate
failure) function to settle the promise.
•Consuming a Promise: The.then()method is used to attach callbacks to
handle the fulfillment or rejection of the promise. The.catch()method is used
to handle rejection, and.finally()method allows you to execute logic
regardless of the promise's outcome.
•Chaining Promises: Promises can be chained to perform a series of
asynchronous operations in sequence. Each.then()returns a new promise,
allowing for further methods to be called in sequence.

15. JavaScript: Conclusion
uPromises are a core part of asynchronous programming in
JavaScript, making it easier to work with asynchronous
operations by avoiding the complexity of nested callbacks,
known as "callback hell."

16. Python: ThreadPoolExecutor
fromconcurrent.futuresimportThreadPoolExecutor, as_completed
deftask(n):
returnn+ 1
# Create a ThreadPoolExecutor
withThreadPoolExecutor(max_workers=5) asexecutor:
# Submit tasks to the executor
futures= [executor.submit(task, i) foriinrange(5)]
# Wait for the futures to complete and get their results
forfutureinas_completed(futures):
print(future.result())

17. Python: asyncio.Future
importasyncio
asyncdefset_after(fut, delay, value):
# Wait
awaitasyncio.sleep(delay)
# Set the result
fut.set_result(value)
asyncdefmain():
# Create a Future object
fut= asyncio.Future()
# Schedule the future
awaitset_after(fut, 1, 'hello!')
# Wait for the future
print(awaitfut)
asyncio.run(main())

18. Java: CompletableFuture

19. importjava.util.concurrent.CompletableFuture;
importjava.util.concurrent.ExecutionException;
publicclassCompletableFutureExample{
publicstaticvoidmain(String[] args) throwsExecutionException, InterruptedException{
// Create a CompletableFuture
CompletableFuture<String> future= CompletableFuture.supplyAsync(() ->{
try{
// Simulate a long-running job
Thread.sleep(1000);
} catch(InterruptedExceptione) {
Thread.currentThread().interrupt();
}
return"Hello";
});
// Chain a computation stage
CompletableFuture<String> greetingFuture=
future.thenApply(result ->result + ", World!");
// Block and get the result
System.out.println(greetingFuture.get()); // Prints "Hello, World!" after 1 second
}
}

20. Dart: async and await
uA long running method is (should be!) annotated with async.
uAn async method returns a Future.
uA callback may be added to a Future to handle:
uA normal result; or,
uAn error.
uInstead of adding a callback, you can await for a Future to complete.
uThis will block, so should not be done in the primary (UI) thread.
uIn background threads this allows synchronous (linear) code.

21. import'dart:async';
Future<String> fetchUserOrder() async {
// Simulate a network request to fetch a user order
awaitFuture.delayed(Duration(seconds: 2));
return'Cappuccino';
}
voidmain() async{
print('Fetching user order...');
try{
// Wait for the Future to complete and extract its result
Stringorder = awaitfetchUserOrder();
print('Your order is: $order');
} catch(err) {
print('Failed to fetch user order: $err');
}
}

22. Exploring Smalltalk Implementations
Not exhaustive!

23. VAST Platform
uModeled on Dart
uDemo

24. Pharo
uSemaphore approach
uTaskIt package
uDemo

25. Glamorous Toolkit
uDocumentation

26. Observations
uApplication developers
uAvoid long-running (blocking) tasks in the UI thread.
uFutures/Promises simplify the handling of asynchronous tasks.
uLibrary developers
uUse Futures/Promises for long-running operations (disk, network, etc.)
uForce application developers to use Futures!

27. Questions?
[email protected]
uVP of Finance and Operations, GemTalk Systems LLC
[email protected]
uAssociate Professor of Computer Science, Walla Walla University