Can Dart have sync APIs? - postgresql

Question

I am thinking about using Dart for server side programming. Because are no full frameworks similar to Ruby on Rails, I am reviewing lower level libraries. The most needed library is Posgresql driver. I found few and most mature seems to be https://pub.dartlang.org/packages/postgresql
And here is my problem. The Postgresql driver has async API. I know that async APIs are required for client side, simply to not block UI thread. However on server side threads are available so why Postgresql driver has async API?
I known about Promises APIs but for me this is just unneeded complexity when doing things on server side. Code readability is most important.
I just wonder if there is something in Dart language design that forces people to build async APIs. So the question is: can Dart have sync APIs for database and file IO operations?

Answer 1

Dart libraries/packages can offer sync APIs. DB ones don't tend to, because you usually don't want to block the entire server waiting for a potentially long DB operation to finish. For example, say you're creating a web server, with a request handler that fetches data from the DB and serves it. If you're only using sync operations, and you get 10 requests, 9 of those will be waiting for the first one to finish before being processed.
If your only concern is readability, you can wait for the await keyword to be implemented, which will help your code feel like sync code, while actually working async:
var conn = await connect(uri);
var results = await conn.query('select * from users').toList();
for(result in results) {
print("${result.username} has email address ${result.emailAddress}.");
}

Answer 2

Dart does have synchronous file io operations. For example see File.readAsStringSync().
Dart does not have a built in way to perform blocking io on a socket, which means that the postgresql library must be asynchronous.
Dart, even on the server, doesn't really have "threads". It has isolates which can run in parallel, but can only communicate by message passing, and do not have synchronisation primitives like mutexes.
Here is a list of server frameworks.
When writing asynchronous code in Dart, the Future.then() syntax, especially with multiple levels of nesting, can become tedious. Luckily the async/await feature is being implemented which means you can write code that is asynchronous but reads similar to code written with blocking io. For example:
main() async {
var conn = await connect('postgresql://foo');
try {
var sql = "select 'foo'";
var result = await conn.query(sql).toList();
return result[0];
} on Exception catch (ex) {
print('Query error: $ex');
} finally {
conn.close();
}
}
As of Nov14, to use async await you need to run dart with the --enable_async flag, and be prepared for crashes, and missing stack trace information - this feature is under active development and not yet stable. Another more stable option is to use the async_await package to translate your async/await code to use Futures.
If you have any specific questions about the postgresql driver (I am the author), feel free to open an issue against it in github, or to send me an email. My email address is on the postgresql pub page.

Answer 3

You need concurrent programming on the server too, not only on the client. It would be highly inefficient for the server to process requests from clients one after another - waiting until one request is totally completed before starting to process the next request while the Dart server process itself is waiting for the operating system, the database or the network to complete calls made to it.
When an I/O operation which are usually async is called, Dart can start processing other requests while it waits for invoked I/O operations to complete.
You can improve concurrent programming by using isolates but you can't create a Dart application that does some kind of I/O calls with sync calls only.

Answer 4

Dart doesn't support multithreading, if not in the form of Dart isolates (but those are not production ready). Only asynchronous processing is well supported, and the "await" keyword (the best syntax for coroutines) is being added to Dart in the next few months. If you need to build a small web site it will work great.
But if you need a really scalable solution for a big web site or a demanding web app, I suggest you to use the combination of Dart+Go. Make Dart to manage the client/UI side, and Golang to manage the data providers on server side. Go is the most performant language server side thanks to his innovative "Goroutines". Goroutines are a form or coroutines that runs automatically in multiple threads, combining the flexibility of asynchronous processing with the efficiency of synchronous multithreading. Goroutines are automatically multiplexed onto multiple OS threads so if one should block, such as while waiting for I/O, others continue to run.
Go+Dart makes a really powerful combination.