or learn more

Linkage 2008.03.03

Mar 3, 2008

Zed: You used Ruby for what?<br/>


Clojure data structures<br/>

Random Numbers: Nothing Left to Chance<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/>

Could doctors save Honest Abe?<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.


Web security blunders<br/>

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

Python getstate, setstate<br/>

Haskell’s type inference<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[1], params)).get(x, False)
                                or env(x)))(env)
                or (lambda pexp: pexp[0](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:]])
            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

Lisp in a single expression<br/>

Mall Ninjas and Ask a Mall Ninja<br/>


Optimizing C++ virtual functions<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.

Extra Numerical Types for Common Lisp<br/>

Programmers at Work<br/>

Russell and Norvig’s PyAIMA<br/>

Arc internals: macros<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.

The Graphing Calculator Story<br/>



Game graphics in 8-bits<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/>

Mind mapping data to drive your application<br/>


Archive of research papers<br/>


No Comments, Comment or Ping

Reply to “Linkage 2008.03.03”