James Tauber's Blog 2008

started

{
    x = 5
    y = x + 2
}

block:
    x = 5
    y = x + 2

foo = {
    x = 5
    y = x + 2
}

block foo:
    x = 5
    y = x + 2

__parent__
foo = {
    __parent__ = bar
    y = x + 2
}

block foo(bar):
    y = x + 2

y
foo(x) = {
    y = x + 2
}

foo = {
    y = x + 2
}

foo % { x = 5 }

assert foo.y == 7

%
orc = { hp = 10 }
warg = { hp = 5 }

boss = { hp = 2 * __parent__.hp }

orc_boss = boss % { __parent__ = orc }

boss(orc)
boss % { __parent__ = orc }
{
    foo = 1
    bar = 1
    baz = 1
}

~x
x
{ ~x = 1 for x in var_list }

canvas
canvas
function drawParabola(fx, fy, dy) {
    var alpha = Math.sqrt((dy*dy)-(fy*fy));
    var p0x = fx - alpha;
    var p0y = 0;
    var p1x = fx;
    var p1y = fy + dy;
    var p2x = fx + alpha;
    var p2y = 0;

    context.strokeStyle = "rgb(100, 100, 100)";
    context.fillStyle = "rgba(0, 0, 0, 0.05)";
    context.beginPath();
    context.moveTo(p0x, p0y);
    context.quadraticCurveTo(p1x, p1y, p2x, p2y);
    context.stroke();
    context.fill();
}

function drawParabolae(dy) {
    $.each(points, function() {
        if (dy > this[1]) {
            drawParabola(this[0], this[1], dy);
        }
    });
}

    ...
    context.clearRect(0, 0, 600, 400);
    drawHorizontalLine(oy);
    drawParabolae(oy);
    redrawDots();
    ....

from reverend.thomas import Bayes
from leonardo.models import Page

guesser = Bayes()

for page in Page.objects.all():
    for category in page.categories.all():
        guesser.train(category.term, page.content)

function drawHorizontalLine(y) {
    context.strokeStyle = "rgb(200,0,0)";
    context.beginPath();
    context.moveTo(0, y);
    context.lineTo(600, y);
    context.stroke();
}

points
function redrawDots() {
    $.each(points, function() {
        drawDot(this[0], this[1]);
    })
}

mousemove
$('#canvas').mousemove(function(e) {
    var pos = $('#canvas').position();
    var ox = e.pageX - pos.left;
    var oy = e.pageY - pos.top;

    context.clearRect(0, 0, 600, 400);
    drawHorizontalLine(oy);
    redrawDots();
});

GET <real_path_to_blog_post>/form.add_comment/

form
class="add_comment"
$('form.add_comment')
Mozilla/5.0 (compatible; SkreemRBot +http://skreemr.com)

class C(object):
    x = 1
    def foo(self):
        return 'bar'

C = type('C', (object,), {'x':1, 'foo':<function foo at ...>})

class <name> <bases>:
    __metaclass__ = <metaclass>
    <block>

<name> = <metaclass>("<name>", <bases>,
            <dictionary created by executing block>)

class
make
make <callable> <name> <tuple>:
    <block>

class
__new__
__call__
<canvas id="canvas" width="600" height="400"
    style="border: 1px solid #999;"></canvas>
<div><button id="clear-button">clear</button></div>

points
(x, y)
var points = [];

anyClose
(x, y)
distance
anyClose
each
/* calculate distance between (x1, y1) and (x2, y2) */
function distance(x1, y1, x2, y2) {
    return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}

/* are there any points close to (x, y) ? */
function anyClose(x, y) {
    var result = false;
    $.each(points, function() {
        if (distance(x, y, this[0], this[1]) < 20) {
            result = true;
            return false; // break out of each
        }
    });
    return result;
}

canvas
var context = $('#canvas')[0].getContext('2d');

(x, y)
function drawDot(x, y) {
    context.fillStyle = "rgb(0,0,0)";
    context.beginPath();
    context.arc(x, y, 2, 0, Math.PI*2, true);
    context.fill();
}

click
#canvas
$('#canvas').click(function(e) {
    /* e will give us absolute x, y so we need to
        calculate relative to canvas position */
    var pos = $('#canvas').position();
    var ox = e.pageX - pos.left;
    var oy = e.pageY - pos.top;

    /* only draw dot and add to points list if
        no other points are close */
    if (!anyClose(ox, oy)) {
        drawDot(ox, oy);
        points.push([ox, oy]);
    }
    return false;
});

$('#clear-button').click(function() {
    points = [];
    context.clearRect(0, 0, 600, 400);
});

TRUE  = lambda a: lambda b: (a)
FALSE = lambda a: lambda b: (b)

(TRUE)(True)(False) == True
(FALSE)(True)(False) == False

AND   = lambda a: lambda b: (a)(b)(a)
OR    = lambda a: lambda b: (a)(a)(b)
NOT   = lambda a: lambda b: lambda c: (a)(c)(b)

(AND)(TRUE)(FALSE) == (FALSE)

(AND)(TRUE)(FALSE)(True)(False) == False

TRUE
FALSE
cons
car
cdr
CONS = lambda a: lambda b: lambda c: (c)(a)(b)
CAR  = lambda a: (a)(TRUE)
CDR  = lambda a: (a)(FALSE)

CAR
CDR
CONS
(CAR)((CONS)(1)(2)) == 1
(CDR)((CONS)(1)(2)) == 2

CONS
(True)(False)
UNCHURCH_BOOLEAN = (CONS)(True)(False)

(UNCHURCH_BOOLEAN)((NOT)(TRUE)) == False
(UNCHURCH_BOOLEAN)((OR)(TRUE)(FALSE)) == True

ZERO = FALSE
SUCC = lambda a: lambda b: lambda c: (b)((a)(b)(c))

ONE = (SUCC)(ZERO)
TWO = (SUCC)(ONE)
THREE = (SUCC)(TWO)
FOUR = (SUCC)(THREE)

def church_number(n):
    return SUCC(church_number(n - 1)) if n else FALSE

PLUS = lambda a: lambda b: lambda c: lambda d: (a)(c)((b)(c)(d))
MULT = lambda a: lambda b: lambda c: (b)((a)(c))
EXP  = lambda a: lambda b: (b)(a)

UNCHURCH_NUMBER = lambda a: (a)(lambda b: b + 1)(0)

(UNCHURCH_NUMBER)(ZERO) == 0
(UNCHURCH_NUMBER)(ONE) == 1
(UNCHURCH_NUMBER)(TWO) == 2

(UNCHURCH_NUMBER)((PLUS)(THREE)(TWO)) == 5
(UNCHURCH_NUMBER)((MULT)(THREE)(TWO)) == 6
(UNCHURCH_NUMBER)((EXP)(THREE)(TWO)) == 9

white-space
pre-wrap
pre
pre-wrap
pre
(add)(2)(2) == 4

(add)(add)(1)(2)(3) == 6
(add)(1)(add)(2)(3) == 6

(neg)(5) == -5
(neg)(neg)(5) == 5
(add)(3)(neg)(2) == 1

(add)(2)(2)
(add)(2)
def eval112100(a, b, c, d, e, f):
    return a(b(c(d(e))(f)))

add
add.args = 2
def eval1121(a, b, c, d):
    return lambda e: (
        eval11210 if e.args == 0 else
        eval11211 if e.args == 1 else
        eval11212 if e.args == 2 else
        ...
    )(a, b, c, d, e)

def combinatoric(n):
    def decorator(f):
        @wraps(f)
        def wrapper(x):
            if callable(x):
                return lambda y: combinatoric(n)(f)(x(y))
            elif n > 1:
                return combinatoric(n - 1)(wraps(f)(partial(f, x)))
            else:
                return f(x)
        return wrapper
    return decorator

@combinatoric(1)
def neg(x):
    return -x

@combinatoric(2)
def add(x, y):
    return x + y

wraps
add
add
wrapper
(add)(M)(5)
class Rel:
    def __init__(self, *attributes):
        self.attributes_ = tuple(attributes)
        self.tuples_ = set()
    def add(self, **tupdict):
        self.tuples_.add(tuple([tupdict[attribute] for attribute in self.attributes_]))
    def attributes(self):
        return set(self.attributes_)
    def tuples(self):
        for tup in self.tuples_:
            tupdict = {}
            for col in range(len(self.attributes_)):
                tupdict[self.attributes_[col]] = tup[col]
            yield tupdict

rel1 = Rel("ENO", "ENAME", "DNO", "SALARY")
rel1.add(ENO="E1", ENAME="Lopez", DNO="D1", SALARY="40K")
rel1.add(ENO="E2", ENAME="Cheng", DNO="D1", SALARY="42K")
rel1.add(ENO="E3", ENAME="Finzi", DNO="D2", SALARY="30K")

from collections import namedtuple
class Rel:
    def __init__(self, typename, field_names):
        self.tuple_type = namedtuple(typename, field_names)
        self.tuples = set()
    def add(self, **tupdict):
        self.tuples.add(self.tuple_type(**tupdict))
    def attributes(self):
        return set(self.tuple_type._fields)

rel1 = Rel("EMPLOYEE", "ENO ENAME DNO SALARY")
rel1.add(ENO="E1", ENAME="Lopez", DNO="D1", SALARY="40K")
rel1.add(ENO="E2", ENAME="Cheng", DNO="D1", SALARY="42K")
rel1.add(ENO="E3", ENAME="Finzi", DNO="D2", SALARY="30K")

>>> rel1.attributes()
set(['SALARY', 'ENAME', 'DNO', 'ENO'])
>>> rel1.tuples
set([EMPLOYEE(ENO='E1', ENAME='Lopez', DNO='D1', SALARY='40K'),
     EMPLOYEE(ENO='E3', ENAME='Finzi', DNO='D2', SALARY='30K'),
     EMPLOYEE(ENO='E2', ENAME='Cheng', DNO='D1', SALARY='42K')])
>>> for employee in rel1.tuples:
         print employee.ENO, employee.ENAME
E1 Lopez
E3 Finzi
E2 Cheng

>>> add_ = lambda x, y: x + y

>>> add_(5, 4)
9

>>> add = lambda x: lambda y: x + y

>>> add(5)(4)
9

>>> (add)(5)(4)
9

>>> add_(5, add_(2, 2))
9

>>> (add)(5)((add)(2)(2))
9

>>> (add)((add)(5)(2))
<function <lambda> at 0x755f0>
>>> (add)((add)(5)(2))(2)
9

(add)(5)(add)(2)
(add)(5)(add)(2)(2)

>>> M = lambda x: (x)(x)

(add)(M)(1)

layout bitmap too short: ASKScriptView 

ProgrammingError: value too long for type character(15)

./manage.py sql leonardo

\d leonardo_comment

author_ipaddress | character(15) 

author_ipaddress = models.IPAddressField(null=True)

"author_ipaddress" inet NULL

'HTTP_X_FORWARDED_FOR': '192.168.0.127, 12.34.56.78',

Firefox                       68.79%
Safari                        13.84%
Chrome                        5.88%
Internet Explorer             4.31%
Opera                         3.26%

canvas
def closest(x, y, control_points):
    closest = None
    distance = None
    for i, pt in enumerate(control_points):
        px, py = pt
        d = ((px - x) ** 2 + (py - y) ** 2)
        if d == 0:
            return i, 0
        if d < distance or not distance:
            closest = i
            distance = d
    return closest, distance

def voronoi(filename, size, control_points):
    def f(x, y):
        c, d = closest(x, y, control_points)
        # draw points in black
        if d < 5:
            return 0, 0, 0
        px, py = control_points[c]
        # just one way to generate a colour
        m = px * 255 / size
        n = py * 255 / size
        return m, 255 - ((m + n) / 2), n
    write_png(filename, size, size, f)

import random
from voronoi import voronoi
space_size = 200
num_control = 8
control_points = []
for i in range(num_control):
    x = random.randrange(space_size)
    y = random.randrange(space_size)
    control_points.append((x, y))
voronoi("voronoi.png", space_size, control_points)

    III . vi . IV . I V

cleese.img: KERNEL.BIN
        hdiutil create -size 5M -fs "MS-DOS" -layout NONE cleese
        mv cleese.dmg cleese.img
        mkdir -p mnt
        mount_msdos -o nosync `hdid -nomount cleese.img` ./mnt
        cp -r boot KERNEL.BIN ./mnt
        umount -f ./mnt
        rm -r ./mnt

cat boot/grub/stage1 boot/grub/stage2 > grub.img

setup (fd0)

update-image:
        mkdir -p mnt
        mount_msdos -o nosync `hdid -nomount cleese.img` ./mnt
        cp KERNEL.BIN ./mnt
        umount -f ./mnt
        rm -r ./mnt

>>> import re
>>> pattern = re.compile("a+b*\s\w?", 0x80)
max_repeat 1 65535
  literal 97
max_repeat 0 65535
  literal 98
in
  category category_space
max_repeat 0 1
  in
    category category_word

compile(pattern[, flags])

re.compile(pattern, re.DEBUG)

# sre extensions (experimental, don't rely on these)

export PREFIX=/Users/jtauber/Projects/cleese/toolchain
export TARGET=i386-elf

cd ~/Projects/cleese
curl -O http://ftp.gnu.org/gnu/binutils/binutils-2.19.tar.gz
mkdir toolchain
tar xvzf binutils-2.19.tar.gz
cd binutils-2.19
./configure --prefix=$PREFIX --target=$TARGET --disable-nls
make
make install
cd ..
curl -O http://ftp.gnu.org/gnu/gcc/gcc-4.2.4/gcc-core-4.2.4.tar.bz2
bunzip2 gcc-core-4.2.4.tar.bz2
tar xvf gcc-core-4.2.4.tar
cd gcc-4.2.4
./configure --prefix=$PREFIX --target=$TARGET --disable-nls --enable-languages=c --without-headers
make all-gcc
make install-gcc

def x(a):
    if callable(a):
        return lambda i: a(i)
    else:
        return a

def x(a):
    def xx(b):
        if callable(b):
            return lambda i: a(b(i))
        else:
            return a(b)
    return xx

def x(a):
    def xx(b):
        if callable(b):
            def xxx(c):
                if callable(c):
                    return lambda i: a(b(c(i)))
                else:
                    return a(b(c))
            return xxx
        else:
            return a(b)
    return xx

def min_sample(decimal):
    fl = float(decimal)
    assert 0 < fl < 1
    sig_digits = len(decimal) - 2
    for sample_size in range(1, (10 ** sig_digits) + 1):
        if round(round(fl * sample_size) / sample_size, sig_digits) == fl:
            return sample_size

#516c7a
#7291a1
#5f7f8f
#87a2af
#516c7a
#7291a1
#5f7f8f
#87a2af
(0, 0.0, 0.40 - 0.25)
(0, 0.0, 0.54 - 0.20)
(0, 0.0, 0.47 - 0.25)
(0, 0.0, 0.61 - 0.25)
def RGB2HSL(R, G, B):
    fR = float(R / 255.0)
    fG = float(G / 255.0)
    fB = float(B / 255.0)
    ma = max(fR, fG, fB)
    mi = min(fR, fG, fB)
    if ma == mi:
        H = 0
    elif ma == fR:
        H = (60 * ((fG - fB)/(ma - mi))) % 360
    elif ma == fG:
        H = 120 + 60 * ((fB - fR)/(ma - mi))
    elif ma == fB:
        H = 240 + 60 * ((fR - fG)/(ma - mi))
    L = (ma + mi) / 2
    if ma == mi:
        S = 0
    elif L <= 0.5:
        S = (ma - mi) / (2 * L)
    elif L > 0.5:
        S = (ma - mi) / (2 - 2 * L)
    return H, S, L

def HSL2RGB(H, S, L):
    if L < 0.5:
        q = L * (1 + S)
    elif L >= 0.5:
        q = L + S - (L * S)
    p = 2 * L - q
    hk = H / 360.0
    tR = hk + 0.333333
    tG = hk
    tB = hk - 0.333333

    def color(t):
        if t < 0:
            t += 1
        if t > 1:
            t -= 1
        if t < 0.166666:
            c = p + ((q - p) * 6 * t)
        elif 0.166666 <= t < 0.5:
            c = q
        elif 0.5 <= t < 0.666667:
            c = p + ((q - p) * 6 * (0.666667 - t))
        else:
            c = p
        return c

    R = int(color(tR) * 255)
    G = int(color(tG) * 255)
    B = int(color(tB) * 255)
    return R, G, B

write_png("test2.png", 50, 90, gradient([
    (0.43, (0xBF, 0x94, 0xC0), (0x4C, 0x26, 0x4C)), # top
    (0.85, (0x4C, 0x26, 0x4C), (0x27, 0x13, 0x27)), # bottom
    (1.0,  (0x66, 0x66, 0x66), (0xFF, 0xFF, 0xFF)), # shadow
]))

add :: Int -> Int -> Int

Vector -> Real

Vector -> Vector -> Real

http://pinax.hotcluboffrance.com

def gen1(start, stop, step):
    n = start
    while n <= stop:
        yield n
        n += step

for x in zip(gen1(10, 20, 2), gen1(10, 25, 3)): print sum(x),

def mixer1(*generators):
    return (sum(x) for x in izip(*generators))

for x in mixer1(gen1(10, 20, 2), gen1(10, 25, 3)): print x,

gen2 = lambda **kwargs: partial(gen1, **kwargs)

partial_gen = gen2(stop=20, step=2)

partial_gen(start=10)

def mixer2(*generators, **kwargs):
    return mixer1(*[gen(**kwargs) for gen in generators])

for x in mixer2(gen2(stop=20, step=2), gen2(stop=25, step=3), start=10): print x,

gen2 = lambda **kwargs: partial(gen1, **kwargs)

def mixer3(*generators, **kwargs):
    return (sum(x) for x in izip(*[gen(**kwargs) for gen in generators]))

<script type="text/javascript" src="/static/jquery.js"></script>
<script type="text/javascript">
    function scrollTo(selector) {
        var targetOffset = $(selector).offset().top;
        $('html,body').animate({scrollTop: targetOffset}, 500);
    }
    $(document).ready(function() {
        $('#add_comment_toggle').click(function() {
            $('form.add_comment').slideToggle();
            scrollTo('form.add_comment');
            return false;
        });
        {% if comment_error %}
        $('form.add_comment').show();
        scrollTo('.comment_error');
        {% endif %}
    });
</script>

$ history | awk '{print $2}' | sort | uniq -c | sort -rn | head
 120 cd
 111 ls
  78 python
  73 svn
  17 mate
  14 less
  11 rm
  11 mv
   7 mkdir
   5 ssh

thunk = lambda name, *args: lambda: name(*args)

def _trampoline(bouncer):
    while callable(bouncer):
        bouncer = bouncer()
    return bouncer

trampoline = lambda f: lambda *args: _trampoline(f(*args))

identity = lambda x: x

_factorial = lambda n, c=identity: c(1) if n == 0 else thunk(_factorial, n - 1, lambda result: thunk(c, n * result))

factorial = trampoline(_factorial)

print factorial(100000)

thunk = lambda name: lambda *args: lambda: name(*args)

_factorial = lambda n, c=identity: c(1) if n == 0 else thunk(_factorial)(n - 1, lambda result: thunk(c)(n * result))

def a(x, m):
    for i, o in enumerate(sorted(x)):
        if o > m:
            break
    return i

def a(x, m):
    return len([o for o in x if o <= m])

drwxr-xr-x   2 jtauber  staff   68 Mar 18 17:57 A
drwxr-xr-x   3 jtauber  staff  102 Mar 18 17:58 B
lrwxr-xr-x   1 jtauber  staff    3 Mar 18 17:58 C -> B/C

jtmbp:TEST jtauber$ cd B

jtmbp:B jtauber$ ../A
-bash: ../A: is a directory

jtmbp:B jtauber$ cd ..

jtmbp:TEST jtauber$ cd C

jtmbp:C jtauber$ ../A
-bash: ../A: No such file or directory
jtmbp:C jtauber$ ../../A
-bash: ../../A: is a directory

jtmbp:C jtauber$ cd ../A
jtmbp:A jtauber$ 

from collections import defaultdict
counts = defaultdict(int)

counts[key] += 1

sorted(counts, key=lambda i: counts[i])

sorted(counts, key=counts.get)

dict_set = {}

if key not in dict_set:
    dict_set[key] = set()
dict_set[key].add(item)

dict_set = {}

dict_set.setdefault(key, set()).add(item)

from collections import defaultdict

dict_set = defaultdict(set)

dict_set[key].add(item)

Windows	60.3%
Linux	20.5%
Macintosh	18.3%

Windows	69.4%
Macintosh	16.9%
Linux	12.9%

Firefox	54.6%
Internet Explorer	24.7%
Safari	9.9%
Mozilla	6.5%
Opera	2.5%

Firefox	44.8%
Internet Explorer	37.1%
Safari	9.6%
Opera	3.4%
Mozilla	2.21%

James Tauber's Blog 2008

Judging Criteria

License

Prize

Comments vs Trackbacks

Paucity of Inbound Links

Blogs as Conversations

Blog to Contribute to Your Tribe

Planetary Effects

The Twitter Effect

Why I Blog

How I View Blogging As Reader

How I View Blogging As a Writer

In Conclusion

Phase 1

Phase 2

Phase 3

Phase 4

Best Joke I Fell For

Best Joke I Didn't Fall For

Best Joke With Just A Touch Of "Maybe They Aren't Completely Joking"

Method 1

Method 2

Method 3