| define: *variable* as: @no-variable | |
| (b: Block) derive := | |
| with: *variable* as: b arguments head name do: { | |
| Block: b contents (map: @derive) arguments: b arguments | |
| } | |
| `(~x ^ ~y) derive := | |
| condition: { | |
| -- constant exponent |
| website: Blog: { | |
| "/" -> page: { | |
| Post all (sort-by: { a b | a created-at < b created-at }) | |
| each: { p | join: p pretty } | |
| } | |
| "/post" -> page: { | |
| (Post get: (parameter: "id")) match: { | |
| @(ok: p) -> super join: p pretty | |
| @none -> not-found |
| if you have to write a unary method to accompany a keyword method | |
| (e.g. for sending no args), just define the unary method | |
| if you're going to use multiple blocks, use keyword | |
| if a block value is likely to be used, consider using unary postfix or | |
| keyword (not a huge deal though, given that & is pretty easy) | |
| unary prefix can be better for DSLs, as it immediately shows the purpose | |
| of the block rather than tacking it on the end |
This article has been given a more permanent home on my blog. Also, since it was first written, the development of the Promises/A+ specification has made the original emphasis on Promises/A seem somewhat outdated.
Promises are a software abstraction that makes working with asynchronous operations much more pleasant. In the most basic definition, your code will move from continuation-passing style:
getTweetsFor("domenic", function (err, results) {
// the rest of your code goes here.
| // Boilerplate | |
| function objectUnion(definer) { | |
| var defined = 0, length = 0, isDefined = false, definitions, key; | |
| definitions = definer(function() { | |
| var names = arguments, fold; | |
| if(isDefined) { | |
| throw new TypeError('This objectUnion has already been defined'); | |
| } | |
| function Ctor() {} |
I want to write software that helps kill people.
Please, before you call the police and get my github account put on lockdown, allow me a moment to explain. What I really want to do is work on projects that advance the human condition and improve people's lives. I've been in a mad dash to learn how to program for the past four or five years exactly because I realized how much good I could do for the world with a computer.
RDBMS-based job queues have been criticized recently for being unable to handle heavy loads. And they deserve it, to some extent, because the queries used to safely lock a job have been pretty hairy. SELECT FOR UPDATE followed by an UPDATE works fine at first, but then you add more workers, and each is trying to SELECT FOR UPDATE the same row (and maybe throwing NOWAIT in there, then catching the errors and retrying), and things slow down.
On top of that, they have to actually update the row to mark it as locked, so the rest of your workers are sitting there waiting while one of them propagates its lock to disk (and the disks of however many servers you're replicating to). QueueClassic got some mileage out of the novel idea of randomly picking a row near the front of the queue to lock, but I can't still seem to get more than an an extra few hundred jobs per second out of it under heavy load.
So, many developers have started going straight t
Recently I've been trying to modify the way that I use the word "just" when I'm at work. Merriam Webster offers a few definitions of the word; the one I'm interested in is the one that means "only", "simply", and to a lesser extent "exactly". I've been working on a new project that involves integrating a number of systems, and as I began rolling pieces out I received a lot a questions in the form of "Couldn't you just ...?" These annoyed me at first, but as I thought about it I realized I often asked questions in the same way, so I began to examine the word and the way I use it.
Functional programming gets a bad wrap about being too hard for mere mortals to comprehend. This is nonsense. The concepts are actually quite simple to grasp.
The jargon is the hardest part. A lot of that vocabulary comes from a specialized field of mathematical study called category theory (with a liberal sprinkling of type theory and abstract algebra). This sounds a lot scarier than it is. You can do this!
All examples using ES6 syntax. wrap (foo) => bar means:
function wrap (foo) {
(A book that I might eventually write!)
Gary Bernhardt
I imagine each of these chapters being about 2,000 words, making the whole book about the size of a small novel. For comparison, articles in large papers like the New York Times average about 1,200 words. Each topic gets whatever level of detail I can fit into that space. For simple topics, that's a lot of space: I can probably walk through a very basic, but working, implementation of the IP protocol.