Forem: Ahmed_Greynoon

Getting Started with Asynchronous Programming in Dart

Ahmed_Greynoon — Sat, 07 Sep 2024 19:59:53 +0000

Last article, we've covered the foundational concepts of the asynchronous programming model, and we learn that synchronous programming in Dart is a powerful way to keep your applications responsive, especially when dealing with tasks like I/O operations, network requests, or heavy computations that could otherwise block the main thread.

Now it's time to dive into how to implement asynchronous code in Dart.

Why does asynchronous code matter?

Asynchronous operations let your program complete work while waiting for another operation to finish. Here are some common asynchronous operations:

Fetching data over a network.
Writing to a database.
Reading data from a file.

Such asynchronous computations usually provide their result as a Future, and to interact with these asynchronous results you can just use callback, or the async and await keywords. These allow you to write code that performs non-blocking operations, ensuring that your application remains responsive and efficient, even when handling time-consuming tasks.

Don't worry, you will understand that now.

Future

A future is an object that represents the result of an asynchronous operation, which will return a value at a later time. They can be thought of as a promise that there will be a value or an error at some point.

The future has two states:

Completed.
Uncompleted.

When asynchronous operation is completed, it will return a value if it is successful or it will return an error in the future. But for the uncompleted future, it will eventually return as long as the asynchronous operation is still in progress.

Example of a Future:

String createOrderMessage() {
  var order = fetchUserOrder();
  return 'Your order is: $order';
}

Future<String> fetchUserOrder() {
  return Future.delayed(
    const Duration(seconds: 2),
    () => 'Large Latte',
  );
}

void main() {
  print(createOrderMessage());
}

Output:

Your order is: Instance of 'Future<String>'

As you can see, the asynchronous code works fine but it fails to get the value, here's why:

fetchUserOrder() function is an asynchronous, after the 2 sec delay it will provide a string that describes the user's order: a "Large Latte".
The print() inside the main() will get the user's order by operatingcreateOrderMessage() function, which should call fetchUserOrder() and wait for it to finish.
Because createOrderMessage() does not wait for fetchUserOrder() to finish, createOrderMessage() fails to get the string value from fetchUserOrder() function.
So, createOrderMessage() got a representation of pending work to be done: an uncompleted future.

So... how to get the value from a future?

There are two ways to get value in the future:

Using a callback.
Using async and await keywords.

First: Using Callback

When a future completes, you can run a callback to handle the result by using these methods: then(), catchError(), and whenComplete().

You can use then() when the future completes successfully with a value.

void main() {
  print('start fetching data');

  Future<String>.delayed(Duration(seconds: 2), () {
    return 'data are fetched';
  }).then((value) {
    print(value);
  });

  print('end fetching data');
}

Output:

start fetching data
end fetching data
data are fetched

But when the future completes with an error value, you can handle it by using thecatchError() method.

void main() {
  print('start fetching data');

  Future<String>.delayed(Duration(seconds: 2), () {
    return 'data are fetched';
  }).then((value) {
    print(value);
  }).catchError((error) {
  print(error);
});

print('end fetching data');
}

Output:

start fetching data
end fetching data
data are fetched

Here's another example of using catchError() that will make you understand more:

Future<int> fetchNumber(bool succeed) {
  return Future.delayed(Duration(seconds: 2), () {
    if (succeed) {
      return 42;
    } else {
      throw Exception("Failed to fetch number");
    }
  });
}

void main() {
  fetchNumber(false).then((value) {
    print("The number is $value");
  }).catchError((error) {
  print("Error occurred: $error");
  });
  print("Waiting for the number...");
}

Output:

Waiting for the number...
Error occurred: Exception: Failed to fetch number

fetchNumber() function returns a Future (which is a number) that simulates an asynchronous operation using Future.delayed, and after 2 seconds it throws an exception if the succeed value equal to false to simulate an error in the operation.

catchError() method will handle any errors that occur during the execution of the Future, Method After calling fetchNumber().

Also when a future completes with a value or an error, you can just use whenComplete() method. In other words, the callback whenComplete() method will always execute whether the future succeeds or not.

Future<int> fetchNumber(bool succeed) {
  return Future.delayed(Duration(seconds: 2), () {
    if (succeed){
      return 42;
    } else {
     throw Exception("Failed to fetch number");
    }
  });
}

void main() {
  fetchData(false).then((value) {
    print(value);
  }).catchError((error) {
    print("Error occurred: $error");
  }).whenComplete(() {
    print("Operation complete, cleaning up...");
  });

  print("Waiting for the operation to complete...");
}

Output:

Waiting for the operation to complete...
Error occurred: Exception: Failed to fetch number
Operation complete, cleaning up...

Second: Using `async` and `await` keywords.

The async and await keywords provide a declarative way to define asynchronous functions and use their results. Remember these two basic guidelines when using async and await:

To define an async function, add async before the function body.
Use await in front of any expression within an async function to wait for it to complete.
The await keyword works only in async functions.

Here's an example:

import 'dart:async';


Future<String> fetchData() async {
  await Future.delayed(Duration(seconds: 2));
  return 'Data fetched successfully!';
}

Future<void> main() async {
  print('Fetching data...');

  String result = await fetchData();

  print(result);

  print('Done fetching data.');
}

Output:

Fetching data...
Data fetched successfully!
Done fetching data.

Explanation:

ThefetchData() function is an async function which simulates fetching a data from a server and delay the result using Future.delayed(Duration(seconds: 2)).
The await keyword is used before Future.delayed, which causes the function to pause for 2 seconds before returning the result.
The main() function is also async because it uses the await keyword before fetchData(), which means the main() function will pause execution until fetchData() completes.
The print('Done fetching data.') line will execute only after fetchData() has returned its result.

Remember: async and await are one of the ways to get the value after the Future.

Error handling in asynchronous functions

Handling errors is crucial in asynchronous programming, you can use try-catch block with async functions to capture any errors that occur during the execution of the await Future.

Example:

Future<void> printOrderMessage() async {
  try {
    print('Awaiting user order...');
    var order = await fetchUserOrder();
    print(order);
  } catch (err) {
    print('Caught error: $err');
  }
}

Future<String> fetchUserOrder() {

  // Imagine that this function is more complex.
  var str = Future.delayed( const Duration(seconds: 4), () {
    throw 'Cannot locate user order';
  });
  return str;
}

void main() async {
  await printOrderMessage();
}

Output:

Awaiting user order...
Caught error: Cannot locate user order

Also, you can handle the errors by using callback methods: then(), catchError(), and whenComplete().

Here's an example of that:

Future<void> printOrderMessage() {
  print('Awaiting user order...');
  return fetchUserOrder().then((order) {
     print(order);
  }).catchError((err) {
    print('Caught error: $err');
  });
}

Future<String> fetchUserOrder() {

  // Imagine that this function is more complex.
  return Future.delayed(const Duration(seconds: 4), () {
    throw 'Cannot locate user order';
  });
}

void main() {
  printOrderMessage();
}

Output:

Awaiting user order...
Caught error: Cannot locate user order

So... what is the difference between both examples?

The main difference between using async/await and using then()/catchError() lies in how the asynchronous code is written and how it affects readability, maintainability, and error handling.

For instance, the async/await syntax makes the code more readable and easier to follow, while then()/catchError() syntax involves chaining method calls, which can become less readable with more complex asynchronous operations.

In error handling, try/catch is straightforward and similar to handling errors in synchronous code, while then()/catchError() error handling can sometimes be less intuitive especially when handling multiple asynchronous calls.

But, that doesn't mean using calling back methods are bad approach, as we said earlier it lies in how the asynchronous code is written and how it affects readability, maintainability, and error handling.

Do want more? here's another example :

Fetching data from the API server

Using callback methods: `then()`, `catchError()`

import 'package:http/http.dart' as http;
import 'dart:convert';


void fetchDataUsingCallbacks() {
  final url = Uri.parse('https://jsonplaceholder.typicode.com/posts/1');

  http.get(url).then((response) {
    if (response.statusCode == 200) {

    var data = jsonDecode(response.body);
    print('Data fetched successfully: ${data['title']}');

  } else {
    print('Failed to load data');
  }

  }).catchError((error) {
    print('An error occurred: $error');

  }).whenComplete(() {
    print('Request complete.');
  });
}


void main() {
  fetchDataUsingCallbacks();
}

Output:

Data fetched successfully: sunt aut facere repellat provident occaecati excepturi optio reprehenderit
Request complete.

Error Case:

An error occurred: <error message> 
Request complete.

Using `async` and `await` keywords with `try()`, `catch()`

import 'package:http/http.dart' as http;
import 'dart:convert';


Future<void> fetchDataUsingAsyncAwait() async {
  final url = Uri.parse('https://jsonplaceholder.typicode.com/posts/1');

  try {
    final response = await http.get(url);

    if (response.statusCode == 200) {

      var data = jsonDecode(response.body);
      print('Data fetched successfully: ${data['title']}');

    } else {
      print('Failed to load data');
    }

  } catch (error) {
    print('An error occurred: $error');
  } finally {
    print('Request complete.');
  }
}


void main() async {
  await fetchDataUsingAsyncAwait();
}

Output:

Data fetched successfully: sunt aut facere repellat provident occaecati excepturi optio reprehenderit
Request complete.

Error Case:

An error occurred: <error message> 
Request complete.

Conclusion

Previously in the last couple of articles, we learn what are we have delved into the intricacies of asynchronous programming in Dart, exploring both the async/await syntax and the use of callback methods such as then(), catchError(), and whenComplete(). We learned how asynchronous programming helps keep applications responsive and prevents blocking the main thread, especially during time-consuming operations like network requests or file I/O.

Asynchronous & synchronous Programming In Dart

Ahmed_Greynoon — Sun, 01 Sep 2024 06:24:58 +0000

Introduction

Previously in the last article, we talked about the fundamental concepts of single and multi-threaded programming, and understanding how they relate to concurrency and parallelism. Single-threaded programs execute tasks sequentially, one at a time, while multi-threaded programs can handle multiple tasks concurrently or in parallel, depending on the system's capabilities. Also, we talked about how single-threaded programming has the ability to handle multiple tasks at once using the concurrency concept only by switching between tasks, giving each task a small slice of time to execute before moving on to the next task, and can't do parallelism.

Now, let's talk about synchronous & asynchronous programming concepts and differences in Dart to understand how it deals with tasks.

Synchronous Programming

As we said previously, Synchronous programming means that code is executed sequentially from top to bottom, each statement is completed before the next one begins.

Synchronous code is often more straightforward to read, predictable, and easy to understand. But because the operations execute sequentially, one by one, it blocks the main thread, leading to unresponsiveness in the user interface, especially for time-consuming tasks like network requests or file operations. Also, CPU cycles are wasted during blocking operations as the application cannot perform other tasks while waiting for the current one to complete.

Asynchronous Programming

Asynchronous programming allows multiple operations to execute independently without blocking each other, which means that the statements do not have to wait for other operations to finish before they can run.

Asynchronous code allows the main thread to remain responsive, ensuring a smooth user experience even during time-consuming tasks, and also improving the overall efficiency of the application, as other tasks can continue while waiting for asynchronous operations to be completed. But the code introduces a level of complexity, especially for developers who are new to the paradigm, also debugging code can be more complex.

Overall, asynchronous programming is a powerful tool that can significantly enhance an application's performance and user experience.

What about Dart?

Dart is a single-threaded system, which means that tasks are executed sequentially, blocking the main thread until each operation completes. It does not support multi-threading which makes it inherently non-concurrent and non-parallel, because there's only one sequence of operations in a single-threaded environment.

Let's see a simple example of a synchronous program:



void main() {
   print(1);
   print(2);
   print(3);
}

Output:



1
2
3

In this program, the main() function runs line by line from top to bottom until it completes. This program runs synchronously because it never displays the number 2 before 1 for example.

For more understanding, let's talk another example:



import 'dart:io';

void synchronousOperation() {
  for (int i = 1; i <= 3; i++) {
    print(i);
    sleep(Duration(seconds: 1));
  }
}

void main() {
  print("Start");
  synchronousOperation();
  print("End");
}

Output:



Start
1
2
3
End

In this example, “Start” is printed, followed by numbers 1 to 3, each with a one-second delay, and finally, “End” is printed. Notice that during the delay, the entire application is unresponsive.

Sleep Function: refers to a synchronous operation that pauses code execution for a specified duration, perhaps to wait for some external process to complete or simply to delay execution, But during that time the entire program will stop. The way of using it is by passing the Duration object into the Sleep function when you call it.

So... what if there's a time-consuming task, like for example waiting for a file to load or fetching data from a remote server... how can Dart deal with that?

Well, actually it can by using asynchronous programming. Dart allows us to do asynchronous programming which runs our program without getting blocked, also concurrency can be achieved using isolates.

But before going any further, let's understand how Dart manages events and what are the isolates.

Concept of Isolates in Dart

We know that most platforms have Multi-threaded systems, which allow true parallel execution of tasks, and to take advantage of that, developers traditionally use shared-memory threads running concurrently. However, shared-state concurrency is error-prone and can lead to complicated code.

Unlike other programming languages, Dart is a single-threaded system and it can approach parallelism and concurrency in different ways by using isolates.

An isolate is an independent execution context that has its own memory and a single thread of execution.

So, instead of shared-memory threads, Dart code runs inside of isolates, which each isolate has its own memory to ensure that no isolate’s state is accessible from any other isolate, but they communicate by passing messages ensuring clear and controlled data exchange.

Isolates are Dart's way of achieving concurrency without shared memory, avoiding the complexities and potential issues of traditional multi-threading, and since Isolates run independently they can execute code in parallel, taking full advantage of multi-core processors. This is how Dart achieves true parallelism.

All Dart code runs in isolates, starting in the default main isolate, and optionally expanding to whatever subsequent isolates you explicitly create. When you spawn a new isolate, it has its own isolated memory and its own event loop. The event loop is what makes asynchronous and concurrent programming possible in Dart.

How it works?

All code execution begins in what is known as the default main isolate, which is automatically created when the Dart application starts. The main isolate has its own memory space, and event loop, and can handle tasks such as I/O operations, user input, and updates to the UI (in the context of Flutter).

If the application requires concurrency execution that should run separately from the main isolate or a parallel execution to fully utilize multi-core processors, then you can create a new isolate by 'spawn' it.

As we mentioned previously, each isolate has its own memory, event loop, and tasks, also they communicate with each other by passing messages.

Example:



import 'dart:isolate';


void sayhii(var msg) {
  print('execution from sayhii ... the message is :${msg}');
}

void main() { 
  Isolate.spawn(sayhii, 'Hello!!');
  Isolate.spawn(sayhii, 'Whats up!!');
  Isolate.spawn(sayhii, 'Welcome!!');

  print('execution from main1');
  print('execution from main2');
  print('execution from main3');
}

output:



execution from sayhii ... the message is :Hello!!

execution from main1

execution from main2

execution from main3

execution from sayhii ... the message is :Welcome!!

execution from sayhii ... the message is :Whats up!!

Exited.

In this example, we have two functions sayhii() and main() function might not run in the same order each time cause the Isolate.spawn method creates a new isolate for the function sayhii, and executed it in parallel with the remaining code. If you run the code again, the output will be different each time as we can see in the second output.

Another example:



import 'dart:isolate';

void isolateFunction(SendPort sendPort) {
  sendPort.send('Message from the new isolate');
}

void main() async {
  ReceivePort receivePort = ReceivePort();
  await Isolate.spawn(isolateFunction, receivePort.sendPort);
  receivePort.listen((message) {
    print('Main isolate received: $message');
  });
}

output:



Main isolate received: Message from the new isolate

As we saw, isolates do not share memory, so they communicate with each other by passing messages using SendPort and ReceivePort. The main isolate can send data to the new isolate via a SendPort, and the new isolate can reply using another SendPort.

But what is the Event loop, and what is the deal with async and await?
Don't worry I will explain each one.

The Event loop

As we said earlier, All the code you write within the main() function and any synchronous or asynchronous operations that do not involve other isolates are executed in the main isolate.

Event: refers to a unit of work or a task that is scheduled to be processed by the event loop, it can be anything from server requests to repaint the UI, to user taps and keystrokes, to I/O from the disk.
Event loop: refers to an invisible process that manages the execution of events and callbacks. Dart’s runtime model is based on an event loop, which is responsible for executing the program's code, processing scheduled events, and more.

How Does Event Loop Work?

The Dart event loop main job is to handle events, like mouse taps, buttons tap, or request data from a remote server. And it works by continuously checking two queues:-

Micro-task queue.
Event queue.

The micro-task queue is used for short asynchronous internal actions that come from your Dart code like for example long-running tasks, and it is what the event loop considers first ensuring that all pending micro-tasks are completed before moving on to the next event in the event queue.

The event queue is used for handling asynchronous external events such as I/O operations, timers, user interactions, and messages between isolates.

The micro-task queue is ideal for tasks that you want to have completed as soon as possible, but not immediately. For instance, you might use the micro-task queue to delay some computation or to allow the UI to update between tasks.

This priority system allows Dart to handle smaller, internal tasks immediately while deferring larger or external tasks until the micro-tasks are complete, maintaining efficiency and responsiveness in asynchronous operations.

Remember: both the micro-task queue and the event queue are parts of Dart's asynchronous programming model, and they are designed to manage asynchronous operations.

The event loop is always running. It continuously checks the synchronous tasks, micro-task queue, and event queue. So, when the Flutter application runs :

The main isolate is created and the event loop starts, The void main() is the first to execute synchronously.
It always runs synchronous tasks immediately, but that doesn't mean it can't be possible to interrupt them.
If all the tasks in the main isolate are completed, the event loop moves the tasks (if available) from the micro-task queue to the main isolate for execution until the micro-task queue is empty.
If both synchronous tasks and the micro-task queue are empty, the event loop moves the tasks from the event queue to the main thread for execution.
The event loop continues until all the queues are empty.

Here's also an animated youtube diagram for the event loop lifecycle:

Asynchronous programming in Dart involves the use of Future objects and async functions (we will explain it later). Whenever we write asynchronous code we schedule tasks to be run later. For example, when we use Future objects and async functions, we’re telling the Dart event loop to complete other Dart codes first and come back when the Future is complete.

Here is a simple example of how the Dart event loop works:



import 'dart:async';


void main() {
  print('Dart app starts');
  Future(() => print('This is a new Future'));
  scheduleMicrotask(() => print('This is a micro task'));
  print('Dart app ends');
}

Output:



Dart app starts
Dart app ends
This is a micro task
This is a new Future

The main function executes synchronously. The print(‘Dart app starts’) and print(‘Dart app ends’) are executed immediately. The Future and scheduleMicrotask calls are added to their respective queues and are executed once the main function has completed.

Another example:



import 'dart:async';

void main() {
  print('Dart app starts');
  scheduleMicrotask(() => print('Microtask 1'));
  scheduleMicrotask(() => print('Microtask 2'));
  Future(() => print('This is a new Future'));
  print('Dart app ends');
}

Output:



Dart app starts
Dart app ends
Microtask 1
Microtask 2
This is a new Future

In this sample code, scheduleMicrotask functions are processed before the new Future, although the Future was added to the event queue before scheduleMicrotask was added to the micro-task queue. This demonstrates how Dart prioritizes micro-tasks over events.

Conclusion

Now we know everything about synchronous programming and asynchronous programming models, synchronous code is executed sequentially blocking the main thread until each operation completes, while asynchronous code allows tasks to run independently without blocking which keeps the main thread responsive and improves overall performance.

Dart is a single-threaded system and it handles operations concurrency through isolates. Isolates provide a way to achieve concurrency and parallelism by running in separate memory spaces and communicating via message-passing, avoiding the pitfalls of shared memory.

The event loop in Dart manages both synchronous and asynchronous tasks using micro-task and event queues, ensuring smooth task execution and responsiveness.

By understanding these foundational concepts, now we know how to implement synchronous code in Dart... but what about asynchronous code?

Well, in the next article, we will dive into how to implement it in Dart cause this is already a long one and that is enough.

Thank you for your time and I will see you in the next one.

Single and Multi-Threaded Programming with Concurrency and Parallelism - Explain The Differences and Concepts

Ahmed_Greynoon — Thu, 29 Aug 2024 07:57:12 +0000

In the world of programming, you definitely will face the concepts of single and multi-threaded programming, these concepts are closely tied to how a programming language handles concurrent execution and parallelism. In this article, we will explore the concepts and differences between them. But first, we need to understand concurrency and parallelism.

Also... why should we know about this? 🤔 why would we bother ourselves to learn this? 🤔
trust me, I'm cooking something 👨🏻‍🍳🔥 and everything is connected so be patient and read. 🤗

Concurrency Vs Parallelism

Concurrency: refers to the ability of a system to handle multiple tasks at once. However, this doesn't mean that the tasks are literally being executed simultaneously (at the exact same moment). Instead, concurrency allows multiple tasks to make progress during overlapping time periods.
Parallelism: occurs when two or more tasks run at the same time (simultaneously). They start, run, and complete in parallel, for example in your PC when your processor has more than one core, it is capable of running multiple threads at the same time. Each processor core can be working on a different task. This is a form of parallelism.

In a single-core processor, for example, it can only execute one instruction at a time. However, the operating system can rapidly switch between tasks, giving each task a small slice of time to execute before moving on to the next task. So, even though the processor is only executing one task at any given moment, it switches between tasks so quickly that it appears as though they are happening concurrently.

In multi-core processors also, for example, true parallelism can occur where different cores handle different tasks simultaneously. However, concurrency still applies because even within a single task, the system may break it down into smaller sub-tasks that are managed concurrently.

Understanding Single and Multi-Threaded Programming

Single-Threaded Programming

In single-threaded programming, a program operates on a single thread of execution. This means that the program executes one task at a time in a sequential manner, which means that a program follows the order of operations as defined in the code, executing one operation at a time. But if it encounters a time-consuming task (like for example waiting for a file to load or fetching data from a remote server), it must finish this task before moving on to the next.

This is inherently non-concurrent and non-parallel cause there's only one sequence of operations and in a single-threaded environment, there is no true concurrency because if tasks appear to run simultaneously they are actually being interleaved or managed through time-slicing, in which the opposite of what we said previously "The Concurrency refers to the ability of a system to handle multiple tasks at once", which creates the illusion of concurrency.

But for Parallelism, a Single-threaded environment cannot achieve true parallelism because there’s only one thread doing all the work.

Multi-Threaded Programming

In multi-threaded programming, a program runs multiple threads concurrently. These threads can perform different tasks simultaneously or handle multiple parts of a single task.

A multi-threaded program can split tasks into multiple threads, which can be run either concurrently or in parallel depending on the system's capabilities and the nature of the tasks.

In a multi-threaded environment, concurrency is achieved by allowing multiple threads to make progress on different tasks or parts of the same task. Concurrency doesn't necessarily mean that these tasks are being executed at the same time; it just means that they are being managed in such a way that it seems like they are happening simultaneously.

Parallelism occurs in a multi-threaded environment when multiple threads actually run at the same time on different cores of a multi-core processor. This is true parallel execution, where tasks are processed simultaneously, leading to potentially significant performance improvements.

Conclusion

Now, we understand the difference between concurrency and parallelism, Concurrency is managing multiple tasks that execute during overlapping periods which is often achieved on single-core processors, while parallelism is about executing multiple tasks at the same time which is possible on multi-core processors.

In single-threaded programming, tasks run sequentially without true concurrency or parallelism, but multi-threaded programming can run concurrently or in parallel improving performance by handling multiple tasks more efficiently.

Next article, we will learn more about these concepts and theories, and how to implement them using Dart programming language, and now I bet you know why 😁😁

Forem: Ahmed_Greynoon

Getting Started with Asynchronous Programming in Dart

Why does asynchronous code matter?

Future

Example of a Future:

So... how to get the value from a future?

First: Using Callback

Second: Using `async` and `await` keywords.

Error handling in asynchronous functions

So... what is the difference between both examples?

Fetching data from the API server

Using callback methods: `then()`, `catchError()`

Using `async` and `await` keywords with `try()`, `catch()`

Conclusion

Asynchronous & synchronous Programming In Dart

Introduction

Synchronous Programming

Asynchronous Programming

What about Dart?

Concept of Isolates in Dart

How it works?

The Event loop

How Does Event Loop Work?

Conclusion

Single and Multi-Threaded Programming with Concurrency and Parallelism - Explain The Differences and Concepts

Concurrency Vs Parallelism

Understanding Single and Multi-Threaded Programming

Single-Threaded Programming

Multi-Threaded Programming

Conclusion

Thank you for your time 🥰🥰

I hope this article has made things clear to you.

Forem: Ahmed_Greynoon

Getting Started with Asynchronous Programming in Dart

Why does asynchronous code matter?

Future

Example of a Future:

So... how to get the value from a future?

First: Using Callback

Second: Using async and await keywords.

Error handling in asynchronous functions

So... what is the difference between both examples?

Fetching data from the API server

Using callback methods: then(), catchError()

Using async and await keywords with try(), catch()

Conclusion

Asynchronous & synchronous Programming In Dart

Introduction

Synchronous Programming

Asynchronous Programming

What about Dart?

Concept of Isolates in Dart

How it works?

The Event loop

How Does Event Loop Work?

Conclusion

Single and Multi-Threaded Programming with Concurrency and Parallelism - Explain The Differences and Concepts

Concurrency Vs Parallelism

Understanding Single and Multi-Threaded Programming

Single-Threaded Programming

Multi-Threaded Programming

Conclusion

Thank you for your time 🥰🥰

I hope this article has made things clear to you.

Second: Using `async` and `await` keywords.

Using callback methods: `then()`, `catchError()`

Using `async` and `await` keywords with `try()`, `catch()`