greim

/*
 * Home in on a number in binary search fashion.
 * binWalk(2048) === 1024
 * binWalk(2048, -1) === 512
 * binWalk(2048, -1, -1) === 256
 * binWalk(2048, -1, -1, -1) === 128
 * binWalk(2048, -1, 1) === 1536
 */

function binWalk(n){

greim

/**
Extend Backbone.SoftModel and then bind to the 'soft:change' event.
It will only fire once given a sequence of rapid-fire changes.
This avoids for example having multiple redundant renders,
which can be a performance killer. That way you don't have to
splatter your code with speculative {silent:true}s.

Warning!
This code is untested. This is just exploring an idea.
*/

greim

/*
For an arch with a rise of X, what's the radius.

Start with this right triangle:

                 b
                 |
a----------------c

a = left edge of arch

greim

type Queue a
  = Empty
  | Mono a
  | Multi a (Queue a) a

enq : a -> Queue a -> Queue a
enq val queue =
  case queue of
    Empty ->

greim

Elm: Supplementary Notes

In which I get angry because some aspect of Elm seems... well, weird to me, and the docs aren't helping, so I jot down these notes in order to force myself to better grasp the topic, because writing forces me to think deeply about things in a way that I'm incapable of doing otherwise gaaasspp

Grokking Elm Functions

Background: In Elm, functions are pure. Given the same input, they'll always return the same output. That isn't the case in JavaScript, where for example a function can return different values on successive calls, like Math.random() or Date.now().

Thus, a function that takes zero args is conceptually no different than a variable. A variable holds a value. A zero-arg function only returns one possible value. This is reflected in Elm syntax. Look at how you annotate and declare a variable in Elm:

greim

Elm: Supplementary Notes

In which I get angry because some aspect of Elm seems... well, weird to me, and the docs aren't helping, so I jot down these notes in order to force myself to better grasp the topic, because writing forces me to think deeply about things in a way that I'm incapable of doing otherwise gaaasspp

Grokking Elm Components

The Elm architecture is cool because it's fractal. That is, you can break your program into components, each of which is a mini-expression of the overall Elm architecture. The Elm architecture is... turtles.

How is this done? I don't know! I'll figure it out and come back!

greim

// created by greg reimer ("gregreimer" at gmail) http://obadger.com/

function createHistogram(rFunc) {
	var arr = [];
	var size = 30;
	for (var i=0; i<size; i++){
		arr[i] = 0;
	}
	for (var i=0; i<1000000; i++){
		arr[Math.floor(rFunc() * size)]++;

greim

vacancies.listen('relatedProducts/:productId', async function(params, send) {
  const id = params.productId;
  const resp = await fetch(`/products/${id}/related`);
  const products = await resp.json();
  send({ type: 'RECEIVE_RELATED_PRODUCTS', id, products });
});

greim

function ProductDetailPage({ viewportWidth, relatedProductInfo }) {
  const hasRealestate = viewportWidth > 800;
  const hasData = relatedProductInfo === undefined;
  return <div>
    ...
    { hasRealestate &&
      ( hasData
        ? <RelatedProducts products={relatedProducts}/>
        : <div data-vacancy={`relatedProducts/${id}`}>Loading...</div>
      )

greim

class ProductDetailPage extends React.Component {

  componentDidMount() {
    ...
    const hasRealestate = this.props.viewportWidth > 800;
    const hasData = this.props.relatedProductInfo === undefined;
    if (hasRealestate && !hasData) {
      this.props.fetchRelatedProductInfo(this.props.productId);
    }
  }