Justin Meiners justinmeiners

Polymorphism in Scheme via compile time dispatch

Here's an example of polymorphism in C++:

int nth ( int a[] , int i ) { return a[i] ; }

double nth ( double a[] , int i ) { return a[i] ; }

One way to think of this is that there are two functions called nth. One can be called with an int array and the other can be called with a double array. The function that is called is determined at compile time by looking at the type of the expression of the first argument.

Generics in Scheme

In a previous note I demonstrated polymorphism in Scheme using Chez Scheme's compile time values and properties.

The code in that example is pretty raw; you might not want to code each generic in that manner. One approach is to decouple the signature/method table. We can do this by factoring out some code into a 'make-generic' procedure:

(define (make-generic table)
  (lambda (stx)
 (lambda (lookup)

In August 2007 a hacker found a way to expose the PHP source code on facebook.com. He retrieved two files and then emailed them to me, and I wrote about the issue:

http://techcrunch.com/2007/08/11/facebook-source-code-leaked/

It became a big deal:

http://www.techmeme.com/070812/p1#a070812p1

The two files are index.php (the homepage) and search.php (the search page)

Hofstadter on Lisp

In the mid-80s, while reading through my roommate's collection of Scientific American back issues, I encountered this introduction to Lisp written by Douglas Hofstadter. I found it very charming at the time, and provide it here (somewhat illegally) for the edification of a new generation of Lispers.

In a testament to the timelessness of Lisp, you can still run all the examples below in emacs if you install these aliases:

(defalias 'plus #'+)
(defalias 'quotient #'/)
(defalias 'times #'*)
(defalias 'difference #'-)


	#include <stdio.h>
	#include <stdlib.h>

	struct closure {
	void (* call)(struct closure *);

	int x;
	};

	CL-USER> (asdf:operate 'asdf:load-op :hello)
	; loading system definition from /home/cametan/hello.asd into
	; #<PACKAGE "ASDF0">
	; registering #<SYSTEM HELLO {AB3F071}> as HELLO
	NIL
	CL-USER>

	default (Int, Integer, Rational, Double)

	if' :: Bool -> a -> a -> a
	if' True x _ = x
	if' False _ y = y

	isBraidIdentity x n =
	[1..n] == concat (map (braidReduce x) [[y] \| y <- [1..n]])

	braidReduce = flip (foldr homomorphism)

	Latency Comparison Numbers (~2012)
	----------------------------------
	L1 cache reference 0.5 ns
	Branch mispredict 5 ns
	L2 cache reference 7 ns 14x L1 cache
	Mutex lock/unlock 25 ns
	Main memory reference 100 ns 20x L2 cache, 200x L1 cache
	Compress 1K bytes with Zippy 3,000 ns 3 us
	Send 1K bytes over 1 Gbps network 10,000 ns 10 us
	Read 4K randomly from SSD* 150,000 ns 150 us ~1GB/sec SSD

	// THIS IS ONLY A PORTION OF THE FILE
	// WILL NOT COMPILE OUT OF THE BOX!



	void OrthogonalizeTangent (TangentInfo& tangentInfo, Vector3f normalf, Vector4f& outputTangent)
	{
	TangentInfo::Vector3d normal = { normalf.x, normalf.y, normalf.z };
	TangentInfo::Vector3d tangent = tangentInfo.tangent;
	TangentInfo::Vector3d binormal = tangentInfo.binormal;

	# Originally from http://sharebear.co.uk/blog/2009/09/17/very-simple-python-caching-proxy/
	#
	# Usage:
	# A call to http://localhost:80000/example.com/foo.html will cache the file
	# at http://example.com/foo.html on disc and not redownload it again.
	# To clear the cache simply do a `rm *.cached`. To stop the server simply
	# send SIGINT (Ctrl-C). It does not handle any headers or post data.

	import BaseHTTPServer
	import hashlib