DEV Community: Mathieu K

Asynchronous Functions in Dart

Mathieu K — Mon, 25 May 2026 08:00:00 +0000

In a previous post synchronous functions and iterators have been explained. Those functions are blocking, and in our daily busy life, we don't want our programs to block, we want a smooth experience. Well, if you are coding in C or C++, you should probably know pthreads, a library used to create threads, a way to create independent computation concurrently. The same exist in many other languages with sometimes different name, but doing mostly the same with just an interface and cool features.

Dart is working a bit like JavaScript, it uses only one thread to do all the computation by default, but this "thread" can be split in many small part allowing the illusion of concurrent or parallel computation. To make that possible, one need to create asynchronous functions, marked with async or async* keywords.

A function is asynchronous if its body is marked with the async or async* modifier. Otherwise the function is synchronous.

-- Dart Language Specification, Chapter 9, page 23

What does it really mean? Well, like the very great Dart documentation part about Concurrency explains, when a function is asynchronous, the event loop will listen for some changes in "background". When the function returns some values, the event loop receive it and return it to the caller. Let have a look on async keyword.

If f is marked async, then a fresh instance is associated with the invocation, where the dynamic type of o implements Future<T>, where T is the actual type corresponding to the future value type of f.

-- Dart Language Specification, Chapter 17, Section 15, page 141

In short, adding async when declaring a new function will mark it as an asynchronous function returning a Future object.

Future<int> async_int_addition(int x, int y) async {
  return x + y;
}

void main() async {
  print(async_int_addition(1, 2);
  print(await async_int_addition(1, 2));
}

$ dart run bin/async.dart 
Instance of 'Future<int>'
3

If f is marked async*, then a fresh instances implementing Stream<U> is immediately returned, where U is the actual type corresponding to the element type of f.

-- Dart Language Specification, Chapter 17, Section 15, page 141

Stream<int> async_int_generator(int x, int y) async* {
  if (y<x) throw "y<y"; 
  while (x <= y) {
    yield x;
    x++;
  }
}

Future<int> main() async {
  await for (var i in async_int_generator(0, 10)) {
    print(i);
  }
  return 0;
}

The previous piece of codes are also using a specific keyword: await. Let check the specification to see what does this one is doing.

An await expression allows code to yield control until an asynchronous operation completes. [...] An await expression can only occur in a function which is declared asynchronous. The await identifier has has no special meaning in the context of a normal function [...] await(e) can be a valid function invocation in non asynchronous functions.

-- Dart Language Specification, Chapter 17, Section 34, page 182

This means if we are using asynchronous function and we want to get the result returned by it, one can use await to get it. Bonus point: the value returned will not be a Future anymore but the generic type defined. Here an example:

Future<int> t() async {
  return 1;
}

void main() async {
  print(t());
  print(await t());
}

t() function is straightforward, it returns simply an integer from an asynchronous call. The main() function will print the returned value of this without await and with it.

$ dart run bin/await.dart
Instance of '_Future<int>'
1

As you can see, the first one returns an instance of Future, the "reference" of the execution, while the second would wait until the asynchronous function is done and return an integer.

Asynchronous functions are more than critical in Dart environment and are the foundation of most of the ecosystem. Mastering this part is vital, and if the information provided in this article was not enough, one should probably wait for the next ones on Future and Stream classes. I underestimated the complexity of this part of the language and thought it could fit in one big post... It was not the case.

Anyway, here more links I can highly recommend to understand how concurrency programming is working with Dart:

Concurrency in Dart from the official Guide, an interesting publication talking a bit about the Dart event loop;
Asynchronous programming from the official Guide where many examples using async and await can be studied;
Dart Language Official Specification where you can find the expected behaviors of all previous keywords including async, async*, yield, yield* and await;
Dart Async Package Documentation where the dart:async package is described, it contains a good introduction;
Master Dart: Yield vs Yield* – Unlock Iterable Power by Dieter. A nice article to understand how yield and yield* are working;
Dart Lesson 13: Asynchronous Programming Basics — Future and async/await by JiGe on Medium. Another great publication giving some use cases and lot of examples;
How can I "sleep" a Dart program on StackOverlow where I found the sleep() function was blocking the whole Dart event loop...

Image Cover by Jose Ruales on Unsplash

Synchronous Functions in Dart

Mathieu K — Fri, 22 May 2026 08:00:00 +0000

This series of post will try to explain a complex topic: concurrent and parallel programming, in Dart. I think the only way to deal with that is using the Erlang VM (BEAM), but Clojure and other functional languages are usually doing better job on this part. Unfortunately, to me, most of other languages using OOP don't offer a great abstraction to concurrency and parallelism, but during the last decade, things are changing a bit.

Anyway, before talking about concurrency, parallelism, or even distributed systems, everything starts with synchronous call, the "standard" way to execute a function or a procedure on a computer. In dart, synchronous function call and generators functions need to me studied a little bit.

Firstly, all function without any specific keyword are all defined as synchronous:

int addition(int x, int y) {
  return x + y;
}

If the keyword sync was present in the language, the previous snippet would be equivalent to the one below. Don't try to compile it, it will fail.

// could be equivalent to the following
// snippet with the sync keyword. But this
// function will not work, sync keyword is
// invalid during compilation
int addition_sync(int x, int y) sync {
  return x + y;
}

When adding the addition() function inside the main() entry-point, it will directly return the value. In fact, you can't really see this because it's quick, but the computer will block a little bit to wait the result of the computation.

int main() {
  return addition(1, 2);
}

A synchronous function will always wait for any kind of return before continuing the execution of the program. For example, if an infinite loop is created, the function will never return, and the function will block the whole program. The following snippet, when executed, will never return because of the while loop defined in the infinite_loop() function. The only way to close this program is to kill it (for example using Ctrl-C or sending another signal on UNIX systems).

int infinite_loop() {
  while (true) {
    // do something
  }
  return 0;
}

int main() {
  return infinite_loop();
}

Great, we know how to create synchronous functions. Now, let have a look on a specific keyword: sync*. This one is a syntactic sugar to help developers creating generators, a function that return many elements, one at a time. The best example is the List class (or []). This data type - a list - is seen as a generator, and more precisely an Iterable.

A function is a generator if its body is marked with the sync* or async* modifier. [...] Generator functions are a sugar for functions that produce collections in a systematic way, by lazily applying a function that generates individual elements of a collection. Dart provides such a sugar in both the synchronous case, where one returns an iterable, and in the asynchronous case, where one returns a stream.

-- Dart Language Specification, Chapter 9, page 23

Let create our first generator from scratch, let call it int_generator(). It will take 2 integers as arguments and will return the list of elements between them. You can see it as a kind of primitive range or sequence function.

Iterable<int> int_generator(int x, int y) sync* {
  if (y<x) throw "y<x"; 
  while (x <= y) {
    yield x;
    x++;
  }
}

int main() {
  for (var i in int_generator(0, 10)) {
    print(i);
  }
  return 0;
}

In the first place, instead of returning a simple int this function is returning an Iterable<int>. Why? Because we are using yield, but we will explain that a bit later. Next, the function definition looks like a classic one, but the sync* keyword is added just after. It means this function will be a generator.

Then, the body of the function where a first step is to avoid creating an infinite loop by creating a simple guard throwing an exception if the second argument is less than the first argument. Immediately after, a while loop is created, where the first argument is incremented until the first argument is less or equal to the second one.

The yield statement adds an object to the result of a generator function.

-- Dart Language Specification, Chapter 18, Section 16, page 213

In this loop, the keyword yield followed by variable (or any valid terms) is used. This specific expression is important, because it will adds the object into the result of the generator. In other words, if another function is calling the previous function inside a loop, the sequence of integer will be printed to the screen.

Let execute that from the console.

$ dart run bin/int_generator.dart
0
1
2
3
4
5
6
7
8
9
10

yield is not the only unique term here able to put an object inside a generator, yield* (yield-each) can also be used to push a series of objects, in fact a subtype of Iterable class.

The yield-each statement adds a series of objects to the result of a generator function.

-- Dart Language Specification, Chapter 18, Section 17, page 214

Iterable<int> int_generator(int x, int y) sync* {
  if (y<x) throw "y<x"; 
  yield* [x,y];
}

int main() {
  print(int_generator(0, 10));
  for (var i in int_generator(0, 10)) {
    print(i);
  }
  return 0;
}

Let execute this code.

$ dart run bin/int_each_generator.dart 
(0, 10)
0
10

To be honest, I don't currently understand why it returns a record on the first part of the program. I was reading the specification but I was unable to find and answer. I will let this problem for future-me. A quick note though: a generator cannot return a value.

Case ⟨Generator functions⟩. It is a compile-time error if a return statement of the form return e; appears in a generator function.

-- Dart Language Specification, Chapter 18, Section 12, page 211

Based on the documentation, it also seems yield* can be used to improve recursive function performance. Here the one of the previous example implemented using recursive function call.

Iterable<int> int_rec_generator(int x, int y) sync* {
  if (x<=y) {
    yield x;
    yield* int_rec_generator(x+1, y);
  }
}

int main() {
  print(int_rec_generator(0, 10));
  return 0;
}

Let run it now.

$ dart run bin/int_recursive_generator.dart 
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

Same result than before, but it was using a recursive function. If I remember correctly, calling recursively a function in Dart with tail queue optimization and trampoline is a very bad idea (it will consume a lot of stack and memory). Anyway, let switch to another topic: Iterable class.

`Iterable` class

We know how to create generators, and then Iterable from scratch, but what we can do with this kind of objects? Let read the definition from the API documentation.

A collection of values, or "elements", that can be accessed sequentially.

-- Dart Language Documentation, Iterable class

Not all features will be illustrated there, only the one looking interesting and useful for my own use cases.

Iterate.generate() constructor creates a new Iterable object using Integer by default (like a Range/Sequence). The second argument offers a way to change the type returned based on the integer sequence produced (a bit like a map()).

int main() {
  var x = Iterable.generate(10);
  print("generate(10): $x");

  var y = Iterable.generate(26, (int x) => String.fromCharCode(x+65));
  print("generate(10, _): $y");

  return 0;
}

$ dart run bin/t.dart 
generate(10): (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
generate(10, _): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

Iterable.contains() method returns true if the object passed in the first argument is present in the collection of objects managed by the Iterable.

$ cat bin/contains.dart 
void main() {
  var a = Iterable.generate(26, (int x) => String.fromCharCode(x+65));
  print('"A"? ${a.contains("A")}');
  print('65? ${a.contains(65)}');
}

$ dart bin/contains.dart 
"A"? true
65? false

Iterable.elementAt() method returns the element present at the position defined by the first argument. If the position does not exist, it throws a RangeError exception.

$ cat bin/elementAt.dart 
void main() {
  var x = Iterable.generate(10);
  print(x.elementAt(0));
  print(x.elementAt(9));
  print(x.elementAt(1024));
}

$ dart bin/elementAt.dart 
0
9
Unhandled exception:
RangeError (index): Index out of range: index should be less than 10: 1024
#0      IndexError.check (dart:core/errors.dart:520:7)
#1      _GeneratorIterable.elementAt (dart:core/iterable.dart:928:16)
#2      main (file:///dart/t/bin/elementAt.dart:5:11)
#3      _delayEntrypointInvocation.<anonymous closure> (dart:isolate-patch/isolate_patch.dart:314:19)
#4      _RawReceivePort._handleMessage (dart:isolate-patch/isolate_patch.dart:193:12)

Iterable.every() method returns true if the collection of items satisfies the anonymous function passed in argument.

$ cat bin/every.dart 
void main() {
  var x = Iterable.generate(10);
  print(x.every((y) => y >= 0 ));
  print(x.every((y) => y == String ));
}

$ dart bin/every.dart 
true
false

Iterable.fold() method reduces the collection of items using a combine function present in second argument and an initial value defined in the first argument.

void main() {
  Iterable<int> i = Iterable.generate(10);
  print(i.fold<int>(1, (v, e) => v + e));

  var s = Iterable.generate(26, (int x) => String.fromCharCode(x+65));
  print(s.fold<String>("string: ", (v, e) => "${v} ${e}"));
}

$ dart bin/fold.dart 
46
string:  A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

Iterable.forEach() method iterates of the collection of item. This method returns nothing.

void main() {
  var list = [1,2,3,4, "end"];
  list.forEach((x) => print(x));
}

$ dart bin/forEach.dart 
1
2
3
4
end

Iterable.join() method joins the collection of item with a String and converts all object in the collection t String.

void main() {
  var list = ["start", 1, 2, 3, "end"];
  print(list.join(", "));
}

$ dart bin/join.dart 
start, 1, 2, 3, end

Iterable.map() method modifies each element of the collection by calling a function defined in the first argument.

void main() {
  var m = [
    {'a': 1},
    {'b': 2}
  ];
  print(
    m.map(
      (x) => {x.values.first: x.keys.first}
    )
  );
}

$ dart bin/map.dart 
({1: a}, {2: b})

Iterable.reduce() methods is similar to Iterable.fold() excepts it does not have an initial value defined.

void main() {
  Iterable<int> list = Iterable.generate(20);
  print(list.reduce((a, e) {
    print("$a $e");
    if (e%2==0) {
      return a + e;
    }
    else {
      return a;
    }
  }));
}

$ dart bin/reduce.dart 
0 1
0 2
2 3
2 4
6 5
6 6
12 7
12 8
20 9
20 10
30 11
30 12
42 13
42 14
56 15
56 16
72 17
72 18
90 19
90

Way more methods are available, but it was not expected to go so deep in this post. If you want to go even deeper, you will need to read the test cases and the Dart implementation:

Iterable test cases can be found in the files tests/corelib/iterable*.dart from Dart SDK.
Iterable implementation source code can be found in sdk/lib/core/iterable.dart.

With these 2 links, you will have more than enough to understand how things are working.

Cover Image by Will H McMahan on Unsplash

Upgrading OpenBSD 7.8 to OpenBSD 7.9

Mathieu K — Thu, 21 May 2026 08:00:00 +0000

The lastest version of OpenBSD has been released this week and announced on the Mailinglist (but also on X/Twitter by Brian Steele). As usual, lot of improvement, this publication is just a quick summary.

Read the release note and the upgrade procedure.
Ensure you have enough place on your partitions.

df -h

Be prepared to upgrade your database like PostgreSQL. Do a Backup.
Start with one device to see if everything is fine.
Upgrade with sysupgrade.

sysupgrade

After the reboot, upgrade the packages with pkg_add

pkg_add -uUra

Do a second reboot if necessary
Upgrade PostgreSQL and other services which have been upgraded.
Do a third reboot to check if all services are started correctly during boot (reboot proof servers)

And... It should be okay! No big deal for this upgrade on my side, everything worked without issues.

Cover Image by A Perry on Unsplash

Dealing with WebSocket in Dart

Mathieu K — Wed, 20 May 2026 08:00:00 +0000

WebSocket is a protocol created more than 10 years ago offering a bidirectional communication channel between a client and a server. It fixes the HTTP polling issue.

The WebSocket Protocol attempts to address the goals of existing bidirectional HTTP technologies in the context of the existing HTTP infrastructure; as such, it is designed to work over HTTP ports 80 and 443 as well as to support HTTP proxies and intermediaries, even if this implies some complexity specific to the current environment. However, the design does not limit WebSocket to HTTP, and future implementations could use a simpler handshake over a dedicated port without reinventing the entire protocol. This last point is important because the traffic patterns of interactive messaging do not closely match standard HTTP traffic and can induce unusual loads on some components.

-- RFC6455, section 1

Today, let have some fun with WebSocket in Dart

WebSocket Server with `shelf`

Unfortunately, like most of the modern language, there is a framework war. Many different implementation exists for doing the same thing. I don't really have time to check all of them, so, I will just do quick table. All of them are supporting WebSockets.

package	version	framework?	deprecated?	notes
`shelf`	1.4.2	no	no	maintained by dart team
`http_server`	1.0.0	no	yes	previous official http server
`frog`	1.2.6	yes	no	minimalist backend framework
`shelf_easy`	5.2.0	yes	no	lightweight framework
`darto`	0.0.35	yes	no	micro-web framework
`serinus`	2.1.12	yes	no	flexible framework
`alfred`	1.1.3	yes	no	expressjs like web server
`vania`	1.1.5	yes	yes	high-performance framework
`finch`	1.3.2	yes	no	lightweight framework (looks popular)

Most of them are using shelf or http_server as backend, not sure if it's really necessary to test them all one by one. Anyway, I will use shelf for one reason: this is not a framework, and it is maintained by the Dart team. I'm a bit sad though, because I can't find a lot of documentation, except the official API. To use WebSocket with shelf, the shelf_web_socket handler is required, again, only the API documentation can easily be found. A full example can be found in server/simple directory from dart source code.

For this exercise, I would like to have something simple:

long living foreground process
listening on 127.0.0.0:8080
only one route: /
all other routes are redirected to /
automatic support of web socket
echo all message sent by the client

No authentication, no encryption, just a simple websocket echo server. First, let try to understand how to use shelf. What kind of packages will be needed there?

shelf from the shelf package. It includes different kind of helpful classes to deal with the server, like Cascade (managing handlers), Pipeline to compose Middlewares and Handlers, Request to give an abstract view of a request, Response to offers an interface for the HTTP response returned and finally Server as adapter. We will see that probably later.
shelf_io from the shelf package. This one is an adapter, mostly used to handle HttpRequest, if one wants to create a quick and dirty http server, one can use the server() method.
shelf_router from the shelf_router package. This is a routing library designed for shelf, offering Route and Router classes to deal with HTTP path routing. In our case, it will be only used to redirect all path to /.
shelf_web_socket from the shelf_web_socket package. Well, it has already be described before, this is an handler to deal with WebSockets.
web_socket_channel package, mostly used for few exposed classes.

Knowing that, here the headers used to deal with a simple shelf WebSocket server:

import 'dart:collection';
import 'dart:convert';
import 'dart:io';
import 'package:ws/ws.dart' as ws;
import 'package:shelf/shelf.dart';
import 'package:shelf/shelf_io.dart' as shelf_io;
import 'package:shelf_router/shelf_router.dart' as shelf_router;
import 'package:shelf_web_socket/shelf_web_socket.dart';
import 'package:web_socket_channel/web_socket_channel.dart';

To create a WebSocket handler, a callback function is required, it is called onConnection in the implementation. This function is taking 2 arguments, the first one is a WebSocketChannel object, and the second argument is a String representing an eventual WebSocket subprotocol.

void _onConnection(WebSocketChannel webSocket, String? subprotocol) {
  webSocket.sink.add('{"msg":"ready"}\n');
  webSocket.stream.listen((message) {
    print('received: "$message"');
    webSocket.sink.add('{"msg":"$message"}\n');
  });
}

The WebSocketChannel object got 2 interesting properties:

sink - an instance of the Sink class - used to send value to the client, it can be used also to close the connection with the close() method. Then, in onConnection() function, when the connection is ready, the server is sending a first message.
stream - an instance of the Stream class - used to receive the message emitted by the client. In onConnection() function, every time a client is sending a message, the server will print the message locally on STDOUT and will return the same message to the client.

Handler _webSocketHandler1() {
  return webSocketHandler(
    _onConnection,
    protocols: null,
    allowedOrigins: null,
    pingInterval: Duration(seconds: 30)
  );
}

A dedicated function to start this first test is also required. Let call it startShelfIO where shelf_io will be used to start the server using serve() method.

void startShelfIO() {
  shelf_io
    .serve(_webSocketHandler1(), 'localhost', 8080)
    .then((server) {
      print('server started');
    });
}

Finally the main() function, it will simply invoke startShelfIO() function and do nothing more.

void main(List<String> arguments) {
  startShelfIO();
}

Hmm. We don't have a WebSocket client available right, it will be coded in the next part of this article. Unluckily, curl does not have a full support for the WebSocket protocol (it can receive but not send data). Instead, we can install the browser-websocket-client open-source plugin available on the Chrome Web Store. Are you Firefox friendly? You can use Weasel and its still open-source. If you prefer a command line tool, you can also check websocat or claws.

$ dart run
Building package executable... 
Built ws:ws.
server started
received: "{"client": "test"}"

It seems to works... What if we want to close the connection from the server side? Simply close() the sink.

webSocket.sink.close();

To do something before closing the connection or if the client is closing it on its side, the onDone attribute can be set while invoking the listen() method.

If this stream closes and sends a done event, the onDone handler is called. If onDone is null, nothing happens.

-- listen abstract method

Am I following the best practices here? Absolutely not! But if you want to fix my mess and add many layers of security, here a small list of references to do that:

WebSocket Security Cheat Sheet by the OWASP Team;
WebSocket architecture best practices: Designing scalable realtime systems by Ably
WebSocket Best Practices for Production Applications from WebSocket.org
WebSocket Security Testing: Penetration Test Cases & Best Practices by Mahendra Mb
WebSocket: Best Practices by MongoHost

If you simply see other implementation or read more about WebSockets server on Dart:

Create a WebSocket Server with Dart by MojoAuth
Working with WebSocket by @itzmeanjan

WebSocket Client with `web_socket`

I will not do the same error twice and start to check all frameworks/implementations to deal with a WebSocket client in Dart. The first one available is the web_socket package. This one is directly maintained by the Dart team and the source code can be seen in pkgs/web_socket. An unique example is also available. The previous package called web_socket_channel was the one used by most of the project, but due to the complexity, a simpler one was required.

$ dart pub add web_socket
Resolving dependencies... 
Downloading packages... 
  web_socket 1.0.1 (from transitive dependency to direct dependency)
Changed 1 dependency!

Only the web_socket package will be required here. Note: to make things easier, just create a new dart file like bin/wsc.dart.

import 'package:web_socket/web_socket.dart';

Let create an isolated function called webSocketClient to deal with the socket initialization.

void webSocketClient() async {
  final socket = 
    await WebSocket.connect(
      Uri.parse('ws://localhost:8080/')
    );
  socket.sendText('hello');
  socket.events.listen(
    (event) async {
      switch (event) {
        case TextDataReceived(text: final text):
          print("$text");
        case BinaryDataReceived(data: final data):
          print("$data");
        case CloseReceived(code: final code, reason: final reason):
          print("$code, $reason");
      }
      socket.close();
    }
  );
}

The connect() static method is called with the URL of the server using an Uri object. It returns a Future<WebSocket> object.
sendText() method is then invoked to send a text message to the server. If binaries are required, then use sendBytes() method. It returns nothing and in case of disconnection, the messages are silently discarded.
The WebSocketEvent class is then used to deal with the events received on the socket. Those events are usually messages sent by the server, they can are defined in three different classes:
- a TextDataReceived object is returned when the server is sending text message (e.g. JSON).
- a BinaryDataReceived object is returned when the server is sending binary message (e.g. protobuf, CBOR).
- a CloseReceived object is finally returned when the connection is closed.
The close() method is called to explicitly close the connection from the client side.

The client side here is quite simple, and does not involve complex procedure. To invoke it, just execute the webSocketClient() function in the main() entry-point.

void main() async {
  webSocketClient(socket);
}

Time to test if it is working correctly

$ dart run bin/wsc.dart
{"msg":"ready"}

It seems to work. The client connects to the server, return the message received and simply close the connection.

Another popular WebSocket client package called web_socket_client is also available at pub.dev. I'm not really sure if it adds more features or is more flexible than the default WebSocket client maintained by the Dart team. If you are interested to see more implementations and examples, here a quick list:

Conclusion

Creating a WebSocket client and a WebSocket server was not so hard, even if the documentation is hard to find, and most of the examples are limited to simple use cases. The subprotocol feature present in WebSocket is kinda interesting and I think I will work on that on another post. Again, the code presented above was made for test purpose only, I can't recommend anyone to use it in production environment.

Anyway, I think in a future publication, we will create something a bit more complex, like creating a custom communication protocol between a client and a server, using binary data.

Cover Image by Andrew Knechel on Unsplash

Discovering Swift

Mathieu K — Tue, 19 May 2026 08:00:00 +0000

Is Swift one of those so called "modern" languages trying to fix what C gave us for good? Or just something else? Well, for the ones who know me a bit, "modern" languages like Rust or Go are not really my friends. Swift, in other hands, is trying something that annoys me: mobile application development. Mobile applications are generarily using Java/Kotlin or C++. In some rare case, other languages, and sometime C. If you want to create your own application on both iOS and Android, the two main OS competitors, you should probably start to learn Java/Kotlin. Since its latest release though, Swift can now create applications for iOS and for Android...

For this first publication on Swift, I will publish only a list of resources. Indeed, after having tested it, this language currently does not fit all my requirements, and Dart/Flutter will be used instead. Anyway, it's always a good thing to have a place to list some good references on the topic.

Books

Swift in Depth by Tjeerd in 't Veen
Classic Computer Science Problems in Swift by David Kopec
Hello Swift! by Tanmay Bakshi
Exploring Swift by Craig Grummitt
iOS Development with Swift by Craig Grummitt
Beginning Swift by Kåre Morstøl and Rob Kerr
Mastering Swift 6 by Jon Hoffman
Swift Cookbook by Keith Moon, Chris Barker, Daniel Bolella and Nathan Lawlor
Learning Swift by Jonathon Manning, Paris Buttfield-Addison and Tim Nugent
SwiftUI in 1 Day by Sagar Kale
SWIFTUI - Quick Start by Ivor Online
Swift From Two to Three by Erica Sadun

Publications

Swift: A language for distributed parallel scripting by Michael Wilde, Mihael Hategan, Justin M. Wozniak, Ben Clifford, Daniel S. Katz and Ian Foster
Swift Logic for Big Data and Knowledge Graphs by Luigi Bellomarini, Georg Gottlob1, Andreas Pieris and Emanuel Sallinger
Swift a new programming language for development and education by Rostislav Fojtik
The Future of iOS Development: Evaluating the Swift Programming Language by Garrett Wells
The Swift Language from a Reverse Engineering Perspective by Malte Kraus and Vincent Haupert

Other

Cover Image by Pawel Czerwinski on Unsplash

Flashing a Xiaomi Mi A3 Phone

Mathieu K — Mon, 18 May 2026 10:00:00 +0000

This post is coming from my unpublished archive. It's quite an old one, but I think it would be interesting to share it. This is a summary of the different steps used to flash a Xiaomi Mi A3 phone and install another Android version (e.g. Lineage OS, Kali, /e/...). A part of the links are gone unfortunately, but I think the most important ones are still available. Have fun!

Bootstrapping

This installation was done on Ubuntu 21.04 due to compatibility with other system.

install latest android sdk from official website from https://developer.android.com/studio/#downloads
Download all required assets to flash your phone

Procedure

This image is open-source but was built by Harukey. This is a good method to root your android phone though.

Ensure ADB is correctly installed on your PC
Ensure Fastboot is correctly installed on your PC
Enable developer mode
Enable debugging throught USB
Connect your USB cable to your phone
Reboot your phone and press volume down
When fastboot prompt appears you can flash your phone with the recovery image

wget https://downloads.sourceforge.net/project/harukeys-roms/laurel/LineageOS18/LinageOSRecovery20210917.img
fastboot flash boot LinageOSRecovery20210917.img

Reboot into normal mode and check if everything was correctly set and configured. You should have your old Android version. (unplug your phone).

fastboot reboot

Reboot in recovery mode

adb reboot recovery

In recovery mode apply the latest partitions an update with ADB

adb sideload copy-partitions-20200903_1329.zip

Do a factory reset (present at the first menu page)
Apply another update, this time, with the lineageOS rom

wget https://downloads.sourceforge.net/project/harukeys-roms/laurel/LineageOS18/lineage-18.1-20211128-UNOFFICIAL-laurel_sprout.zip
adb sideload lineage-18.1-20211128-UNOFFICIAL-laurel_sprout.zip

Reboot in normal mode
Reboot in recovery mode

adb reboot recovery

Download and install Magisk

wget https://github.com/topjohnwu/Magisk/releases/download/v24.3/Magisk-v24.3.apk
cp Magisk-v24.3.apk Magisk-v24.3.zip
adb sideload Magisk-v24.3.zip

Reboot in normal mode and check if you can have access to LineageOS and Magisk.
Configure your system as desired (set developer mode and USB debugging).
Reboot in recovery mode
Download and install nethunter

adb sideload nethunter-2022.1-laurel_sprout-eleven-kalifs-full.zip

reboot your system and configure nethunter.

The procedure to install this image is available on xda-developer forum: https://forum.xda-developers.com/t/rom-11-unofficial-laurel_sprout-oss-lineageos-18-1.4240953/

Unbrick Xiaomi Mi A3

Shit happens sometime. Xiaomi Mi A3 can be bricked if you do a wrong configuration or don't follow the good process when trying to install LineageOS or any kind of alternative to android. Fortunately, this phone can easily be unbricked by using few tools. Here the requirement:

windows 10 (at this time, it's a requirement unfortunately)
qpsttool (version I used was 2.7.480 but the latest was 2.7.496)
service rom by @nullby

Other steps are explained in depth in Mi A3 unbrick guide by @nullby. It takes around 30/45 minutes to unbrick your phone, and start with a fresh version of android one installed.

Fixing a bootloop

You can use TWPRP image, in my case twrp-3.3.1-17-laurel_sprout-Q-mauronofrio.img worked. Go into advanced settings and "fix bootloop".

References and Resources

Cover Image by Eric Han on Unsplash

Raw VM Image Mounting with losetup

Mathieu K — Sun, 17 May 2026 10:00:00 +0000

I use Qemu/KVM for most of my custom virtual machine, and sometime, I need to do some backup or to check the filesystem from the host point of view. The process is quite simple, the virtual disk is used as a virtual storage device and then we mount the partition on the host. On FreeBSD, we use mdconfig, on OpenBSD we use vmconfig and on Linux, we are using losetup. Both of these commands have the same goal: allocate a special device pointing to a file present on a filesystem. Here an example with losetup.

First we want to mount the image /path/to/your/image.raw on a free losetup device (usually present in /dev/loop*). The --find flag will look for the next available loop device, the --show will print it to stdout and -P will reload the partition table.

# use available loop device, and attach image.raw to it
loop=$(losetup --find --show -P /path/to/your/image.raw)

Then, we can check if the partitions are present (or not). The attached device has been put into the loop variable.

# check the loop devices partition
ls -l ${loop}*

If you are using lvm (it was my case for this note), simply use lvscan command and automatically enable the logical volume found.

lvscan -a y

mount the logical volume on your and do what you have to do.

mount /dev/vg/lv /mnt

# Do your stuff here.

When you have done, you can simply umount the partition...

umount /mnt

... and finally detach the loop device.

losetup --detach ${loop}

Note: this procedure can be used only for raw qemu image. If you are using qcow format or another one, you will first need to convert it with qemu-img or use a tool like mount-qcow2-image.

Cover Image by Aleksandr Popov on Unsplash

Discovering Flutter Ecosystem and Community

Mathieu K — Sat, 16 May 2026 08:00:00 +0000

Flutter is a framework used by Dart, and most of the projects are using Dart because of Flutter. Most of the links you'll find here are also present in the Flutter Awesome List.

Sources

Official Flutter Git Repository

Books

Flutter Complete Reference 2.0 by Alberto Miola
Flutter Succinctly
Flutter UI Succinctly
Flutter Tutorials
Flutter Libraries We Love
Programming Flutter by Carmine Zaccagnino
Advanced Flutter - Build High-Performance, Cross-Platform Apps for Mobile, Web and Desktop by Sivaraj Selvaraj
Flutter App Development - How to Write for iOS and Android at Once by Rap Payne
Flutter in Action by Eric Windmill
Exploring Cross-Platform Development with Flutter, React Native, and Xamarin by Eric Windmill
Flutter Design Patterns and Best Practices: Build scalable, maintainable, and production-ready apps using effective architectural principles by Daria Orlova, Esra Kadah and Jaime Blasco
Flutter Cookbook: 100+ step-by-step recipes for building cross-platform, professional-grade apps with Flutter 3.10.x and Dart 3.x , Second Edition by Simone Alessandria
Flutter Projects: A practical, project-based guide to building real-world cross-platform mobile applications and games by Simone Alessandria
Building Games with Flutter: The ultimate guide to creating multiplatform games using the Flame engine in Flutter 3 by Paul Teale
Taking Flutter to the Web: Learn how to build cross-platform UIs for web and mobile platforms using Flutter for Web by Damodar Lohani
Managing State in Flutter Pragmatically: Discover how to adopt the best state management approach for scaling your Flutter app by Waleed Arshad
Mobile Deep Learning with TensorFlow Lite, ML Kit and Flutter: Build scalable real-world projects to implement end-to-end neural networks on Android and iOS by Anubhav Singh and Rimjhim Bhadani
Cross-Platform UIs with Flutter: Unlock the ability to create native multiplatform UIs using a single code base with Flutter 3 by Ryan Edge and Alberto Miola
Flutter and Dart Cookbook by Richard Rose
Flutter 3 From Scratch: A Practical Guide with Real Projects by Andres Cruz Yoris
Beginning Flutter 3.0 with Dart by Sanjib Sinha

Communication Channels

Gitter - Exchange channel.
r/FlutterDev - Reddit community by u/JaapVermeulen.
Discord - Discord server to discuss and get help by Pritykin.
Flutter Community - Central place for community made packages.
OpenFlutter - Make it easier 让 Flutter 更简单.
Hashnode - Read and write posts, participate in discussions or ask questions.

Courses

Publications

Application development using flutter by Aakanksha Tashildar, Nisha Shah, Rushabh Gala, Trishul Giri and Pranali Chavhan
THE ROLE OF FLUTTER IN MOBILE PROGRAMMING by Tursunbek SadriddinovichJalolov
Flutter in cross platform development: tools, performance and optimization by Väänänen Teemu
Assisting Novice Developers Learning in Flutter Through Cognitive-Driven Development by Ronivaldo Ferreira, Victor H. S. Pinto, Cleidson R. B. de Souza and Gustavo Pinto
Flutter Technology and Mobile Software Applications by Alexandru TĂBUȘCĂ, Cristina COCULESCU and Mironela PÎRNĂU
Low-code flutter application development solution by Atefeh Nirumand, Iván Alfonso and Jordi Cabot
The Flutter framework: Analysis in a mobile enterprise environment by Daniele PALUMBO
Flutter native performance and expressive ui/ux by Thanh Thanh
Examining the Usage of Flutter to Design a Yatch in 3D by Mohammed Kpannah Fahnbulleh, Xu SHUOBO
Flutter Mobile Application Development by Abhishek Samar Yadav
An Independent Learning System for Flutter Cross-Platform Mobile Programming with Code Modification Problems by Safira Adine Kinari, Nobuo Funabiki, Soe Thandar Aung, Khaing Hsu Wai, Mustika Mentari and Pradini Puspitaningayu
A freights status management system based on Dart and Flutter programming language by Ghusoon Idan Arb and Kadhum Al-Majdi
An image-based user interface testing method for Flutter programming learning assistant system by Soe Thandar Aung, Nobuo Funabiki, Lynn Htet Aung and Safira Adine Kinari.
A study of learning environment for initiating Flutter app development using Docker by Soe Thandar Aung, Nobuo Funabiki, Lynn Htet Aung, Safira Adine Kinari, Mustika Mentari and Khaing Hsu Wai
An implementation of web-based answer platform in the Flutter programming learning assistant system using Docker Compose by by Lynn Htet Aung, Soe Thandar Aung, Nobuo Funabiki, Htoo Htoo Sandi Kyaw and Wen-Chung Kao
The use of the flutter framework in the development process of hybrid mobile applications by Slavimir Stošović, Dušan Stefanović, Milan Bogdanović and Nikola Vukotić
Review on mobile application development based on flutter platform by Shreya A. Bhagat, Sakshi G. Dudhalkar, Prathmesh D. Kelapure, Aniket S. Kokare and Prof. Sudesh A. Bachwani
State management approaches in Flutter
Development of a large-scale flutter app by ALEJANDRO FERRERO LIGORRED
Design and Development of a Mobile Application Using Android Studio and Flutter by ALEJANDRO FERRERO LIGORRED
What Do Flutter Developers Ask About? An Empirical Study on Stack Overflow Posts by Anthony Wambua
Evaluation of Flutter framework time efficiency in context of user interface tasks by Damian Białkowski and Jakub Smołka
Flutter Development at Dorao by Nibrash Kazi Subah
Evaluation of flutter as a migration target by Joni Tuominen
Performance analysis of BLoC and provider state management library on flutter by Regawa Rama Prayoga, Ghifari Munawar, Rahil Jumiyani and Alifia Syalsabila
Mobile apps development: Towards incorporating regional and national languages in flutter app by Kamran Khan Rajput, Salahuddin Saddar, Hina Hussain, Umair Ayaz and Sadaquat Ali Ruk
Development of a Flutter module for ATHLETin by Ahmed Alakhir
Expanding Flutter Framework: generative art with alternative tools by Samuli Ristimäki
A flashcard mobile application development with Flutter by Tung Huynh
Design and development of attendance system application using android-based flutter by Giri Wahyu Wiriasto, Ramadan Wibi Surya Aji and Djul Fikry Budiman
Creating Flutter Apps from Native Android Apps by Yoonsik Cheon and Carlos Chavez
Opportunities with Flutter Development by Ambrish Dewangan, Bhavik Dindor, Shikhar Prakash Mahobia and Dr. Vinod Patidar
Flutter framework mobile application development of gamified automotive reseller team management by Edmund Johnson and Gunawan Wang
State Management and Software Architecture Approaches in Cross-platform Flutter Applications by Michał Szczepanik and Michał Kędziora
Integration of Flutter Framework in Real-Life Applications: Technical and Development Practices by YESIM UZUN
Evaluation of the Cross-Platform Framework Flutter Using the Example of a Cancer Counselling App by Leon Lovrić, Mahsa Fischer, Natalie Röderer and Alexander Wünsch
Flutter on Windows Desktop: a use case based study by Stefan Zindl
State Management Analyses of the Flutter Application by Avaa tiedosto
Master thesis: Integrating Wayland with Flutter by Alex-Manuel Rosca
Review and testing of plugins in Flutter for Android and IOS by Guido Albertengo
Over-The-Top (OTT) Media Application using Flutter by Linda M. John, Nehal Mistry, Ritu Patel and Dipti Nagvekar
Flutter: The future of application development? by Dieter Meiller
Design and development of a boundary alert system for fishermen by Zalak Thakrar and Atul Gonsai
The CARP mobile sensing framework - A cross-platform, reactive, programming framework and runtime environment for digital phenotyping by Jakob E. Bardram
Flutter in smart energy metering by Ms. Priyanka Ray
Quick sort and merge sort performance comparison in the flutter framework by Achmad Fahreza Alif Pahlevi
Mobile real-time object detection with Flutter by Daniel Kusnetsoff
Qrcode recognition on flutter framework mobile application implemented on entrance security system by Rosa Andrie Asmara, Rizky Putra Pradhana Budiman, Mungki Astiningrum, Brian Sayudha, Anik Nur Handayani and Cahya Rahmad
Using Flutter framework in multi-platform application implementation by Miroslav Mikolaj
Backdrop: An Exploration of Flutter by Austin D. Latture
Cloud-based cross-platform collaborative augmented reality in flutter by Lars Carius, Christian Eichhorn, Linda Rudolph, David A. Plecher and Gudrun Klinker
Development of a Platform-independent Renderer for the Rendering of OpenStreetMap Indoor Maps in Flutter by Julia Richter, Robin Thomas, David Lange, Thomas Graichen and Ulrich Heinkel
A Comprehensive Evaluation of Cloud Storage Access in Flutter Applications–Direct and API Based by A Javed and Z Ghalioun
Specifics of Designing and Construction of the System for Deep Neural Networks Generation by Oleksandr Mediakov and Taras Basyuk

Comparison

Comparison of flutter and react native platforms by Ekrem Gülcüoğlu, Ahmet Berk Ustun and Neşet Seyhan
Comparative analysis of scalable mobile app implementations: a case study with Flutter and Jetpack Compose by Bendinelli Marco
A Study of UI Construction in Android and Flutter: Comparative & Analysis by Donglan Zou1 and Mohamad Yusof Darus
Analyzing The Difference In Development Between Flutter And Native Android Development by Selena Goods
React Native vs. Flutter: A performance comparison between cross-platform mobile application development frameworks by G Tollin and L Marcus
An Empirical Evaluation of the User Interface Energy Consumption of React Native and Flutter by Erik Blokland
Native-like cross-platform mobile development: Multi-os engine & kotlin native vs flutter by Fayzullaev, Jakhongir
Comparative study of Android Native and Flutter app development by Hina Hussain, Kamran Khan, Faiza Farooqui, Dr. Qasim Ali Arain and Dr. Isma Farah Siddiqui
Performance analysis of Flutter applications vs. native iOS and Android apps by Evgenii Mozharovski
Challenges and solutions in cross-platform mobile development: a qualitative study of Flutter and React Native by Zhou Changkong
Performance comparison between react native and flutter by J Jagiello
Comparative analysis of UI construction and performance in android and flutter frameworks by Zou Donglan, Mohamad Yusof Darus, Maslina Abdul Aziz and Suzana Zambri
Comparative Analysis of React Native, Kotlin, and Flutter for Cross-Platform Mobile Development by Muhammad Usama Riaz
A comparative study of cross-platform mobile application development by Dongliang You
Comparison study of React Native Versus Flutter by Chintan Grover, Opal Jain, Aman Kaushik and Dr. Vinita Mathur
Evaluation of React Native and Flutter for cross-platform mobile application development by Elin Hjort
Cross-platform empirical analysis of mobile application development frameworks: Kotlin, react native and flutter by Dr Bhawna Suri, Dr Shweta Taneja, Isha Bhanot, Himanshi Sharma and Aanchal Raj
Cross platform mobile application development: a comparison study of React Native Vs Flutter by Fentaw Awel Eshetu
Comparative analysis between flutter and react native by Sharjeel Moqrab Khan, Aftab ul Nabi and Tahir Hussain Bhanbhro
A comparison of performance and looks between flutter and native applications by M Olsson

Usage Report

Utilization of Flutter Framework in Developing an Android-Based Cooking Recipe Application by Saniah Evatri Algadrie and Enny Itje Sela
Design, integration, and deployment of a Flutter–Firebase mobile commerce application at Berlian Tech by Labib Falah Athallah, Achmad Habib and Geri Kusnanto
E-Commerce application with Flutter framework by Adnan Naseer
Development of FASIH Application for the Badan Pusat Statistisk using flutter framework by R Prasetia and L R Maghfiroh
Building a fullstack mobile application with flutter and stable diffusion model by Luan Nguyen and Minh Hoang
CakeMeup App-Investigating the use of Flutter and Firebase for Developing E-Commerce Solution for a Cake Shop by Sprooha Athalye, Sanika Pawar, Gaurav Vaze, Sakshi Kadam and Manali Jangale
Reimbursement Application Using Rest API Methods and Android-Based Flutter Framework by Febby Renardi, NM Faizah and Lucky Koryanto
Implementation of crop disease detection system using flutter by Sunny Bhatt and Shivam Hingu
Design and Implementation of a Dental English Learning Application Using Flutter by
Yuta Otsuka, Tadahiro Higashinakao, Fumiko Nishio and Hiroshi Kono
Development of Mobile QR Warehouse Management Apllication Based on Flutter and Firebase by Irma Kartika Wairooy, Ignatius Dillwyn, Kevin Putra Yonathan and Andre Lay
Building a Worship Demand Application with The Waterfall Method Using Flutter Framework at The Al-Muttaqin Mosque Suralaga, Indonesia by Ahmad Subki, Muhamad Masjun Efendi and Erfan Wahyudi
Cross-platform campus news flutter app by David Osei Opoku
Developing a cross-platform mobile application for health data integration and capture from multi devices using Flutter by A Farmanesh
The Development Of A Mobile Application For Fruit Garden Tourism Information System In Sidoarjo Using Flutter by Mohammad Fadli Zaka1, Ade Eviyanti and Yulian Findawati
E-commerce application for local stores by Marya Anwar, Nuzhat Saba, Isha Admane, Saloni Khandelwal,
Vipul Tembhurne and Jyoti C. Kolte
Development of Course Booking System (Front-end & Back-end) Based on Mobile Application to Help Tutoring Elementary and Junior High School in Indonesia by Elsa Febrianti, Kamilia Luthfiyyah, Septi Hidayah, Aji SasongkoBurhanuddin Dirgantoro and Umar Ali Ahmad
SocialBook: a social network for sharing books built with Flutter and Firebase by Veselin Radoslavov Solenkov
Master thesis: Development of a Flutter module for ATHLETin by Stephan Bulut
Exploration of Modernity: Worship Reservation System at Rose of Sharon Church Salatiga Utilizing Flutter Framework by Davin Kurnia Hiuredhy and Henoch Juli Christanto
A Guided Self-Study Platform of Integrating Documentation, Code, Visual Output, and Exercise for Flutter Cross-Platform Mobile Programming by by Safira Adine Kinari, Nobuo Funabiki, Soe Thandar Aung and Htoo Htoo Sandi Kyaw
Development of a Flutter Mobile Application Using Spotify's Application Programming Interface
Design and development of mobile healthcare application prototype using flutter by Ragda Mamoun, Mohamed Nasor and Sahar H. Abulikailik
Online learning service application design using Flutter and Laravel framework by Yusuf Kurnia and Geraldi Aditya
Development of an Android Application for Recipe Management Using Flutter and API by Eko Sutono, Adam Muiz and Muhammad Hafiz Pratama
Development of Employee Attendance Management System using Flutter by Muhamad Faiz Akmal Mohamad Noor, Alif Faisal Ibrahim and Muhammad Nabil Fikri Jamaluddin
Implementation of Prototype Method on Online Fruit Store Service Application Using Flutter Framework by Wahyu Aji Suryantoro, Setiya Nugroho and Ardhin Primadewi
Designing an Android application using the software platform (FLUTTER) to alert the times of medical treatments (MT) by Layla Esam Mohammed and Shatha Abdullah Mohammed
Implementation of flutter in the development of an Android E-Commerce furniture application using the Sdlc Waterfall Method (A case study of mandiri furniture) by Umar Tsani Abdurrahman and Kuncoro Adin Nugraha
The Development of Mobile Application of Organ Donation Using Flutter by Kai Sian Ong

Security

The Security of Flutter's Architecture by MARO S ZELENAK
Secure Data Management: An Implementation of Advanced Encryption Standard in a Flutter-Based Notes App by Adetokunbo Abayomi Adenowo, Mary A. Adedoyin and Oluwasegun J. Adebiyi
Safety Widget by TOMÁŠ PSOTA
Enhancing Mobile Security through a Comprehensive Development Package by SaifAlmajd M. H. Almassri

Talks

Too many interesting talks can be found on Youtube, Flutter is way more popular than Dart itself. So, it was kinda hard to select few talks from the long list of choice I got.

Flutter Plugins - From Method Channels to Native Interop - Fluttercon EU 2025 by Dominik Roszkowski
Advanced Memory Management in Flutter - Fluttercon EU 2025 by Maher Jaafar
Let’s Talk About Memory Leaks In Dart And Flutter - Fluttercon EU 2025 by Majid Hajian
Hack My App: Learn Flutter Security by Breaking It - Fluttercon India 2025 by Gauri Panse
Flutter with WebRTC for real-time screen sharing - Fluttercon EU 2025 by Stanislav Sydorenko
Crash-Proof Flutter: Building Apps That Refuse to Die - Fluttercon EU 2025 by Pawan Kumar
Flutter Performance: No Silver Bullet, Only Smart Engineering - Fluttercon EU 2025 by Mikhail Zotyev
No touch. No gestures. Can you still build a Great UX? - Fluttercon EU 2025 by Vadym Pinchuk
Fearless Flutter Debugging: When All Else Fails, Hack the Tools! - Fluttercon EU 2025 by Mateusz Wojtczak
Using Dart FFI for Compute-Heavy Tasks in Flutter Apps - Robert | Fluttercon India 2025 by Robert Odrowaz-Sypniewski
Easy state restoration with Flutter - Fluttercon EU 2024 by Lucas Goldner
Exploring Static Code Analysis techniques in Flutter - Fluttercon EU 2024 by Daria Orlova
The art of Flutter testing - Fluttercon USA 2024 by Matt Carroll
Code Meets Art: Flutter for Creative Coding - Fluttercon EU 2024 by Roaa Khaddam
real world use cases in Flutter with GoRouter and GoRouterBuilder - Fluttercon EU 2024 by Max Weber
Building a package with assets - Fluttercon USA 2024 by Moritz Sümmermann & Daco Harkes
Realtime Communications with Flutter - Fluttercon EU 2024 by Simon Lightfoot
*Debugging performance issues with the Flutter DevTools - Fluttercon EU 2024
* by Alexandre Moureaux
**Securing Flutter Apps - droidcon London 2022 by Majid Hajian
KarmaApp - Why we choose flutter and Firebase - droidcon London 2022 by Sumith Damodaran
Flutter on Desktop: End to end from build to distribution - droidcon London 2022 by Teresa Wu
How Flutter Can Change the Future of Urban Communities - StrangeLoop 2021 by Edward Thornton
Material Theming with Flutter - Flutter Interact 2019 by Yasmine Evjen
Pragmatic State Management in Flutter - Google I/O 2019 by Filip Hracek and Matt Sullivan
Flutter for Business - Mobile World Congress 2019
Flutter Meets the Physical World at OSCON 2019 by Emily Fortuna and Matt Sullivan
Beyond Mobile: Material Design, Adaptable UIs, and Flutter - Google I/O 2019 by Anthony Robledo
Flutter: How we're building a UI framework for tomorrow at Google - StrangeLoop 2017 by Eric Seidel
*Flutter: The Best Way to Build for Mobile? -GOTO 2017
* by Kasper Lund

Conferences

Tools and Other Resources

Cover Image by Khara Woods on Unsplash

Using dio HTTP Client in Dart

Mathieu K — Fri, 15 May 2026 08:00:00 +0000

The low-level HTTP Client and a higher level implementation with the http package have been tested previously. This time, we will try another high level implementation of an HTTP client in Dart called dio. This client seems way more flexible than the previous clients, and embed great features. Furthermore, based on pub.dev, it looks like it's a popular choice. If you are interested to see some examples, you can look into example_dart/lib directory from their official repository. Anyway the first step to use it is to add it in the dependencies.

dart pub add dio
dart pub get

This time, instead of of using our own quick and dirty HTTP server using netcat or Python http.server module, let use the free HTTP Echo Server service. The idea is to simply creates some requests to this server and print the data returned.

As usual, the first step is to import the package in bin/httpcat.dart.

import 'package:dio/dio.dart';

Then, let create/configure a dio client object using the Dio class

final target = 'https://echo.free.beeceptor.com';   

final dio = Dio(
  BaseOptions(
    baseUrl: target,
    connectTimeout: const Duration(seconds: 5),
    receiveTimeout: const Duration(seconds: 5),
    contentType: null,
    followRedirects: true,
    maxRedirects: 2,
    persistentConnection: false,
    preserveHeaderCase: false,
    // receiveDataWhenStatusError; ...
    // requestEncoder: ...
    // responseDecoder: ...
    // responseType: ...                            
    // sendTimeout: ...                             
    // validateStatus: ...
    headers: {
      HttpHeaders.userAgentHeader: 'dio',
      'x-custom': 'custom'
    },
  )
);

The Dio class constructor accepts a BaseOptions object, containing the options to configure for the HTTP client. As you can already see in the previous snippet, plenty of attributes are available:

baseUrl: set the URL target as String. It must be a valid URL;
connectTimeout: the connection timeout out as int, when the client is opening a new connection to the remote server. Setting it to null or to Duration.zero will wait for the connection forever;
contentType: set the Content-Type HTTP header as a String;
followRedirects: a Boolean value to define if the client should follow the redirection returned by the server;
maxRedirects: the maximum number of redirection the client is allowed to follow defined as int;
persistentConnection: define if the client should use a persistent connection or not as boolean;
preserveHeaderCase: keep the header case unmodified during the request, defined as boolean;
queryParameters: set the query parameters of the request as Map<String, dynamic>;
receiveDataWhenStatusError: I will need to check the code for this one, but I assume when an error is returned, the data received is dropped, if we set this property to true, we should then be able to receive the data from the error;
receiveTimeout: set the timeout as a Duration for the data sent by the server;
requestEncoder: define a custom request encoder using RequestEncoder type as function callback. A way to use it, like defined in the tests:

dio.options.requestEncoder = (data, _) => Future.value(utf8.encode(data));
// or
dio.options.requestEncoder = (data, _) => utf8.encode(data);

responseDecoder: define a custom response decoder using ResponseDecoder type as function callback. It can be used like the following snippet from the test suite.

 dio.options.responseDecoder = (_, __, ___) => null;
// or
dio.options.responseDecoder = (_, __, ___) => Future.value('example');
// or
dio.options.responseDecoder = (_, __, ___) => 'example';

responseType: set the kind of response wanted by the client. For example, it can be set to ResponseType.stream, ResponseType.plain or ResponseType.bytes.
sendTimeout: set the client send timeout, when data is being uploaded to the server;
validateStatus: set a custom function callback defining if a request status is good or not, using ValidateStatus type. Here an example of usage from the test suite, the status parameter is an integer representing the HTTP status code.

validateStatus: (status) => true;
// or
validateStatus: (status) => false;

headers: configure a Map<String, dynamic> as HTTP Headers. Standardized HTTP Headers keys can be found in HttpHeaders class, defined as constants, for example acceptEncodingHeader contains the string accept-encoding. The code in charge of this part can be seen in dio/lib/src/headers.dart, it contains some constants;

After having created a Dio object, one can use different way to execute a request, but usually, two conventions can be used, using the baseUrl attribute set in the object, or pass it an Uri object.

GET Method
- dio.get(path) where path is a String
- dio.getUri(uri) where uri is an Uri object
HEAD Method
- dio.head(path) where path is a String
- dio.headUri(uri) where uri is an Uri object
POST Method
- dio.post(path) where path is a String
- dio.postUri(uri) where uri is an Uri object
PUT Method
- dio.put(path) where path is a String
- dio.putUri(uri) where uri is an Uri object
DELETE Method
- dio.delete(path) where path is a String
- dio.deleteUri(uri) where uri is an Uri object
PATCH Method
- dio.patch(path) where path is a String
- dio.patchUri(uri) where uri is an Uri object

So, before starting, the main() function will be modified to add a switch statement, and then, easily test each method from the CLI.

Future<int> main(List<String> arguments) async {
  if (arguments.length != 1) {
    print("Usage: httpcat TARGET");
    return 1;
  }

  switch (arguments[0]) {
    case "get": return getRequest();
    case "head": return headRequest();
    case "post": return postRequest();
    case "put": return putRequest(); 
    case "delete": return deleteRequest();
    case "patch": return patchRequest();
  }

  Uri? url = parseUrl(arguments[0]);
  if (url == null) return 1;  

  var ret = getUrl(url);
  return ret;
}

Then, the code will be called like that:

dart run ./bin/httpcat.dart get

Another quick modification is required to help seeing the answers from the server. Let create a function called printResponse() to print the data from the response.

void printResponse(Response response) {
  print({
    'status': response.statusCode,
    'status_msg': response.statusMessage,
    'uri': response.realUri,
    'headers': response.headers,
    'data': response.data,
  });
}

It will simply print to STDOUT the attributes available in a Response object.

GET Method

Probably one of the most used HTTP request is the GET one.

The GET method means retrieve whatever information (in the form of an entity) is identified by the Request-URI. If the Request-URI refers to a data-producing process, it is the produced data which shall be returned as the entity in the response and not the source text of the process, unless that text happens to be the output of the process.

-- RFC2616, section 9.3

getRequest() will use get() method to fetch /:

Future<int> getRequest() async {                    
  var response = await dio.get('/');   
  printResponse(response);                                            
  return 0;                                         
}

Let run this code to see what it will return from the CLI.

$ dart run bin/httpcat.dart get
{status: 200, status_msg: OK, uri: https://echo.free.beeceptor.com/, headers: connection: close
alt-svc: h3=":443"; ma=2592000
transfer-encoding: chunked
access-control-allow-origin: *
date: Wed, 13 May 2026 12:39:47 GMT
vary: Accept-Encoding
content-type: application/json
via: 1.1 Caddy
, data: {method: GET, protocol: https, host: echo.free.beeceptor.com, path: /, ip: 1.2.3.4:38247, headers: {Host: echo.free.beeceptor.com, User-Agent: dio, Accept-Encoding: gzip, Via: 1.1 Caddy, X-Custom: custom}, parsedQueryParams: {}}}

The answer from the server is printed alongside with the status and other information. The return data is a JSON object, containing my - modified - IP address, the headers and so on.

HEAD Method

The HEAD method is identical to GET except that the server MUST NOT return a message-body in the response. The metainformation contained in the HTTP headers in response to a HEAD request SHOULD be identical to the information sent in response to a GET request. This method can be used for obtaining metainformation about the entity implied by the request without transferring the entity-body itself. This method is often used for testing hypertext links for validity, accessibility, and recent modification.

-- RFC2616, section 9.4

headerRequest() function will use head() method and print the response.

Future<int> headRequest() async {
  var response = await dio.head('/');
  printResponse(response);
  return 0;
}

Let execute this function now.

$ dart run bin/httpcat.dart head
{status: 200, status_msg: OK, uri: https://echo.free.beeceptor.com/, headers: connection: close
alt-svc: h3=":443"; ma=2592000
access-control-allow-origin: *
date: Wed, 13 May 2026 12:48:48 GMT
vary: Accept-Encoding
content-type: application/json
via: 1.1 Caddy
, data: null}

No data is returned there, it's normal. HTTP Head method does not return any data, like defined in the specifications.

POST Method

The POST method is used to request that the origin server accept the entity enclosed in the request as a new subordinate of the resource identified by the Request-URI in the Request-Line. POST is designed to allow a uniform method to cover the following functions:

Annotation of existing resources;

Posting a message to a bulletin board, newsgroup, mailing list, or similar group of articles;

Providing a block of data, such as the result of submitting a form, to a data-handling process;

Extending a database through an append operation.

-- RFC2616, section 9.5

postRequest() function will use post() method from the client. A POST request can pass some data, to do that, the string test_data is passed to the data parameter. The contentType attribute must also be updated, because dio is intercepting the POST request and will set it to JSON. Let set this to text/plain.

Future<int> postRequest() async {
  dio.options.contentType = 'text/plain';
  var response = await dio.post(
    '/',
    data: 'test_data'
  );
  printResponse(response);
  return 0;
}

We can now invoke the command:

$ dart run bin/httpcat.dart post
{status: 200, status_msg: OK, uri: https://echo.free.beeceptor.com/, headers: connection: close
alt-svc: h3=":443"; ma=2592000
transfer-encoding: chunked
access-control-allow-origin: *
date: Wed, 13 May 2026 14:27:11 GMT
vary: Accept-Encoding
content-type: application/json
via: 1.1 Caddy
, data: {method: POST, protocol: https, host: echo.free.beeceptor.com, path: /, ip: 1.2.3.4:40459, headers: {Host: echo.free.beeceptor.com, User-Agent: dio, Content-Length: 9, Accept-Encoding: gzip, Content-Type: text/html, Via: 1.1 Caddy, X-Custom: custom}, parsedQueryParams: {}, rawBody: test_data}}

As you can see, the data we have sent is stored in the rawBody field. POST, PUT and PATCH methods are really important, and another publication on this topic will be required, especially for the serialization part.

PUT Method

The PUT method requests that the enclosed entity be stored under the supplied Request-URI. If the Request-URI refers to an already existing resource, the enclosed entity SHOULD be considered as a modified version of the one residing on the origin server. If the Request-URI does not point to an existing resource, and that URI is capable of being defined as a new resource by the requesting user agent, the origin server can create the resource with that URI.

-- RFC2616, section 9.6

The PUT method is similar to the POST method. Here a putRequest() function is created, the content type is updated and the string test_data is sent to the server via the post() method.

Future<int> putRequest() async {
  dio.options.contentType = 'text/plain';
  var response = await dio.put(
    '/',
    data: 'test_data'
  );
  printResponse(response);
  return 0;
}

DELETE Method

The DELETE method requests that the origin server delete the resource identified by the Request-URI. This method MAY be overridden by human intervention (or other means) on the origin server. The client cannot be guaranteed that the operation has been carried out, even if the status code returned from the origin server indicates that the action has been completed successfully. However, the server SHOULD NOT indicate success unless, at the time the response is given, it intends to delete the resource or move it to an inaccessible location.

-- RFC2616, section 9.7

The DELETE method is closer to the GET method. deleteRequest() function is created, and the delete() method is called.

Future<int> deleteRequest() async {
  var response = await dio.delete('/');
  printResponse(response);
  return 0;
}

Here the returned data:

$ dart run bin/httpcat.dart delete
{status: 200, status_msg: OK, uri: https://echo.free.beeceptor.com/, headers: connection: close
alt-svc: h3=":443"; ma=2592000
transfer-encoding: chunked
access-control-allow-origin: *
date: Wed, 13 May 2026 14:32:49 GMT
vary: Accept-Encoding
content-type: application/json
via: 1.1 Caddy
, data: {method: DELETE, protocol: https, host: echo.free.beeceptor.com, path: /, ip: 1.2.3.4:40520, headers: {Host: echo.free.beeceptor.com, User-Agent: dio, Accept-Encoding: gzip, Via: 1.1 Caddy, X-Custom: custom}, parsedQueryParams: {}}}

PATCH Method

The PATCH method requests that a set of changes described in the request entity be applied to the resource identified by the Request-URI. The set of changes is represented in a format called a "patch document" identified by a media type. If the Request-URI does not point to an existing resource, the server MAY create a new resource, depending on the patch document type (whether it can logically modify a null resource) and permissions, etc.

-- RFC5789, section 2

The PATCH method is a recent addition to HTTP, but act similarly like the PUT and POST methods. patchRequest() function is created, the content type is updated and patch() method is called.

Future<int> patchRequest() async {
  dio.options.contentType = 'text/plain';
  var response = await dio.patch(
    '/',
    data: 'test_data'
  );
  printResponse(response);
  return 0;
}

Again, here the result:

$ dart run bin/httpcat.dart patch
{status: 200, status_msg: OK, uri: https://echo.free.beeceptor.com/, headers: connection: close
alt-svc: h3=":443"; ma=2592000
transfer-encoding: chunked
access-control-allow-origin: *
date: Wed, 13 May 2026 14:33:28 GMT
vary: Accept-Encoding
content-type: application/json
via: 1.1 Caddy
, data: {method: PATCH, protocol: https, host: echo.free.beeceptor.com, path: /, ip: 1.2.3.4:34690, headers: {Host: echo.free.beeceptor.com, User-Agent: dio, Content-Length: 9, Accept-Encoding: gzip, Content-Type: text/plain, Via: 1.1 Caddy, X-Custom: custom}, parsedQueryParams: {}, rawBody: test_data}}

Downloading Files

dio is also offering two helpers to download file and store save locally via download() and downloadURI() methods. Let try to download the latest official OpenBSD banner locally using the downloadUri() method this time.

Future<int> downloadRequest() async {
  final url = Uri.parse('https://www.openbsd.org/images/puffy78.gif');
  var response = await dio.downloadUri(
    url,
    (_) => './puffy78.gif',
  );
  printResponse(response);
  return 0;
}

downloadRequest() function is creating a new Uri object from a valid URL, in this case, from the OpenBSD website. Then, the url and an anonymous function is passed to the downloadUri() method. Finally, the response is displayed on STDOUT and the function return 0.

The anonymous function is taking one argument, a Headers object and must return a String representing where the file will be stored.

Let execute that:

$ dart run bin/httpcat.dart download
{status: 200, status_msg: OK, uri: https://www.openbsd.org/images/puffy78.gif, headers: content-type: image/gif
connection: close
last-modified: Wed, 22 Oct 2025 07:18:46 GMT
date: Thu, 14 May 2026 03:50:12 GMT
server: OpenBSD httpd
content-length: 56669
redirects: 0
uri: https://www.openbsd.org/images/puffy78.gif
, data: Instance of 'ResponseBody'}

$ ls -lhart puffy78.gif 
-rw-rw-r-- 1 user user 56K 14 mai   05:50 puffy78.gif

It seems the function correctly downloaded the file, and when opening it with feh, the gif looks good.

What about OPTIONS, TRACE and/or custom HTTP Methods?

At this time, OPTIONS and TRACE HTTP methods have not been implemented in dio, but it could be possible to craft them using the request() method and setting the method attribute from the Options class to the correct String.

OPTIONS method can be useful when using CORS and then, can be sometime used by developers or administrator to check if everything is right.

The OPTIONS HTTP method requests permitted communication options for a given URL or server. This can be used to test the allowed HTTP methods for a request, or to determine whether a request would succeed when making a CORS preflighted request.

-- Mozilla Developer website

This time, the request() method can be used. This one permits to modify the Options object containing the method attribute, defined as String.

Unfortunately, the echo service does not support OPTIONS nor TRACE HTTP method, we will need to use nc -kl 8080 for this test.

Future<int> customRequest(String method) async {
  dio.options.method = method;
  var response = await dio.request('http://localhost:8080/');
  printResponse(response);
  return 0;
}

We are not really interested of the response here, but more about what the client will send to the server. From the netcat side, here the raw output:

$ nc -kl 8080
OPTIONS / HTTP/1.1
user-agent: dio
connection: close
x-custom: custom
accept-encoding: gzip
content-length: 0
host: localhost:8080

The client is correctly using the method we have manually set. The same procedure can also be applied for the TRACE method.

What about HTTP/2?

HTTP/2 is more a recent protocol upgrading HTTP/1.1 by adding multiplexed connection and use binary format (instead of text) for headers.

HTTP/2 provides an optimized transport for HTTP semantics. HTTP/2 supports all of the core features of HTTP/1.1 but aims to be more efficient in several ways. The basic protocol unit in HTTP/2 is a frame (Section 4.1). Each frame type serves a different purpose. [...] Multiplexing of requests is achieved by having each HTTP request/response exchange associated with its own stream. [...] Flow control and prioritization ensure that it is possible to efficiently use multiplexed streams. [...] HTTP/2 adds a new interaction mode whereby a server can push responses to a client. [...] Because HTTP header fields used in a connection can contain large amounts of redundant data, frames that contain them are compressed.

-- RFC7549, section 2

What kind of advantage to use HTTP/2 instead of HTTP/1.1? Better performance, especially when it comes to send multiple requests in parallel. Unfortunately, it does not fix everything, like slow connections issues, or a way for the server to easily close a connection, those issues are still relevant with HTTP/2, mainly due to the network layer above it: TCP.

Most - if not all - modern HTTP servers are supporting it (nginx, apache2, cowboy...) , the same happens for modern clients. dio needs the http2_adapter plugin to support this protocol though.

dart pub add dio_http2_adapter
dart pub get

import 'package:dio_http2_adapter/dio_http2_adapter.dart';

Future<int> http2Request() async {
  dio.httpClientAdapter = Http2Adapter(
    ConnectionManager(idleTimeout: const Duration(seconds: 10)),
  );
  var response = await dio.get('/');
  printResponse(response);
  return 0;
}

$ dart run bin/httpcat.dart http2
{status: 200, status_msg: null, uri: https://echo.free.beeceptor.com/, headers: access-control-allow-origin: *
alt-svc: h3=":443"; ma=2592000
content-type: application/json
date: Thu, 14 May 2026 07:52:12 GMT
vary: Accept-Encoding
via: 1.1 Caddy
, data: {method: GET, protocol: https, host: echo.free.beeceptor.com, path: /, ip: 1.2.3.4:34174, headers: {Host: echo.free.beeceptor.com, User-Agent: dio, Via: 2.0 Caddy, X-Custom: custom, Accept-Encoding: gzip}, parsedQueryParams: {}}}

I'm not really sure if it correctly using HTTP/2 protocol while using the echo service. Let add a logging feature to see if we can know a bit more there. To do that, we can add a new LogInterceptor object in the current interceptor queue.

Future<int> http2Request() async {
  dio.httpClientAdapter = Http2Adapter(
    ConnectionManager(idleTimeout: const Duration(seconds: 10)),
  );
  dio.interceptors.add(
    LogInterceptor(
      logPrint: (o) => print(o.toString()),
      request: true,
      requestBody: true,
      requestHeader: true,
      requestUrl: true,
      responseBody: true,
      responseHeader: true,
      responseUrl: true,
    )
  );
  var response = await dio.get('/');
  printResponse(response);
  return 0;
}

Execute the code a second time with the logs now:

$ dart run bin/httpcat.dart http2
*** Request ***
uri: https://echo.free.beeceptor.com/
method: GET
responseType: ResponseType.json
followRedirects: true
persistentConnection: false
connectTimeout: 0:00:05.000000
sendTimeout: null
receiveTimeout: 0:00:05.000000
receiveDataWhenStatusError: true
extra: {}
headers:
 user-agent: dio
 x-custom: custom
data:
null

*** Response ***
uri: https://echo.free.beeceptor.com/
statusCode: 200
headers:
 access-control-allow-origin: *
 alt-svc: h3=":443"; ma=2592000
 content-type: application/json
 date: Thu, 14 May 2026 08:00:36 GMT
 vary: Accept-Encoding
 via: 1.1 Caddy
Response Text:
{"method":"GET","protocol":"https","host":"echo.free.beeceptor.com","path":"/","ip":"1.2.3.4:50442","headers":{"Host":"echo.free.beeceptor.com","User-Agent":"dio","Via":"2.0 Caddy","X-Custom":"custom","Accept-Encoding":"gzip"},"parsedQueryParams":{}}

{status: 200, status_msg: null, uri: https://echo.free.beeceptor.com/, headers: access-control-allow-origin: *
alt-svc: h3=":443"; ma=2592000
content-type: application/json
date: Thu, 14 May 2026 08:00:36 GMT
vary: Accept-Encoding
via: 1.1 Caddy
, data: {method: GET, protocol: https, host: echo.free.beeceptor.com, path: /, ip: 1.2.3.4:50442, headers: {Host: echo.free.beeceptor.com, User-Agent: dio, Via: 2.0 Caddy, X-Custom: custom, Accept-Encoding: gzip}, parsedQueryParams: {}}}

Yeah, still not really sure if we are using HTTP/2 there. Let use netcat instead, just to be certain.

$ nc -kl | hexdump -C
00000000  50 52 49 20 2a 20 48 54  54 50 2f 32 2e 30 0d 0a  |PRI * HTTP/2.0..|
00000010  0d 0a 53 4d 0d 0a 0d 0a  00 00 06 04 00 00 00 00  |..SM............|
00000020  00 00 02 00 00 00 00 00  00 5b 01 04 00 00 00 01  |.........[......|
00000030  00 07 3a 6d 65 74 68 6f  64 03 47 45 54 00 05 3a  |..:method.GET..:|
00000040  70 61 74 68 01 2f 00 07  3a 73 63 68 65 6d 65 04  |path./..:scheme.|
00000050  68 74 74 70 00 0a 3a 61  75 74 68 6f 72 69 74 79  |http..:authority|
00000060  09 6c 6f 63 61 6c 68 6f  73 74 00 0a 75 73 65 72  |.localhost..user|
00000070  2d 61 67 65 6e 74 03 64  69 6f 00 08 78 2d 63 75  |-agent.dio..x-cu|
00000080  73 74 6f 6d 06 63 75 73  74 6f 6d 00 00 00 00 01  |stom.custom.....|
00000090  00 00 00 01 00 00 04 03  00 00 00 00 01 00 00 00  |................|

As you can see, HTTP/2.0 is printed on the netcat side and a part of the data received are in binary format, not text like in HTTP/1.1 version. So, it looks good!

Other examples can be found in dio_http2_adapter README.md and in the example/ directory.

What about HTTP/3?

HTTP/3 provides a transport for HTTP semantics using the QUIC transport protocol and an internal framing layer similar to HTTP/2. Once a client knows that an HTTP/3 server exists at a certain endpoint, it opens a QUIC connection. QUIC provides protocol negotiation, stream-based multiplexing, and flow control. Within each stream, the basic unit of HTTP/3 communication is a frame. Each frame type serves a different purpose. Multiplexing of requests is performed using the QUIC stream abstraction. Each request-response pair consumes a single QUIC stream. Streams are independent of each other, so one stream that is blocked or suffers packet loss does not prevent progress on other streams. [...] As in HTTP/2, request and response fields are compressed for transmission.

-- RFC9114, Section 2

Unfortunately, it seems QUIC and HTTP/3 are not currently supported everywhere, it will depend of the platform used. The package pure_dart_quic seems to be the solution here. I don't think the solution was currently very stable, and in fact, the addition of this protocol in nginx for example is from the 1.25.0 version (released May 2023). The cowboy server is also offering its implementation but not by default since the beginning of 2025 (version 2.13.0). So, it will be the main subject for another article, outside of dio (or perhaps to extend it).

Want More About `dio`?

If you are here, that means you enjoyed these notes... And you probably want to know even more about dio. Perhaps having a small glimpse of its usage in real world? You can easily find few open source projects using it:

Diohub: open-source unofficial GitHub mobile client
Flutter Crypto APP: Complete Flutter Application with Riverpod & Freezed + Dio for API REST.
Vexana: Vexana is easy to use network process with dio.
randomuser: Example project to present Dio, RxDart and Bloc
Flutter User Management App with Multi-Source Backend Support: Flutter-based user management application that demonstrates full CRUD (Create, Read, Update, Delete) operations. The app interacts with a RESTful API to manage users and their associated data, including posts, todos, and comments.
youtube_video: a Flutter application built to demonstrate the use of Modern development tools with best practices implementation like Clean Architecture, Modularization, Dependency Injection, BLoC, etc.

And to end this section, a list of interesting dio plugins:

dio_file_uploader: A en_file_uploader plugin to handle the file upload using dio package.
datadome_flutter_dio: provides an interceptor that filters and validates all requests to ensure your app networking layer is protected with DataDome.
dio_builder: a builder pattern for configuring and creating instances of the Dio HTTP client.
embrace_dio: enable the embrace plugin to capture network requests made with the Dio package.
alice_dio: Alice is an HTTP Inspector tool for Flutter which helps debugging http requests.
dio_http_logger: A powerful network interceptor for Dio, providing comprehensive logging of requests, responses and errors.
dio_retry_plus: A plugin for dio that retries failed requests.
chunked_uploader: A plugin to upload files to server in chunks.
oauth_dio: A customizable oauth client with token storage and interceptors for dio.
dio_ansi_logger: A beautiful, Postman-style Dio interceptor that logs HTTP requests and responses with ANSI colors, structured formatting, and fully customizable themes.
dio_cache: A plugin for dio that caches responses in a database for better optimization and offline data access.
pl_api_helper: pl_api_helper is a Flutter plugin that simplifies API calls, caching, and data management with support for both Dio and HTTP clients.

References and Resources

Cover Image by Ilona Ivanova on Unsplash

Extracting Publication Data from Substack

Mathieu K — Thu, 14 May 2026 08:00:00 +0000

If you have a substack account, like me, you are probably wondering how the articles are stored and how to fetch them manually, right? Well, it will be a short post trying to explain that.

The end-point to get the JSON object describing the post is /api/v1/drafts/${post_id} where post_id is an integer (a reference to your post).

curl https://${account_name}.substack.com/api/v1/drafts/${post_id}

The headers used for doing this request:

Accept: */*
Accept-Encoding: gzip, delfate, br, zstd
Accept-Language: en-US
Cookie: ${your_cookie}
Priority: u=1, i
sec-ch-ua: 
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Linux"
sec-fetch-dest: 
sec-fetch-mode: cors
sec-fetch-site: same-origin
sec-gpc: 1
User-Agent: ${your_user_agent}

If successful, a JSON should be returned containing a huge amount of fields. Your post is stored in draft_body as stringified JSON.

{
   ...
   "draft_body": "",
   ...
}

The body of your post can be extracted now, it's a JSON object using the SubstackPost Document Model, if you want more information about it, you can check the DeepWiki page on that or Substack document format from can3p/substack-api-notes.

Anyway, I need to extract few values from that recently, I thought maybe it would help someone one day.

Cover Image by Tim Wildsmith on Unsplash

Using the http Package in Dart

Mathieu K — Wed, 13 May 2026 08:00:00 +0000

The previous publication was talking about the low-level HTTP Client interface HttpClient offered by dart:io. This package does the job, but even the documentation recommends to use package:http instead. This is a higher-level implementation dealing with all the portability for different platforms and adding a lot of cool features. Instead of recreating a new project from scratch, we will improve the previous one created: httpcat.

First, we need to know how to install a package with Dart. Using an external package requires adding a new dependency in pubspec.yaml file present at the root of the project.

name: httpcat
description: A sample command-line application.
version: 1.0.0
# repository: https://github.com/my_org/my_repo

environment:
  sdk: ^3.11.5

# Add regular dependencies here.
dependencies:
  path: ^1.9.0
  http: ^1.6.0

dev_dependencies:
  lints: ^6.0.0
  test: ^1.25.

The new line added is http: ^1.6.0 in the dependencies section. The command dart pub get needs to be called to fetch the package locally.

Another method is to use dart pub add subcommand:

dart pub add http:^1.6.0

This command will directly adds the dependency in pubspec.yaml without editing with a text editor (and valid it at the same time). Now, we can import this package in our program.

Importing `http` package

To import a package in Dart, import keyword followed by the package URL is needed. The package can also be locally renamed using as keyword followed by the local namespace to use. In our case, importing http package will look like that:

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

From Dart specification:

An import specifies a library whose exported namespace (or a subset of its mappings) is made available in the current library. An import specifies a URI s where the declaration of an imported library is to be found. It is a compile-time error if the specified URI of an import does not refer to a library declaration. The current library is the library currently being compiled. The import modifies the namespace of the current library in a manner that is determined by the imported library and by the optional elements of the import. [...] Imports may be deferred or immediate. [...] An immediate import directive I may optionally include a prefix clause of the form as id used to prefix names imported by I. In this case we say that id is an import prefix, or simply a prefix.
-- Latest Dart (3.0+) Programming Language Specification Draft Chapter 19, page 218

Refactoring `httpcat`

A big part of httpcat will be rewritten, even if the logic will stay the same. Let start with getUrl().

Future<int> getUrl(Uri url) async {
  try {
    var response = await http.get(url);
    print(response.body);
    return 0;
  }
  catch (e) {
    print("outch. something bad happened. $e");
    return 1;
  }
}

getUrl() function will now accept an already parsed String as Uri. Indeed, http.get() method is acception Uri object as parameter, so, instead of doing all the parsing logic inside the same function, this already parsed string can be passed directly to it. getUrl() will also return an int based on the result of the http request, in case of success, it will return 0 (zero), in case of failure, it will return 1. Because this function is asynchronous, the returned value will be wrapped around a Future.

Uri? parseUrl(String str) {
  try {
    var url = Uri.parse(str);
    if (url.scheme.isEmpty) url = url.replace(scheme: 'http');
    if (url.host.isEmpty) url = url.replace(host: 'localhost');
    if (url.port == null) url = url.replace(port: 80);
    if (url.path.isEmpty) url = url.replace(path: "/");
    return url;
  }
  catch (e) {
    print("bad url");
    return null;
  }
}

parseUrl() is a new function in charge of parsing a String. In case of success it will return an Uri object and in case of failure it will return null. We will have a small discussion at the end of this article about null safety.

Future<int> main(List<String> arguments) async {
  if (arguments.length != 1) {
    print("Usage: httpcat TARGET");
    return 1;
  }

  Uri? url = parseUrl(arguments[0]);
  if (url == null) return 1;

  var ret = getUrl(url);
  return ret;
}

main() function - our entry-point - will now be asynchronous because we are returning getUrl() value.

The final result can be seen below. Dealing with null annoys me a lot, it's a bit like dealing with errors in Go, and I hate that. I suppose dartz or another package implementing functional programming features could fix that.

import 'package:httpcat/httpcat.dart' as httpcat;
import 'dart:io';
import 'dart:async';
import 'dart:convert';
import 'dart:core';
import 'package:http/http.dart' as http;

Future<int> main(List<String> arguments) async {
  if (arguments.length != 1) {
    print("Usage: httpcat TARGET");
    return 1;
  }

  Uri? url = parseUrl(arguments[0]);
  if (url == null) return 1;

  var ret = getUrl(url);
  return ret;
}

Uri? parseUrl(String str) {
  try {
    var url = Uri.parse(str);
    if (url.scheme.isEmpty) url = url.replace(scheme: 'http');
    if (url.host.isEmpty) url = url.replace(host: 'localhost');
    if (url.port == null) url = url.replace(port: 80);
    if (url.path.isEmpty) url = url.replace(path: "/");
    return url;
  }
  catch (e) {
    print("bad url");
    return null;
  }
}

Future<int> getUrl(Uri url) async {
  try {
    var response = await http.get(url);
    print(response.body);
    return 0;
  }
  catch (e) {
    print("outch. something bad happened. $e");
    return 1;
  }
}

The code is still dirty, but it works. If someone is passing bad URL, it can fail. Let start a small HTTP server using Python HTTP server module.

mkdir /tmp/t
cd /tmp/t
python -m http.server

Now, let have some fun with this program.

$ dart run bin/httpcat.dart 'http://localhost:8000'
<!DOCTYPE HTML>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Directory listing for /</title>
</head>
<body>
<h1>Directory listing for /</h1>
<hr>
<ul>
</ul>
<hr>
</body>
</html>

$ dart run bin/httpcat.dart 'localhost:8080'
outch. something bad happened. Invalid argument(s): Unsupported scheme 'localhost' in URI localhost://localhost/8080

As you can see, the first call is returning what we want, the HTML page returned by default by the HTTP server. But when calling it a second time without the scheme defined in the URL, it fails. So, that's a bug we will fix in another iteration.

Asynchronous call

A quick note on asynchronous programming, more publications will come on this part of Dart, but you can see that part as a kind of reminder. Let start with the - very small - concurrency section from Dart specification.

Dart code is always single threaded. There is no shared-state concurrency in Dart. Concurrency is supported via actor-like entities called isolates.
-- Latest Dart (3.0+) Programming Language Specification Draft Chapter 6, page 15

The Dart VM is dealing with concurrency via an event loop on one thread. Applications require to do tasks in parallel though, and then, asynchronous properties. This is where the async-await enters the game with the help of Futures and Streams.

For now, if you want to know more about that, you can check these references:

`null` safety

Well. One reason I really love and enjoy coding in Erlang is because of the way it deals with errors and exceptions. A function in Erlang will always returns a values, and those values can be "tagged" with ok or error or any other term you want. It's not the case by default with Dart and many other "modern" languages. For the ones who don't know Erlang (or Elixir), here an example:

my_function() ->
  {ok, "value"}.

callme() ->
  case my_function() of
    {ok, V} ->
      io:format("~p~n", V);
    _ ->
      io:format("nothing~n");
  end.

Dealing with null in Dart is a long topic, and while trying to find a solution by myself, I was, in fact, recreating a kind of Maybe Monad. Someone else already this this job with the maybe_just_nothing package. The idea here is to delegate most of the null check to an object, and use functional programming paradigm.

Another solution is to create a solution similar to the one used by Erlang by using records as a tuple. The tag part can be defined as an enum.

enum Tag { ok, error }

A function could then return a record containing a Tag and any kind of data.

(Tag, String) my_function() {
  return (Tag.ok, "value");
}

One can then use some pattern matching like in Erlang with the help of the switch statement.

void callme() {
  switch (my_function()) {
    case (Tag.ok, var v):
      print("ok $v");
    default:
      print("error");
  }
}

I'm not really sure this is good idea to use this method, if it's portable and how the switch expression can deal with a long list of different patterns (performance issue?).

The Dart documentation offers a great documentation about the null safety issues, and a dev.to author called @jige2025 created two publications (part-1 and part-2) on this topic. Anyway, a full publication will be made to summarize that, so, if you want to know more, please check these references:

Cover Image by Pavan Trikutam on Unsplash

Discovering Dart Ecosystem and Community

Mathieu K — Tue, 12 May 2026 08:51:00 +0000

Like any language, having a list of resources to find examples and best practices is always nice to have. Unfortunately, Dart is mostly used for/with Flutter, and lot of publications are directly showing Flutter examples instead of talking about Dart itself. Anyway, this not a complete list, only the things I've found on the web and started to check.

Official Dart Website: this is the main entry-point for any Dart developpers, from beginners to advanced.
Official Dart Tutorials: First time using Dart? That's the place to be.
Official Dart documentation: If something goes wrong, or if you want to know what a class, method or attribute is doing, this is the best place.
Official Dart Announcement on Google Group: all important news regarding Dart are published here, useful for the new releases and other critical information about the language.
Official Dart Blog: One can found many interesting information about the language and the community.
Official Dart Package Website: the first place to check if you want to use a specific feature and you don't have time to create it from scratch.
Official Dart API documentation: wants to know more about Dart API and SDK? you'll probably find your answer here.
Official Dart Language Specification: Dart Language has been specified, and the syntax and other rules have been documented.
Effective Dart (Official Dart Best Practices): the official best practice guide from Dart developers.
Official List of Companies using Dart: Want to work with Dart (or Flutter), this page can give you some hints about which companies are using this language in production.

Sources

Having access to open-source projects and official source code is always useful. If you want to learn Dart, you should start by reading the tests and then try to understand the code tested.

Official Dart Github Profile: the page listing all official project supported by Dart.
Official Dart SDK Repository: Dart SDK source code.
Official Dart Language Specification Repository: Dart language specification source code

Interesting Packages

A long list of packages had my attention while I was learning Dart/Flutter, and while I was reading books/publications. Here few of them

actors: an implementation of the Actor Model in Dart.
beam_vm: a plugin to embed an Erlang VM on Android and iOS.
cryptography: cryptographic algorithms implemented in Dart.
dart_amqp: AMQP implementation in Dart.
cbor: an implementation of CBOR/RFC8949 in Dart.
dartzmq: an implementation of zeromq in Dart.
dio: an advanced HTTP networking tool.
drift: a persistent storage layer using SQLite.
ecdsa: an implementation of ECDSA.
ed25519_edwards: an implementation of ed25519 elliptic curve.
flame: a game engine based on dart/flutter.
fpdart (github): Functional Programming in Dart.
oauth2: an OAuth2 client.
postgres: an interface to PostgreSQL database.
pure: add support for many functional programming features, like composition, pipes, memoization and recursion.
sqlite3: an interface to sqlite3 database.
state_machine: Implementation of a finite state machine in Dart.

Books

Dart is a young language, and I was not expecting to find lot of books... I was wrong. Here a quite complete list of all available books.

Dart Apprentice: Fundamentals by the Kodeco Team
Dart Apprentice: Beyond the Basics by Jonathan Sande and the Kodeco Team
Data Structures & Algorithms in Dart by Jonathan Sande and the Koneco Team
The Art of Dart: Master the Dart Programming Language by Kenneth Choi
Dart in Action by Chris Buckett
Mastering DART: Master the art of programming high-performance applications with Dart by Sergey Akopkokhyants
Dart By Example by David Mitchell
Learning Dart by Ivo Balbaert
Dart Essentials by Martin Sikora
Dart Cookbook by Ivo Balbaert
What is Dart? by Kathy Walrath and Seth Ladd
The Dart Programming Lagnuage by Gilad Bracha
Dart Scalable Application Development by Davy Mitchell, Sergey Akopkokhyants and Ivo Balbaert
Dart Up and Running by Kathy Walrath and Seth Ladd
Web Programming with dart by Moises Belchin and Patricia Juberias
Quick Start Guide to Dart Programming by Sanjib Sinha
Dart for Absolute Beginners by David Kopec

Communication Channels

Here a list of the main/official communication channels used by Dart developers - excluding Flutter ones.

StackOverflow: asking/answering questions.
Official Discord Server: a place to chat with Dart developers.
Dart on Reddit: a subreddit for Dart developers.
Dart on dev.to: Another place to read publication about Dart.
Dart Official X/Twitter Account: The official Dart X/Twitter account.
Dart Official Bluesky Account: The official Dart BlueSky account.

Community

A small list of developers using Dart. Most of them are coming from public talks.

Anna Leushchenko (medium, mastodon, dev.to, github).
Björn Sperber (github).
Bob Nystrom (github, blog).
Chris Swan (website, blog, mastodon, linkedin, bluesky).
Csongor Vogel (github, x/twitter, linkedin, instagram, youtube).
Erik Ernst (github, medium).
Eric Saidel (blog, github, mastodon, linkedin, x/twitter).
Evgeny Kot (github, x/twitter).
Filipe A. Barroso (dev.to, medium, github, linkedin).
Gilad Bracha (website, blog).
Jaime Wren (github, medium).
Kasper Lund (github).
Karl Krukow (github, blog, x/twitter).
Kevin Moore (github, website, bluesky, medium).
Kresten Krab Thorup (github, x/twitter, blusky, mastodon).
Leaf Peterson (github, website, x/twitter).
Majid Hajian (website, medium, github, blog, x/twitter, linkedin).
Miguel Beltran (github, website, bluesky).
Mike Diarmid (github, mastodon, x/twitter, bluesky, linkedin, medium).
Norbert Kozsir (website, blog, x/twitter, github, medium).
Pascal Welsch (website, github, mastodon, medium).
Randal Schwartz (github, medium, dev.to, mastodon).
Razvan Cristian Lung (github, linkedin, medium).
Roman Jaquez (medium, youtube, github).
Simon Binder (website, github, mastodon).
Vadym Pinchuk (github, medium, linkedin, instagram).
Vyacheslav "Slava" Egorov (blog, medium, github, Substack, Mastodon, Linkedin).

Courses

Only free courses are listed here. More can be found on Udemy or other MOOC platforms.

Publications

Dart has been designed by Lars Bak and Kasper Lund at Google, but also backed by the scholars and academics. Many interesting publications can be found on Dart, here a short list of them.

An interpretation of dart programming language by Dr. U. Urathal Alias Sri Swathiga, Ms. P. Vinodhini, and Dr. V. Sasikala.
The power of the Dart programming language for modern, high-performance web application development by Tamara Ranisavljević, Aleksandar Šijan and Luka Ilić.
Spicing Up Dart with Side Effects: A set of extensions to the Dart programming language, designed to support asynchrony and generator functions by Erik Meijer, Kevin Millikin, and
Gilad Bracha.
Message Safety in Dart by Erik Ernst, Anders Møller, Mathias Schwarz, and Fabio Strocco.
The Operational Semantics and Implementation of a Core Dart language by Zhivka Gucevska.
dart2java: Running Dart in Java-based Environments by Matthias Springer, Andrew Krieger, Stanislav Manilov and Hidehiko Masuhara.
Towards a Pattern Language for Interactive Coding Tutorials by Tao Dong and Gale Yang.
Rapid Open Hardware Development Framework by Max Korbel.
Aggressive unboxing in the Dart VM by Victor Agnez Lima.

Type System

Publications related to Dart Type system.

Type inference in Dart by Malte Johansson and Mikel Lindholm.
Type Soundness in the Dart Programming Language by Fabio Strocco.
Type Systems And Programmers: A Look at Optional Typing in Dart by Mark Faldborg and Troels Lisberg Nielsen.
Type Unsoundness in Practice: An Empirical Study of Dart by Gianluca Mezzetti, Anders Møller and Fabio Strocco.
Type Safety Analysis for Dart by Thomas S. Heinze, Anders Møller and Fabio Strocco.
A SIMD Programming Model for Dart, JavaScript, and Other Dynamically Typed Scripting Languages by John McCutchan, Haitao Feng, Nicholas D. Matsakis, Zachary Anderson and Peter Jensen.
STATIC TYPE CHECKER TYPE CHECKER TOOLS FOR DART by Snigdha Mokkapati.

Usage Report

Publications related to real world application developed and released with Dart.

Design and Development of Automotive Workshop Application Based on Android and IOS Using Dart Programming Language by Baiq Andriska Candra P and Ramli Ahmad.
FEATURES OF THE IMPLEMENTATION OF TIME MANAGEMENT TECHNIQUES IN THE PROGRAMMING LANGUAGE DART by Yakov Lvovich and Emma Lvovich.
Android based college app using Flutter Dart by Kavitha Marimuthu, Arunkumar Panneerselvam, Senthilkumar Selvaraj, Lakshmi Praba Venkatesan and Vetriselvi Sivaganesan
DETECT MALICIOUS EMAILS USING DART LANGUAGE by A.Z. Ablahd.
Construction of A Remote Home Automation and Security System Using Raspberry PI by Samson Dauda Yusuf, Chima Oji, Abdulmumini Zubairu Loko and Alhassan Tijani.
An Enhanced Mobile Financial Security System using Facial Recognition and Resident Token generator by Olufunmilola Adunni and Ogunyolu Oludele Awodele.
Propchan: A Mobile Application for Property Management by Chow Jiunn Yang, Minnu Hellen Joseph and Masrina A. Salleh.
Developing Cross-Platform Library Using Flutter by Dilkhaz Y. Mohammed and Siddeeq Y. Ameen.
QRCode Recognition on Flutter Framework Mobile Application Implemented on Entrance Security System by Rosa Andrie Asmara, Rizky Putra Pradhana Budiman, Mungki Astiningrum, Brian Sayudha, Anik Nur Handayani and Cahya Rahmad.
Development of e-butler: Introduction of robot system in hospitality with mobile application by Alexander A S Gunawana, Benedick Clemonsa , Ignatius Ferdyan Halima, Kevin Andersona, Maria Pia Adianti.
Plantonome: A Cross-Platform Application for Precision Agriculture by Anass DEROUSSI, Abdessalam Ait Madi, Imam Alihamidi, zakaria chabou and Adnane Addaim.

Comparison and Benchmark

Publications doing performance comparison between Dart and other languages.

DART Evolved for Web - A Comparative Study with JavaScript by Sabyasachi Mohanty and Smriti Rekha Dey.
JAVA and DART programming languages: Conceptual comparison by Afaf Mirghani Hassan.
Comparative analysis of Java and Dart programming languages in terms of suitability for creating mobile applications by Łukasz Kozłowski, Grzegorz Kozieł.
JAVA and DART programming languages: Conceptual comparison by Afaf Mirghani Hassan.
EXPLORING JAVASCRIPT AND ITS RELATED LANGUAGES by Trieu Huynh Ba Nguyen.
Empirical Testing for Establishing Benchmarks: Process Review and Comparison Between Java, Kotlin and Dart’s Performance by Juan Sebastian Espitia Acero.
Analyzing JavaScript frameworks and Dart for front-end development in building automation by Mukhammadjon Jalolov.

Security

Security risks of java applets in remote experimentation and available alternatives by Petra Špiláková, Roman Jašek1 and František Schauer.

Videos and Channels

Lot of talks can be found on Youtube, I can't list them all, but here some highlights.

What is an Isolate anyway? - Flutter & Friends 2026 by Vyacheslav "Slava" Egorov
Behind the @ – Dart Annotations in Depth - Flutter & Friends 2026 by Anna Leushchenko
Learning something about Dart performance by optimizing jsonDecode - Flutter & Friends 2025 by Vyacheslav "Slava" Egorov
The Future is Written in Dart - Fluttercon EU 2025
by Eric Seidel
Dart on the Backend with Serverpod - FlutterConf 2025 by Viktor Lidholt
Dart Exceptions: Best Practices - Fluttercon USA 2025 by Randal Schwartz
Simpler state management with Dart on the server and synced databases - Fluttercon EU 2025 by Simon Binder
How to design a Dart package with hooks - Fluttercon EU 2025 by Moritz Sümmermann
Machines and Code Analysis - What makes Dart and Flutter run - Fluttercon USA 2024 by Norbert Kozsir
A Deep Dive into Dart FFI - Fluttercon USA 2024 by Roman Jaquez
Supercharging Dart with Rust - THAT Conference 2024 by Brian Lambert
Exploring Records and Patterns - droidCon 2023 by Pascal Welsch
Running Dart around the Globe - droidCon 2023 by Mike Diarmid and Majid Hajian
Full Stack Dart - DroidCon 2023 by Chris Swan
Executing Dart code in background with Flutter - droidCon 2023 by Razvan Cristian Lung
Server-Side In-App Purchases in Dart - droidCon 2023 by Miguel Bentran
The Joy of Functional Programming in Dart - Fluttercon 2023 by Csongor Vogel
Experimenting around Dart Entrypoint Function Name to get it all - droidCon 2023 by Vadym Pinchuk
Dart Microservice with Google Cloud Platform - droidCon 2023 by Filipe Barroso
Pure functional programming in Dart - Func Prog Sweden 2021 by Björn Sperber
The Dart Specification Parser - DartConf 2018 by Erik Ernst
How to build good packages for Dart and Flutter - DartConf 2018 by Kevin Moore
Evolving Dart: Leaving the ocean and learning to fly -DartConf 2018 by Leaf Peterson
Dart: the Return - Javascript Conferences 2018 by Evgeny Kot
Rebuilding Optimizing Compiler for Dart - Strange Loop 2018 by Vyacheslav Egorov
Want to be a Better Programmer? - GOTO 2016 by Lars Bak and Kasper Lund
Dart for the Internet of Things - Dart Developer Summit 2015
by Dennis Khvostionov
Kasper Lund: Why Google thinks you should drop everything you do and pick up their Dart by Kasper Lund
Dart For the Language Enthusiast - Strange Loop 2013 by Bob Nystrom
Building optimising compiler for Dart - Strange Loop 2013 by Vyacheslav Egorov
Anders Hejlsberg and Lars Bak: TypeScript, JavaScript, and Dart - GOTO 2012 by Anders Hejlsberg and Lars Bak
Your First Look at the Dart Editor - GOTO 2012 by Jaime Wren
Dart - A Modern Web Language - Google I/O 2012 by Kasper Lund and Lars Bak
Translating DART to Efficient JavaScript - GOTO 2012 by Kasper Lund
A Walk on the Dart Side: A Quick Tour of Dart by Gilad Bracha
Slides from the Google Dart Presentation - GOTO 2011 by Kresten Krab Thorup
World Premier of Google Dart - GOTO 2011 by Karl Krukow
Interview with Gilad Bracha about Google Dart - GOTO 2011 by Gilad Bracha

Conferences

A list of conferences where you can find more talks about Dart.

Tools and Other Resources

Other stuff I don't know where to put.

ZetCode on Dart: a list of e-pub, ebooks and documentations.
DartPad: an editor and an in-compiler browser for Dart, useful to test snippets.
Awesome Dart: an awesome list, mostly unmaintained.
100 exercises in Dart: a repository with 100 exercises to do in Dart.
Dart on Exercism: coding exercises for Dart.
Dart Tools: a list of useful tools for Dart.
Advent of Code in Dart by Tsoding: just because Tsoding tried Dart.
Nikuu's Blog on Medium: in particular with 30 Days of Dart Code: A Beginner-Friendly Journey in Coding
Yassen Hussein Qasem Saeed Aleshab's blog on Medium: especially Best Practices for Dart and Flutter Application Development

Cover Image by Ricardo Arce on Unsplash

DEV Community: Mathieu K

Asynchronous Functions in Dart

Synchronous Functions in Dart

Iterable class

Upgrading OpenBSD 7.8 to OpenBSD 7.9

Dealing with WebSocket in Dart

WebSocket Server with shelf

WebSocket Client with web_socket

Conclusion

Discovering Swift

Books

Publications

Other

Flashing a Xiaomi Mi A3 Phone

Bootstrapping

Procedure

Unbrick Xiaomi Mi A3

Fixing a bootloop

References and Resources

Raw VM Image Mounting with losetup

Discovering Flutter Ecosystem and Community

Sources

Books

Communication Channels

Courses

Publications

Comparison

Usage Report

Security

Talks

Conferences

Tools and Other Resources

Using dio HTTP Client in Dart

GET Method

HEAD Method

POST Method

PUT Method

DELETE Method

PATCH Method

Downloading Files

What about OPTIONS, TRACE and/or custom HTTP Methods?

What about HTTP/2?

What about HTTP/3?

Want More About dio?

References and Resources

Extracting Publication Data from Substack

Using the http Package in Dart

Importing http package

Refactoring httpcat

Asynchronous call

null safety

Discovering Dart Ecosystem and Community

Sources

Interesting Packages

Books

Communication Channels

Community

Courses

Publications

Type System

Usage Report

Comparison and Benchmark

Security

Videos and Channels

Conferences

Tools and Other Resources

`Iterable` class

WebSocket Server with `shelf`

WebSocket Client with `web_socket`

Want More About `dio`?

Importing `http` package

Refactoring `httpcat`

`null` safety