#asyncronous

Asyncronous - Pangaea Nova EP - elctronica from Ukraine (Phonica Special Edition)

The next release in the Phonica Special Edition series comes from Ukrainian duo Asyncronous who first came to our attention after hearing their critically acclaimed debut on Berlin label Slow Life, ‘The Art of Fighting In A Dream’ . A Phonica favourite, it provided the soundtrack to many days in the shop throughout the year, culminating in its inclusion in our top ten Best Singles of 2019!

Self-directed Asynchronous Writing Sprint

Here's how this works: You see this post? Get it set to reblog, and open your WIP. Pick a time: 15 minutes, 30 minutes, an hour, 2 minutes whatever. Whatever amount of time you have free to write at all right now.

SPEND THAT MUCH TIME WRITING IN YOUR WIP.

Come back to the post, write how much time you spent, and how many words you added to your total wordcount.

Whoever sees this post from you should then do the same.

Congratulate yourself on your new wordcount, and your friends/followers on their new wordcounts as they come across this post and make some words happen. 5 words? 500 words? It's all words that weren't there before!

Artwork by Mariia Prymachenko It’s now been four years since the full-scale invasion with little to feel optimistic about. This month we talk to kyïvite about radio broadcasts and archival recordings while Polygrim describes his production processes as playing with Lego on steroids and Konstantin Kost displays his penchant for VHS aesthetics in Odesa, whereas Doctor Bugg admits to a strong…

For my initial dive into Tornado and asynchronous programming, check this out. 

Let’s talk RabbitMQ this time, Tornado and RabbitMQ are like match made in heaven. They go together even better if you don’t care about delivery confirmations. 

Here is a Tornado application to post stuff to RabbitMQ that can scale up to tens of thousands of open connections by never blocking the main thread. It’s all event driven, just how Tornado likes it.

Here is what the app looks like

Tornado is python web framework. If you don’t know about it, you should check it out. It’s one of the easier frameworks to use, if you know what you are doing.

Tornado, as the documentation says, is great for applications that require long lived connections to the user like long polling. Tornado becomes great for these applications by using non blocking I/O. 

The main thread in Tornado accepts connections so we need to keep that thread free as much as we can for Tornado to scale as it’s meant to be. This is great when the logic in your application is minimal or you extensively depend upon network based call. In case of I/O, you can initial the I/O and register a callback. This would be what people call event driven programming. 

All this is great but where tornado is not so great is libraries to support event driven programming for basic technologies like MySQL and memcache. That makes it very important to look at what your application will do now or in future before you choose Tornado as your web framework.

In case you do choose Tornado and MySQL is your bottleneck. There are things you can do using python’s asynchronous programming and latest versions of Tornado even help you write asynchronous code looking like it’s synchronous. But if you are stuck to version of python like 2.6 or 2.7, here is my shot at allowing asynchronous MySQL logic. It uses  a pool of workers to whom you send a query and a callback, which is called once the query returns. 

The app looks something like this

JavaScript has really taken asynchronous programming mainstream, but some of the lessons we've learned along the way is that async is different. Rather than the usual linear program flow, you have these callbacks which can be nested or managed by a control flow lib. However, what if we dreamt something more natural for async programming, because async is awesome and it deserves it.

Promises is the idea that an async function returns an object which handles the outcome of an async action. I like this concept because you're using the return statement where it should be used (output). Inversely, callbacks seem backwards: you use the input to handle the output of a function (how backwards). However, promises are still callbacks, just nicer.

I wondered then, what would it be like if we had async built into a language? How could this work? Could it even work? Let's hypothesize.

Say the return statement was asynchronous in that the function would wait until it is used before it returns output:

function af(){ return setTimeout(function(){ return 'done'; }, 1000) }

Here, setTimeout returns what the callback returns, but it is async so it doesn't return 'done' immediately. This is interesting, but the language would have to know which parts of the code depend on other async operations.

var foo = af(); if (foo === 'done') { alert('second'); } alert('first');

Sense the if-statement depends on foo, then the if statement is put on hold before, and the alert('first') statement is executed.

This will make parallel async and serial async almost invisible to the programmer:

// parallel invocation var a = async(); var b = async(); doSomethingWith(a, b); // Final results // Serial invocation var a = async(); var b = doSomethingWith(a); doSomethingWith(b); // Final results

Some more examples to get used to how this works:

var done = sleep(2000); if (done) { alert('Done sleeping!'); } alert('Sleeping'); var posts = db.query("select * from posts"); var comments = db.query("select * from comments"); // This next statement is using the pending variables // so it will be queued until for later, automatically res.render('template', {posts:posts, comments:comments}); // This will run before the above because it's not depending // on the async pending variables Analytics.push(request);