 Mar 3, 2008

JPC<br/>

At first glance, it may seem like a simple thing to generate random numbers. In fact, you may think that humans could do this easily by, for instance, just writing sequences of 0’s and 1’s in a stream of consciousness. By following this link, you will be able to write a sequence of one hundred 0’s and 1’s that will be analyzed using a few of the tests we’ll encounter later in this article. If your sequence passes these tests, it shares several properties with truly random sequences. However, you will most likely find it difficult to write a sequence that passes these tests. Humans have a difficult time creating random sequences by trying to “act randomly.”

Cobra Language (pdf)<br/>

The Nature of Lisp<br/> Tons and tons about everything.<br/>

After describing the circumstances surrounding each famous assassination, Housinger offered his opinion on whether modern medicine could have saved those high-profile victims if the attack had occurred in Billings today.

OpenCog<br/>

Song of Ice and Fire FAQ and WP article<br/> Something to tide me over until A Dance with Dragons<br/>

When the lightbulb came on, it was blinding. I just needed to use the result of lookup in a way that forced the Haskell’s type inference to put it into the Maybe monad! To do this, all you have to do is compare to Just pass instead of pass.
``````
import re
from itertools import *
iterpreter = (lambda s: (
(lambda g: lambda env, exp: g(g)(env, exp))
(lambda g: (lambda interpret:(
lambda env, exp:{
list:lambda exp:(
(exp[:1]==["lambda"]) and
(lambda env: lambda params:
(lambda nenv: [interpret(nenv, e)
for e in exp[2:]][-1])
(lambda x: dict(zip(exp, params)).get(x, False)
or env(x)))(env)
or (lambda pexp: pexp(pexp[1:]))([interpret(env, e)
for e in exp])),
str:lambda exp: env(exp), int:lambda exp: exp
}[type(exp)](exp)))(lambda env, exp:g(g)(env, exp))))
(lambda x:{"sum":(lambda params: sum(params))}.get(x, False),
reduce(lambda env, v:
(v==")" and
(lambda:((lambda i:env[:i]+[env[i+1:]])
(len(env)-env[::-1].index("(")-1)))
or (lambda:env+[v]))(),
[(i==2 and int(e[i]) or e[i]) for e, i in
[(e,sum([c*(i is not "") for i, c in zip(e, count())]))
for e in re.findall(r"(\()|(\))|(\d+)|(\w+)",s)]],
[])))

s = "((lambda (a b) (sum a (b))) 1 (lambda () 8))"
v = iterpreter(s)
print v
``````

Mall Ninjas and Ask a Mall Ninja<br/>

PyScheme<br/>

Rapid RESTful Rails<br/>

The myth of the duck<br/>

There is nothing in the concept of dynamic typing or duck typing that requires that interfaces (or even classes) cannot be specified. But, instead, Ruby pushes work onto programmers that the compiler and runtime system ought to be doing automatically.

Programmers at Work<br/>

Macro creation in Arc is, somewhat surprisingly, not part of the ac.scm foundation, but is implemented in arc.arc out of annotated functions.

The Arc Debate<br/>

Continuation-based web programming lets you program in a natural, structured programming style. You avoid the spaghetti code of html links you have to write.

<br/>

BookletCreator<br/>

The golden era of the 8-bit computer game began around 1982 and continued until about 1990.

Heathkit HERO and Robot Gallery<br/>

Semantic Web is open<br/>

Douchebaggery<br/>

-m