Andrew Gaspar AndrewGaspar

I hereby claim:

To claim this, I am signing this object:

Asynchronous Javascript Notes

Unique problems for Javascript:

JavaScript is single threaded
Most I/O is performed asynchronously in JavaScript (by design)
On client side
- App is driven by user input
- Most CPU work presumably done by DOM
On server side

	use std::cell::RefCell;

	// `generational_arena` is a special type of arena that allows elements to be recycled, and the
	// handles allocated from the arena do not hold a borrow on the arena. The handles are later used to
	// retrieve concrete borrows on the arena temporarily. The check for live-ness is essentially
	// performed at runtime, rather than being checked by the borrow checker.
	use generational_arena::{Arena, Index};

	// Allocate `ARENA` at global/thread scope. The arena is wrapped in a RefCell so we can get
	// runtime-checked mutable borrows of the arena.

	struct RequestCollection<'a, T: 'a + Copy> {
	handles: Vec<bool>,
	buffers: Vec<&'a mut [T]>,
	}

	impl<'a, T: 'a + Copy> RequestCollection<'a, T> {
	fn new() -> Self {
	RequestCollection {
	handles: Vec::new(),
	buffers: Vec::new(),

	#![feature(test)]

	extern crate test;
	#[macro_use] extern crate itertools;

	use test::Bencher;

	const VEC_SIZE: usize = 10000;

	#[bench]

	var queryResultsPromise = readListOfQueriesAsync("config.xml")
	.then(function(queries) {
	return promise.all(
	queries.map(searchQueryAsync)
	);
	}).then(function(queryResults) {
	return writeOutAsync(queryResults);
	});

	function handleFoobar(error, foobar) {
	if(error) output(error);

	var bar = deFoo(foobar);
	// Matrix multiplication or something
	output(bar);
	}

	fooButton.on("click", function (evt) {
	$.get("/foobar/1", handleFoobar);