Suppose you're writing a contract which involves a huge amount of participants. As an example, think of an online, blockchain-based Trading-Card Game with tournaments. How would you program a playCard function? You might be thinking of something like this:
function playCard(uint player, uint card){
...
else if (card == PROFESSOR_OAK){
// shuffles the player's hand on his deck
shuffleHand(player)
| #include <stdio.h> | |
| #include <stdlib.h> | |
| void add1(long len, long *array){ | |
| for (long i = 0; i < len; ++i) | |
| array[i] = array[i] + 1; | |
| } | |
| long sum(long len, long *array){ | |
| long sum = 0; |
| module Main where | |
| import qualified Data.Vector.Unboxed as V | |
| {-# INLINE add1 #-} | |
| add1 :: V.Vector Int -> V.Vector Int | |
| add1 = V.map (+ 1) | |
| main :: IO () | |
| main = do |
| // Bitcoin's hash rate has been doubling once every 75 days in average. It | |
| // varies a lot, though, but, assuming it keeps at least a similar pace, and | |
| // assuming that guessing one private key has the same cost of a single hash, | |
| // then, by the end of 2025, it will be more rewarding for miners to brute | |
| // force private keys rather than mining. | |
| let pow = x => Math.pow(2, x); | |
| let log = x => Math.log(x) / Math.log(2); | |
| let blockRate = block => Math.pow(2, 61.602060630030124) * 1.0000693171203765 * Math.pow(2, (block - 454667) / 10000); |
| // Various ways to upload a PDF with swarm-js | |
| var swarm = require(".").at("http://swarm-gateways.net"); // use http://localhost:8500 if you're running swarm locally, or swarm.local(config, swarm => ...) if you want to run it with swarm-js | |
| var fs = require("fs"); | |
| // Swarm can upload a PDF file directly from disk | |
| // You can then access on browser bzz://hash | |
| swarm.upload({path: "./sample.pdf", kind: "file"}) | |
| .then(console.log) | |
| .catch(console.log); |
CertSimple just wrote a blog post arguing ES2017's async/await was the best thing to happen with JavaScript. I wholeheartedly agree.
In short, one of the (few?) good things about JavaScript used to be how well it handled asynchronous requests. This was mostly thanks to its Scheme-inherited implementation of functions and closures. That, though, was also one of its worst faults, because it led to the "callback hell", an seemingly unavoidable pattern that made highly asynchronous JS code almost unreadable. Many solutions attempted to solve that, but most failed. Promises almost did it, but failed too. Finally, async/await is here and, combined with Promises, it solves the problem for good. On this post, I'll explain why that is the case and trace a link between promises, async/await, the do-notation and monads.
First, let's illustrate the 3 styles by implementing
| -- Relevant resources: | |
| -- http://www.haskellforall.com/2012/07/purify-code-using-free-monads.html | |
| -- http://www.haskellforall.com/2012/06/you-could-have-invented-free-monads.html | |
| -- This type allows expressing computations | |
| -- with readLines and putLines inbetween. | |
| -- It has nothing to do with Monads so far. | |
| data Teletype a | |
| = PutLn String (Teletype a) |
A few days ago, I published an article about Moon, a fundamental building block of a decentralized browser that aims to solve many of Mist's problems. I've showed up some fancy features such as its decentralized package manager and a generalized monadic notation. I guess that made some people angry, wondering why the hell I made yet another programming language when we have so many of them. If you're on that group: you're right. I'm sorry. Believe me when I say I'm as tired of new languages as you, and I'm as pissed with myself as you are. But I'd not have done this if I didn't have a very good reason. Give me, thus, a chance to justify my sins. For one, I didn't actually invent a programming lang
| all vars have different names: | |
| ((rename. (rename X.(a.(rename Y.(Y a)) X))) f.c.(f c)) | |
| -> (f.c.(f c) X.(a.(f.c.(f c) Y.(Y a)) X)) | |
| -> c.(a.c.(c a) c) | |
| -> c.c.(c c) |