Post-Rice Haze

JavaScript Inheritance

Thu, 11 Mar 2010 01:16:00 -0600

JavaScript inheritance can be done dozens of different ways. One of the major plusses of the language is that it’s flexible enough to allow many possible paradigms. However, this also turns into a major language detractor, since everyone does it just a little differently. Here are a couple and some reasons I lean one way most of the time.

First, there’s a functional pattern. I actually like this a lot. Probably because I’ve written way too much Scheme in my time, but it’s elegant and, through functional scope, provides privacy otherwise lacking in JavaScript.

For example:

var make_rectangle = function(length, width) {

	// length, width in private scope

	var area = function() {

		return length * width;

	};

	return {

		area: area

	};

};

var make_square = function(length) {

	return make_rectangle(length, length);

};

var r = make_rectangle(1, 2);

var s = make_square(2);

r.area();

s.area();

This is sometimes called the Module pattern and sometimes uses constructors with the new keyword, but that all amounts to the same thing: a function that generates an object.

The functional pattern is great, and I like it for lots of things but it has significant drawbacks. Privacy is rarely really needed and blocks lots of fun extensions once the object is created (e.g. r.perimeter = function() { return 2*this.length + 2*this.width; };) The subtle drawback is the performance hit it entails, which I will come back to.

Then there’s a classical-styled inheritance pattern. Which has it’s drawbacks but has grown on me in recent months.

function Rectangle(length, width) {

	this.length = length;

	this.width = width;

};

Rectangle.prototype.area = function () {

	return this.length * this.width;

};



function Square(length) {

	/* could use parent constructor here, but requires some more work. */

	this.length = this.width = length;

};

Square.prototype = new Rectangle();



var r = new Rectangle(1, 2);

var s = new Square(2);

r.area();

s.area();

This is pretty straightforward and understandable for someone coming from the OO world of doing things. Rectangle constructs an object that has a length and a width. The next line adds a function to it’s prototype. Square constructs similarly. And sets it’s prototype to an instance of Rectangle (it’s actual data doesn’t matter; so here, length and width are undefined).

Now this approach has it’s drawbacks too. There’s no easy way to call a parent’s constructor. This can be buttered over with some convenience functions if necessary. And the new keyword has it’s problems: without the new, calls to Rectangle and Square have this bound to the global namespace which can cause all kinds of crazy problems. As Crockford says, “There is no compile warning, and there is no runtime warning.” This used to bother me, but I’ve learned to live with lint. A capitalized function must always get called with new, done and done. Besides, if you’re extra paranoid, there’s always:

function Rectangle(length, width) {

	if (!(this instanceof Rectangle)) {

		return new Rectangle(length, width);

	}

	

	this.length = length;

	this.width = width;	

}

But this also has it’s advantages. For example, not only can I now extend individual objects, but I can also add functionality to the prototype itself. For example:

r.perimeter = function () { return 2*this.length + 2*this.width; };

r.perimeter();

Or:

Rectangle.prototype.perimeter = function () { return 2*this.length + 2*this.width; };

r.perimeter();

s.perimeter();

Which otherwise, the privacy would block. The subtle advantage is that the classical actually performs much better than our first pattern. A quick profile shows:

>>> function exercise_functional() {

	for (var i=0; i<100000; i++) {

		make_rectangle(1, 2).area();

	}

};

>>> function exercise_classical() {

	for (var i=0; i<100000; i++) {

		(new Rectangle(1, 2)).area();

	}

};

function calls time average

make_rectangle 100000 418.666ms 0.004ms

Rectangle 100000 95.361ms 0.001ms

A pretty big difference and a huge factor for objects in tight loops.

The classical pattern is much faster, because it’s doing much less. It makes one area function assigned to Rectangle’s prototype and the language delegates all calls to it up to that instance with the correct data bound to this. The functional pattern is making a new area function for every object. And assigning it to it’s own property. Not only wasting a bunch of time, but also memory.

JavaScript is fun. It lets you do all this any way you choose. Which is a blessing and a curse. My choice tends to change fairly frequently.

Shoes

Sat, 27 Feb 2010 01:02:48 -0600

Nelly’s “Air Force Ones” is a classic. I remember riding around in the car in high school surfing radio stations in the attempt to always have “Air Force Ones” playing. It was ridiculous how long we could actually keep this up.

Since “My Adidas” was released by Run DMC in 1986, shoes have been a classic trope in hip hop, but nothing takes it to the extreme like “Air Force Ones”. And it’s the extremes that make “Air Force Ones” great. The complete necessity of something as trivial as a shoe. In multiples. “I said give me two pairs,/I need two pairs,/So I can get to stomping in my Air Force Ones.”

The song is just getting started when Murphy Lee comes in with a verse that’s only rhyme is the one word “man”.

Don’t get me wrong man, now Murphy Lee ain’t dumb man,
‘Cause if the shoe is on the shelf, you should have some man
You can not sit up and tell me that you have none man
You may not have three or four but you got one man.

I got into a long argument once in college when someone mentioned they hated 50 Cent because he rhymed lines with the same word. Murphy Lee’s verse is a solid example of why I rarely take offense to this. Just look at the endings “dumb man”, “some man”, “none man”, “one man”. Enough said.

Then Kyjuan comes in with a verse that mixes the shoes with the another hip-hop staple: the car. Another necessity that’s completely trivial.

O. K. ‘li, I treat my shoe like my ride,
Chrome on the fat laces and put wood on the inside
Spray candy on the swoosh with electric roof
Since I put a kit on the sole, now got a wider shoe
You see that low mid, skittle purple poof, I’m drivin them.
(Kyjuan, where you gettin’ them colors, are you dying them?)
…

Every time I hear this verse, I just picture it all literally. A tricked out high top complete with chrome, wood interior and candy paint. And I giggle. But they are both just accessories.

Finally, Nelly rounds it out with a verse about the white on whites. My favorites, though mine are scuffed.

Now don’t nothing get the hype on first site like white on whites
Them three quarters, them lows; they all tight
The only problem they only good for one night,
‘Cause once you scuff them you fucked up your whole night.

Look at that first line. The whole verse, like most of the song’s verses, is centered around a single rhyme. But here, it’s the first line that makes it all work. “Now don’t nothing get the hype on first site like white on whites”. It’s overloaded “hype”, “first site”, “like”, “white on whites”. A completely excessive line that matches the theme of the song.

I think I might need some new shoes.

Dead Simple Concurrency with Clojure

Mon, 09 Nov 2009 19:24:00 -0600

Concurrency is hard. In an environment where processors don’t get faster, we just get more of them, concurrency is going to get more important. We’ll take these as givens.

Enter Clojure. Promising a vast array of interesting features promising to make concurrency easier.

So in my attempts to learn the language, my goal was to get something running concurrently as quickly as possible. I started with merge sort.

(use 'clojure.contrib.seq-utils)

; merge side of the merge sort. naive tail recursive solution.
(defn ms-merge [left right]
  (loop [head [] l left r right]
    (if (empty? l) (concat head r)
      (if (empty? r) (concat head l)
        (if (> (first l) (first r))
          (recur (conj head (first r)) l (rest r))
          (recur (conj head (first l)) (rest l) r))))))

; split side of the merge sort. naive recursive solution.
(defn naive-merge-sort [l]
  (if (< (count l) 2) l
    (apply ms-merge (map naive-merge-sort (split-at (/ (count l) 2) l)))))

This naive solution is slow and clearly doesn’t use both my cores.

With a total running time of 21.98s to sort a shuffled list of 1M integers.

From here, I split the process between my cores.

; wrapper around merge sort that just delegates both sides
; to threads running the naive solution.
(defn parallel-merge-sort [l]
  (apply ms-merge (pmap naive-merge-sort (split-at (/ (count l) 2) l))))

The approach is just to split the input in half and sort both sides in different threads. This is trivial to do using pmap. The end job of merging these two together is easy enough and tail-recursive, so the downside of running the merge on just a single thread is less than you think (roughly 0.9% of total processing time).

And with a total running time of 16.25s to sort a shuffled list of 1M integers.

In this, I don’t use Clojure’s key win, STM, just the pmap syntactic sugar around managing multiple threads, so I’m only getting a little benefit from Clojure.

Also, this only splits the task into two parts, therefore only making use of at most two cores. Not a completely portable solution.

But the fact that my “hello world” in a new language uses both my cores this easily, is impressive.

Really Liking Ruby

Tue, 29 Sep 2009 13:37:22 -0500

class Node

  def initialize(label, left, right)
    @label  = label
    @left   = left
    @right  = right
  end

  attr_accessor :label, :left, :right

  def breadth_first
    unvisited = [self]

    while not unvisited.empty?
      node = unvisited.shift

      yield node

      unvisited << node.left if node.left
      unvisited << node.right if node.right
    end
  end

end

Migrated west until I hit an ocean. From the bayou to Houston to Austin. Skipped the desert and hit...

Fri, 21 Aug 2009 13:50:00 -0500

Migrated west until I hit an ocean. From the bayou to Houston to Austin. Skipped the desert and hit a beach. Cold as all hell up the foothills. I-10 always the closest thing to a home I had. Until I ran out of mile markers and there’s only east to go.

"People. This is me again. I hate to cut things down like this. But, uh. There’s a crowd of..."

Thu, 13 Aug 2009 17:57:31 -0500

“People. This is me again. I hate to cut things down like this. But, uh. There’s a crowd of kids. And this is to whom I’m talking. Mostly to whom. Are you ready for that? Um. There’s kids like crowding around over the walls, and like, trying to break down doors and everything. Thinking the Beatles are here. And uh. And uh that last comment. Hahaha alright. Except that they’re trying to break things down, crawling over ceilings and walls, and like. Thinking the Beatles are here. And they’re not. You. Those of you. And uh, they can come in if they want to come in. The Beatles aren’t here. Yeah. There’s great things happening anyway. Yeah, except that, just don’t, you know. Don’t like, bring down the ceilings and walls and everything. And uh, carry on.”

- Bill Graham at Monterrey Pop during the Grateful Dead’s set.

Jurassic Park

Thu, 23 Jul 2009 15:35:53 -0500

MALCOLM
The problem with scientific power you’ve used is it didn’t require any discipline to attain it. You read what others had done and you took the next step. You didn’t earn the knowledge yourselves, so you didn’t take the responsibility for it. You stood on the shoulders of geniuses to accomplish something as fast as you could, and before you knew what you had, you patented it, packaged it, slapped it on a plastic lunch box, and now you want to sell it.

HAMMOND
You don’t give us our due credit. Our scientists have done things no one could ever do before.

MALCOLM
Your scientists were so preoccupied with whether or not they could that they didn’t stop to think if they should. Science can create pesticides, but it can’t tell us not to use them. Science can make a nuclear reactor, but it can’t tell us not to build it!

"…that inside this building is the president, and not just any president—though..."

Mon, 20 Apr 2009 20:49:45 -0500

“…that inside this building is the president, and not just any president—though admittedly that probably would not have mattered—but this is a president that, fuck, we have some sort of crush on this man. He speaks like a president, not always authoritative or anything but he can form sentences, complex sentences with beginnings and ends, subordinate clauses—you can hear his semicolons! He knows the answers to questions. He knows acronyms and the names of foreign leaders, their deputies. It is heartening, it makes our country look smart, and this is an important thing, something we have too long been without.”

- Dave Eggers about Clinton circa 1994 in A Heartbreaking work of Staggering Genius.

"I need to see what’s inside that box. If I learned anything from 24, you’re going to..."

Sun, 29 Mar 2009 19:34:27 -0500

“I need to see what’s inside that box. If I learned anything from 24, you’re going to want to zoom in and enhance.”

- 30 Rock, “Apollo, Apollo”

A lot of people have used The Cure’s “Close to...

Mon, 16 Mar 2009 13:20:00 -0500

A lot of people have used The Cure’s “Close to Me”, Diplo included. NME gives a rundown, but uses a terrible Diplo example.

Now Lady Sovereign’s thrown her two cents in with her new single. I like. Plus it’ll give me good material for Lady Sovereign/Diplo/The Cure extended transitions.

For some reason, I followed Barack’s senate race in 2004....

Mon, 09 Mar 2009 19:56:57 -0500

For some reason, I followed Barack’s senate race in 2004. Though living in Texas and being from New Orleans meant it was of little relevance to me.

The gem that came out of the race was this little track. When Barack started running for president, I kept wishing I could find this track, but it had gotten lost somewhere deep in my hard drive. Well. I found it.

Worst Line of Code and Why

Fri, 06 Mar 2009 18:14:01 -0600

I needed to grab the latest Link object for a certain Forum from Django’s ORM.

Normally, I’d do this with:

link = forum.link_set.order_by('-id')[0]

But for some reason, adding the slice (which adds a limit to the SQL query), was considerably slowing down the call. Whereas, just getting the iterator was fine.

link_qs = forum.link_set.order_by('-id')

Which is disturbing. I haven’t figured out why, but I wanted to get the code I was working on done before figuring out why this query was slow, so I hacked around it.

So, of course, I could just convert that QuerySet to a list and index the list with:

link = list(forum.link_set.order_by('-id'))[0]

But that would load the entire result into memory. My results could potentially be extremely large, so I didn’t want to go down that route.

So I wrote the obvious solution, using the iterator, but only saving the first result. Which turned out to be one of the worst lines of code I’ve ever written.

In all it’s glory:

for link in forum.link_set.order_by('-id'):
    break

"Trust me, they don’t apply to your app. If in doubt, explain your use case for XML to an..."

Wed, 25 Feb 2009 15:58:34 -0600

“Trust me, they don’t apply to your app. If in doubt, explain your use case for XML to an experienced Python developer. Or, if you have a thick skin and don’t mind being laughed at, try explaining to a Lisp programmer why your application needs XML!”

- Python is not Java

i've lost it

Wed, 11 Feb 2009 14:00:27 -0600

i grew up. learned how to take care of myself.
buy beer. car insurance.

and suddenly the words don’t pretty. oh! forgot the insomnia of restless sparkling girls’ eyes from across the bar. two sets at a time.

oh!

suddenly midnights are:
consumption.
alcohol. television. transportation. oh!

nothing geography can’t solve?

Elegant Fibonacci Iterator

Sat, 24 Jan 2009 18:21:00 -0600

After a bunch of versions of Fibonacci functions months back, the following iterator appeared in my notebook.

def fib():

    future = [0, 1]

    while True:

        future.append(sum(future))

        yield future.pop(0)

Though of no particular engineering marvel. It is, at O(n), slower than the best case O(log(n)) I can do using matrix multiplication of powers of two.

I find it particularly elegant.

Whitney and I picked up a stray kitten a little while back. My...

Fri, 26 Dec 2008 08:53:02 -0600

Whitney and I picked up a stray kitten a little while back. My first real pet.

"Numbers that fool the Fermat test are called Carmichael numbers, and little is known about them..."

Mon, 22 Dec 2008 13:53:11 -0600

“Numbers that fool the Fermat test are called Carmichael numbers, and little is known about them other than that they are extremely rare. There are 255 Carmichael numbers below 100,000,000. The smallest few are 561, 1105, 1729, 2465, 2821, and 6601. In testing primality of very large numbers chosen at random, the chance of stumbling upon a value that fools the Fermat test is less than the chance that cosmic radiation will cause the computer to make an error in carrying out a “correct” algorithm. Considering an algorithm to be inadequate for the first reason but not for the second illustrates the differences between mathematics and engineering.”

- footnote pg. 53 SICP

Mocking with Python

Fri, 12 Dec 2008 00:24:46 -0600

After recent conversations about the surgery I did to the DISQUS IMAP processing code in order to make it testable, I was steered toward Python mock modules. Of which there are a lot.

So I installed the python-mock module and coded up a quick example use case.

Often when writing unit tests, you stumble upon dependencies that the code you’re testing uses, but are orthogonal to the actual functionality being tested.

At DISQUS, this was IMAP processing code that clearly depended heavily on an api into an IMAP mail server. But the functionality being tested was just what the processing did to incoming email from said server. So I wrote a fake IMAP api that just passed around test messages.

However this is generally easier to do using mock objects. The mock objects can catch all methods called on them, so there’s no need to strictly match the expected api. And we can inspect the actual calls made to make sure they are what we expected.

So for an example I coded up a simple logger. In a production environment, it would be helpful to log data for debugging, etc. But while testing this is unnecessary.

The following code does BFS using a simple logger:

	def search(self, label):
		"""
		Search for label in graph. Return list of nodes visited in path.
         Note: Uses BFS.
		"""
		visited = set()
		queue = [(self, [])]
		while queue:
			node, path = queue.pop(0)
			self.logger.log('Visiting node %s with path %s.' %
                      (node.label, [n.label for n in path]), severity=1)

			if node in visited:
				continue
			visited.add(node)

			path.append(node)
			if node.label==label:
				return path
			else:
				for edge in node.edges:
					edge_path = copy.copy(path)
					queue.append((edge, edge_path))

		self.logger.log('Not found.', severity=2)
		return None

Which is easy enough to test, except that we’ll be leaving log files around with this information. Instead of a real logger, we can pass in a mocked object as such:

class NodeTests(unittest.TestCase):

	def setUp(self):
		logger = mock.Mock( {'log' : 'log called'} )

		austin = Node('austin', [], logger)
		dallas = Node('dallas', [austin], logger)
		houston = Node('houston', [austin, dallas], logger)
		san_antonio = Node('san antonio', [austin, houston], logger)

		self.logger = logger
		self.graph = san_antonio

	def testSearch(self):
		result = self.graph.search('dallas')
		labels = [node.label for node in result]

		self.assertEqual(['san antonio', 'houston', 'dallas'], labels)
		self.assertEqual(5, len(self.logger.mockGetNamedCalls('log')))

Easy enough. And a lot easier that writing up a fake logger that matches the expected api.

Tackling JavaScript

Wed, 19 Nov 2008 18:15:00 -0600

Lately, I’ve been looking at JavaScript a little differently. Instead of writing JavaScript as dirty hacks to do DOM manipulation, handle JavaScript as a first-class language in itself and write elegant code to do DOM manipulation. Something I should have been doing all along. Toward that goal, I tackled a little project to exercise writing elegant JavaScript code.

At least until I can have python in the browser.

This was sparked by bit of fiddling with SproutCore and reading about the other advanced JavaScript frameworks. In those frameworks, binding a bit of data to a view is the standard. The framework handles the glue code that keeps that data and the display in sync, while the programmer is left to do whatever data manipulation is needed.

So I wrote a small SproutCore application that read network feeds and updated a displayed HTML list. The code that updates this need only concern itself with the data side of the equation and not the view. Which was all MVC and fine and dandy. Elegant in fact.

But what bothered me was this data was handled in an intermediate representation defined by the framework. So to manipulate this data, I needed to know the framework’s API for manipulating it’s representation.

There’s no reason that internal representation cannot be similar (if not exactly like) JavaScript’s own Array.prototype.

Hence boundarray was born. Just a simple wrapper around the JavaScript Array.prototype with a near exact implementation that also handles updating a HTML list element. I thought this would be a perfect little project to exercise my JavaScript, so I quickly put up a public github repository and got coding.

It was certainly a learning experience in writing clean JavaScript code as well as truly getting to know JavaScript’s Array.prototype.

boundarray

boundarray provides a constructor called BoundArray that creates an intermediate representation that behaves exactly as a JavaScript Array with one single exception.

An example use of boundarray with code snippets and a working example lives here.

After conversations with a couple of JavaScript expert friends of mine, it became evident that it’s currently impossible to implement Array.prototype entirely in JavaScript.

The problem creeps in because Array.prototype supports implicitly growing the length of the Array. For example:

var numbers = ['one', 'two', 'three'];
numbers[4] = 'five';

The assignment in the second statement is out of the bounds of the array. So JavaScript silently grows the array and makes the assignment leaving an array that looks like: ['one', 'two', 'three', undefined, 'five']

Currently JavaScript provides no means of catching assignment to undefined properties. There is a way to catch calls to undefined properties with Object.prototype.__noSuchMethod__, but no similar method for properties.

But failing that one little difference, a BoundArray behaves exactly like a JavaScript Array as defined at the Mozilla Developer Center, but has the side effect of updating a displayed HTML list element.

For more information on BoundArray see it’s public github repository.

Next on the list is to consider rolling this into a plugin for JQuery or something similar.

Juicy

Mon, 18 Aug 2008 17:28:00 -0500

I always rap on and on about how hip-hop is the natural extension of postmodernism, but rarely offer up much on the subject. In an effort to start getting some of it on paper, I’m going to start tackling the topic here.

Saturday I went down to Mountain View for Rock the Bells. Mostly for Dead Prez. After their set, I get into the postmodernism speil with April, a poet herself, when a golden gem of an example presented itself.

Dead Prez’s set included a rap over the beat from The Notorious B.I.G.’s Juicy (video). But Dead Prez went beyond the simple example of intertextuality of borrowing another’s beat. They offered up their own version of one of the most famous verses in hip-hop, Biggie’s first verse in Juicy:

It was all a dream,
I used to read Word Up magazine;
Salt-n-Pepa and Heavy D up in the limousine.
Hangin’ pictures on my wall,
Every Saturday: Rap Attack, Mr. Magic, Marley Marl.
I let my tape rock ‘til my tape popped,
Smokin’ weed and bamboo, sippin’ on private stock;
Way back, when I had the red and black lumberjack,
With the hat to match.

Apparently released as “B.I.G. Respect” on their mixtape Turn off the Radio: The Mixtape Vol. 1, Dead Prez’s version isn’t just an unrelated rap over the same beat, but follows the same pattern of Biggies’.

It’s the story of their coming to age into their experience of hip-hop. It even follows the same general pattern.

It was all a dream!
Started organizing in my late teens,
Malcolm X and Huey P, who I wanna be.
Marcus Garvey on my wall.
I was just a young G, thought I’d been through it all.
Fuckin’ with po-po, used to stay “lock”.
Tryin’ to get my aim right, learning how to shoot a glock.
Way back, used to rock the army green fields jacket,
We was known for that.

This coming of age story has already been told. It’s part of the established hip-hop dictionary. Dead Prez just fits their own experience into the existing mold.

Just another example of the death of stylistic innovation common in postmodernism. As Jameson puts it:

We thus face an aesthetic dilemma: if the experience and the ideology of the unique self is over and done with, then it is no longer clear what artists and writers of the present age are supposed to be doing. It would seem that, in a world in which stylistic innovation is no longer possible, all they can imitate are dead styles.

However, hip-hop, I believe embraces this dilemma and lives within it. Art doesn’t need to be stylistically innovative.