his lisp a bit more losely these days.

See BE KIND AND REWIND, 2012 and apparently SHOOTER (haven’t seen SHOOTER, but I hear things.)

There isn’t much to say other than…”Wow he’s got a killer lisp.”

I don’t have anything against him, he seems pretty cool and all. So I’m not going to bitch about him.

Good luck with that freakish spitolicious lisp. FREAK!

xoxo

Nice Girl

Most people reading this will know that Structure and Interpretation of Computer Programs (SICP) by Abelson and Sussman is one of the most well known and recommended books when it comes to core Computer Science, algorithms, and functional programming. Suffice it to say, if you want to explore these areas and enhance your programming on a level beyond knowing the latest framework, check out this book. It’s freely available online, as well as recordings of lectures the authors gave.

Now, in case that’s not nerdy enough for you, I found a version in texinfo yesterday. Complete with all graphics converted to ASCII art. Yes, kinda scary, but it rocks: have your Emacs display an info buffer with the book and a Scheme or CL REPL to play with the book’s code and work on the exercises. Just move around the book and evaluate the code snippets there. Neat!

I guess that means I have to resume my project of working through the exercises. I’m not even sure where my first couple solutions are…

I think this is the first real Clojure job posting I’ve seen. Check it out: 3 years experience required (in Lisp and other languages, natch).

SICP Exercise 4.29

(define (fib n)
  (cond ((= n 0) 0)
        ((= n 1) 1)
        (else (+ (fib (- n 1)) (fib (- n 2))))))

(let ((t0 0) (t1 0))
  (set! t0 (get-universal-time))
  (fib 20)
  (set! t1 (get-universal-time))
  (- t1 t0))
; 67 without memorization
; 12 with memorization

;;; L-Eval input:
(square (id 10))
;;; L-Eval value:
100
;;; L-Eval input:
count
;;; L-Eval value:
1 ; with memorization, (id 10) is called once.
2 ; without memorization, (id 10) is called twice

SICP Exercise 4.28

If the value of the operator is not forced, this will fail because f is a thunk.

(let ((f (lambda (x) (* x x))))
  (f 2))
;Unknown procedure type -- APPLY (thunk (lambda ... ...) (...))

SICP Exercise 4.27

(define w (id (id 10)))
;;; L-Eval input:
count
;;; L-Eval value:
1
;;; L-Eval input:
w
;;; L-Eval value:
10
;;; L-Eval input:
count
;;; L-Eval value:
2

Defining w as (id (id 10)) will cause the eval procedure to be applied to (id (id 10)). So the outer id procedure will be evaluated. And the count variable will be set to 1. Printing the value of w will cause the inner id procedure to be evaluated. So the final value of count will become 2.

SICP Exercise 4.26

It is shown below how to implement unless as a special form.

(define (eval exp env)
; ......
        ((unless? exp) (eval (unless->if exp) env))
; ......
)

(define (unless? exp) (tagged-list? exp 'unless))
(define (unless-clauses exp) (cdr exp))
(define (unless-condition clauses) (car clauses))
(define (unless-usual-value clauses) (cadr clauses))
(define (unless-exceptional-value clauses) (caddr clauses))
(define (unless->if exp)
  (expand-unless-clauses (unless-clauses exp)))
(define (expand-unless-clauses clauses)
  (make-if (unless-condition clauses)
           (unless-exceptional-value clauses)
           (unless-usual-value clauses)))

For the sake of argument, the following code will fail unless unless is implemented as a procedure.

(define (foo f condition value-1 value-2)
  (f condition value-1 value-2))

(foo unless (> 2 10) 1 2)
; Unbound variable unless
;   because unless is a special form

(define (unless-proc condition usual-value exceptional-value)
  (if condition exceptional-value usual-value))
(foo unless-proc (> 2 10) 1 2)
; 1

SICP Exercise 4.25

The code does not work in a normal-order language. The maximum recursion depth will be reached because the evaluation of the second argument of unless will proceed forever.

SICP Exercise 4.24

Below is the code I use for the experiment.

(define (factorial n)
  (if (= n 1)
      1
      (* (factorial (- n 1)) n)))

(let ((t0 0) (t1 0))
  (define (loop i n)
    (factorial 1234)
    (if (< i n)
        (loop (+ i 1) n)))
  (set! t0 (get-universal-time))
  (loop 0 200)
  (set! t1 (get-universal-time))
  (- t1 t0))

The results are 78 and 41 for the original metacircular evaluator and the improved evaluator, respectively. So the original evaluator spends about 37 seconds on repeating syntactic analysis.

SICP Exercise 4.23

The version of analyze-sequence in the text produces more efficient execution procedure than Alyssa’s version.

The execution procedure produced by the analyze-sequence procedure in the text looks like this:

(lambda (env)
  ((lambda (env)
     ((lambda (env)
        (proc1 env)
        (proc2 env))
      env)
     (proc3 env))
   env)
  (proc4 env))

Here, proc1, proc2, proc3 and proc4 are the resulting procedures of applying the analyze procedure to individual expressions of a sequence.

The execution procedure produced by Alyssa’s version looks like this:

(lambda (env)
  (execute-sequence (proc1 proc2 proc3 proc3) env))

When the above execution procedure is run, procedure execute-sequence is called. Note that procedure execute-sequence contains a cond expression and an iteration process. So it will be less efficient.

SICP Exercise 4.22

(define (analyze exp)
; ......
        ((let? exp) (analyze (let->combination exp)))
; ......
)

See SICP Exercise 4.6 for procedures let? and let->combination.

Tim Lopez published an elegant and tiny LISP interpreter for Python on his blog. Inspired by Norvig’s Paradigms of Artificial Intelligence Programming. I developed an interpreter as well as a compiler for LISP in Python. Hence the interpreter is quite similar to Tim Lopez’ implementation, I will present sinC, the s-expression input compiler. SinC compiles my own proprietary LISP dialect to Python source code.

The reader

def read(sexpr):
    grammar = r"(\()|(\))|([^()\s]+)|(\s+)"

    def sequenceBuilder(match):
        leftbracket, rightbracket, atom, whitespace = match.groups()
        if(leftbracket): return '['
        elif(rightbracket): return ']'
        elif(atom): return '"' + atom + '"'
        elif(whitespace): return ','
    return eval(re.sub(grammar, sequenceBuilder, sexpr), None, None)

The reader converts a s-expression in a corresponding Python list representing the syntax tree. For example:

(print (+ 1 2)) -> ["print", ["+", "1", "2"]]

Only alphanumeric characters are allowed in symbols. Especially no strings or brackets. They would break the reader.

The evaluator

def comp(tree):
    if(type(tree) == list):
        if(tree[0] in specialForms):
            return specialForms.get(tree[0])(tree[1:])
        else:
            args = map(lambda x: comp(x), tree[1:])
            return tree[0] + "(" + ",".join(args) + ")"
    else:
        return tree

The evaluator parses the syntax tree recursively. The first symbol in a list is always interpreted as a function and the remaining symbols as its paramters. If the symbol representing the function is found in specialForms, a Python function is called, returning the generated Python source code as a string.

My dialect has the following special forms:

set, first, rest, cons, quote, eq, cond

Additionally, I implemented the algebraic operators ‘+’, ‘-’, ‘*’ and ‘/’ as special forms for convenience reasons.

Except for the set function, every special form is side effect-free and can be written as a Python lambda-expression. In particular, the evaluator is just nesting calls to pure Python functions.

The transcription step and the set function

def set(rest):
    if(len(rest) == 2): # a variable
        globalScope.append((comp(rest[0]), comp(rest[1])))
    else: # a function
        globalScope.append((comp(rest[0]), "lambda " + comp(rest[1]).strip("[]") +": " + comp(rest[2])))
    return "None"

The set function takes care of global variable and function bindings. In Python, such a binding is not possible in a lambda expression. So we evaluate this function to None and store the binding for later use in a globalScope. After parsing the syntax tree, we first generate Python code for the global Scope to establish the bindings and after that append the function calls generated by the comp function.

The whole compiler looks like this:

#!/usr/bin/env python

import re
import sys

errfile = "<sinc>"

def read(sexpr):
    grammar = r"(\()|(\))|([^()\s]+)|(\s+)"

    def sequenceBuilder(match):
        leftbracket, rightbracket, atom, whitespace = match.groups()
        if(leftbracket): return '['
        elif(rightbracket): return ']'
        elif(atom): return '"' + atom + '"'
        elif(whitespace): return ','
    return eval(re.sub(grammar, sequenceBuilder, sexpr), None, None)

def set(rest):
    if(len(rest) == 2): # a variable
        globalScope.append((comp(rest[0]), comp(rest[1])))
    else: # a function
        globalScope.append((comp(rest[0]), "lambda " + comp(rest[1]).strip("[]") +": " + comp(rest[2])))
    return "None"

specialForms = {
    "set": set,
    "first": lambda rest: "(" + comp(rest[0]) + ")[0]",
    "rest": lambda rest: "(" + comp(rest[0]) + ")[1:]",
    "cons": lambda rest: "[" + comp(rest[0])+"] + " + comp(rest[1]),
    "quote": lambda rest: "[" + ", ".join(map(lambda x: comp(x), rest)) + "]",
    "eq": lambda rest: "("+comp(rest[0])+" == "+comp(rest[1])+")",
    "cond": lambda rest: "("+comp(rest[1])+" if "+comp(rest[0])+" else "+comp(rest[2])+")",
    "+": lambda rest: comp(rest[0])+" + "+comp(rest[1]),
    "-": lambda rest: comp(rest[0])+" - "+comp(rest[1]),
    "*": lambda rest: "("+comp(rest[0])+") * ("+comp(rest[1])+")",
    "/": lambda rest: "("+comp(rest[0])+") / ("+comp(rest[1])+")"
}

globalScope = []
def comp(tree):
    if(type(tree) == list):
        if(tree[0] in specialForms):
            return specialForms.get(tree[0])(tree[1:])
        else:
            args = map(lambda x: comp(x), tree[1:])
            return tree[0] + "(" + ",".join(args) + ")"
    else:
        return tree

def transcribe(sexpr):
    tree = read(sexpr)
    if(type(tree) == tuple):
        transcripts = []
        for node in tree:
            transcripts.append(comp(node))
        transcript = "\n".join(transcripts)
    else:
        transcript = comp(tree)

    initCode = []
    for expr in globalScope:
        initCode.append(str(expr[0]) + " = " + str(expr[1]) + "\n")
    return "".join(initCode) + transcript

def sinc(sexpr):
    transcript = transcribe(sexpr)
    print transcript

def repl():
    while(True):
        print "sinC> ",
        sys.stdout.flush()
        line = sys.stdin.readline().lstrip(">").strip()
        try:
            sinc(line)
        except:
            print "???"

if __name__ == "__main__":
    if(len(sys.argv) == 2):
        f = open(sys.argv[1])
        sinc(f.read())
        f.close()

    else:
        print "This is sinC-alpha. Interactice LISP to Python compiler."
        print
        repl()

Call it with a sourcefile as argument or with no arguments to compile s-expressions interactively (used this a lot for testing).

Demo program: Series summation

As a little demo we calculate the series summation of a range and print the result:

(set sum x (cond (eq x 0) 0 (+ (sum (- x 1)) x)))

(set range (quote begin end) (cond (eq begin end) (quote) (cons begin (range (+ begin 1) end))))
(set len list (cond (eq list (quote)) 0 (+ 1 (len (rest list)))))
(set map (quote fun list) (cond (eq list (quote)) (quote) (cons (fun (first list)) (map fun (rest list)))))

(set testrange (range 1 8))

(print (len testrange))
(print testrange)
(print (map sum testrange))

Call it

$ ./sinc sum.sinc  | python
7
[1, 2, 3, 4, 5, 6, 7]
[1, 3, 6, 10, 15, 21, 28]

and it works! The generated code looks like this:

sum = lambda x: (0 if (x == 0) else sum(x - 1) + x)
range = lambda begin, end: ([] if (begin == end) else [begin] + range(begin + 1,end))
len = lambda list: (0 if (list == []) else 1 + len((list)[1:]))
map = lambda fun, list: ([] if (list == []) else [fun((list)[0])] + map(fun,(list)[1:]))
testrange = range(1,8)
None
None
None
None
None
print(len(testrange))
print(testrange)
print(map(sum,testrange))

SICP Exercise 4.21

; The evaluation proceeds as follows
((lambda (n)
   ((lambda (fact)
      (fact fact n))
    (lambda (ft k)
      (if (= k 1)
          1
          (* k (ft ft (- k 1)))))))
 10)

;-->

((lambda (fact)
   (fact fact 10))
 (lambda (ft k)
   (if (= k 1)
       1
       (* k (ft ft (- k 1))))))

;-->

((lambda (ft k)
   (if (= k 1)
       1
       (* k (ft ft (- k 1)))))
 (lambda (ft k)
   (if (= k 1)
       1
       (* k (ft ft (- k 1)))))
 10)

;-->

(if (= 10 1)
    1
    (* 10 ((lambda (ft k)
             (if (= k 1)
                 1
                 (* k (ft ft (- k 1)))))
           (lambda (ft k)
             (if (= k 1)
                 1
                 (* k (ft ft (- k 1)))))
           9)))

;-->
(* 10 ((lambda (ft k)
         (if (= k 1)
             1
             (* k (ft ft (- k 1)))))
       (lambda (ft k)
         (if (= k 1)
             1
             (* k (ft ft (- k 1)))))
       9))

;......

The following expression computes the 10th Fibonacci number.

((lambda (n)
   ((lambda (fibo)
      (fibo fibo n))
    (lambda (fb k)
      (cond ((= k 0) 0)
            ((= k 1) 1)
            (else (+ (fb fb (- k 1))
                     (fb fb (- k 2))))))))
 10)

An alternative definition of f:

(define (f x)
  ((lambda (even? odd?)
     (even? even? odd? x))
   (lambda (ev? od? n)
     (if (= n 0) true (od? ev? od? (- n 1))))
   (lambda (ev? od? n)
     (if (= n 0) false (ev? ev? od? (- n 1))))))

SICP Exercise 4.20

(define (eval exp env)
; ......
        ((letrec? exp) (eval (letrec->let exp) env))
; ......
)

(define (letrec? exp) (tagged-list? exp 'letrec))
(define (make-unassigned-letrec vars)
  (if (null? vars)
      '()
      (cons (list (car vars) ''*unassigned*)
            (make-unassigned-letrec (cdr vars)))))
(define (make-set-letrec vars exps)
  (if (null? vars)
      '()
      (cons (list 'set! (car vars) (car exps))
            (make-set-letrec (cdr vars) (cdr exps)))))
(define (letrec->let exp)
  (let* ((assi (let-assignment exp))
         (lvars (let-var assi))
         (lexps (let-exp assi)))
    (cons 'let (cons (make-unassigned-letrec lvars)
                     (append (make-set-letrec lvars lexps)
                             (let-body exp))))))

See SICP Exercise 4.6 for the definitions of let-assignment, let-body, let-var and let-exp.

I am going to skip the environment diagram. But I will explain why Louis Reasoner is wrong. Note that

  (let ((even?
         (lambda (n)
           <body of even? including call to odd?>)
        (odd?
         (lambda (n)
           <body of odd? including call to even?>)))
        <rest of body of f>))

is equivalent to

  ((lambda (even? odd?)
     <rest of body of f>)
   (lambda (n) <body of even? including call to odd?>)
   (lambda (n) <body of odd? including call to even?>))

There are three lambda functions in the above piece of code. The arguments even? and odd? of the first lambda function have no relationship whatsoever with odd? in the body of the second lambda function and even? in the body of the third lambda function. The way I see it, the arguments even? and odd? of the first lambda function are just names. We can rename them to foo and bar if we like. Therefore the above code will not work. Louis Reasoner is wrong.

“The Vengeance Formulation”

November 23rd, 2009

Last week, the show chose to split its story between something that works (Sheldon and Penny) and something that doesn’t (Leonard, Wolowitz and Raj on their own), resulting in an episode that was a mixed bag (although perhaps a bit better than I gave it credit for, as my distaste for the latter perhaps overshadowed the strength of the former).

This week, however, the show returns to more of an ensemble structure, and while nothing reaches the heights of adhesive ducks it’s a solid episode as a whole because it manages a reasonably emotional Wolowitz storyline with a cheap but not ineffective Sheldon storyline. There was every chance for these two elements to go off the rails (based on both the show’s tradition of misusing Wolowitz and the presence of Kripke), so the fact that they stayed moderately in orbit makes this a victory, if not exactly an overwhelming success.

When it comes to Wolowitz, I strongly believe that less is more, unless the show decides to do what they did here and turn Wolowitz from obnoxious to introspective. While interacting with a fantasy version of Katee Sackhoff isn’t genius or anything, it allows Wolowitz to stop acting like he runs the joint and actually come to terms with his delusions. The naked bathtub fantasy version of Katee Sackhoff spoke the truth, and while there were signs of the old Wolowitz (feeling more slighted by the fact that Sackhoff’s date was tall as opposed to handsome, since he actually believes he is handsome) for the most part he was honest with himself. Sure, he messes up his romantic overtures to Bernadette, but he was legitimately charming during his tone deaf wailing at episode’s end, and the fact that Howard was given any continuity at all in terms of a relationship is such a huge step forward that I think it’s commendable.

It also shows how even Howard, who to this point one couldn’t imagine in a relationship, is effectively getting the relationship stories that Leonard has been given in the past, except ones that are actually funny. While Sheldon in a relationship might be too ludicrous, and Raj in a relationship has been made impossible by the alcohol gimmick, Howard and Leonard are both effectively eligible, but the show has always resisted treating Howard seriously (by having his actual skills be so outmatched by his capability), sending him off to gothic night clubs and moving him away from legitimate couplings. However, while Leonard’s relationships tended to be neurotic and sort of dull, Howard’s relationship is (to use his own word) quirky in a way that adds a fun dynamic to the show. Sure, I’m not a huge fan of his relationship with his shrill mother, and I could have used less talk about what he was doing in the tub, but for once the show didn’t actually treat him like a horny 15-year old, and for this I was most grateful and certainly entertained.

As for the other half of the episode, it really comes down to how funny you find someone talking in a high-pitched voice and how you feel about Eric Kripke. Twitter user SnowDan mentioned that he likes Kripke because it’s ironic that the university bully has a lisp (which would, outside of that world, make him subject to bullying), but I’ve always felt like that joke has been long ago used up in favour of dialogue that calls attention to the lisp unnecessarily. The idea of Sheldon having a nemesis is funny on its own, which is why Leslie Winkle was more interesting to me (especially because the gender politics of it all wreaked havoc with Sheldon’s already problematic ability to respond in kind) than someone both more dully mean-spirited and less witty. Beyond the broad irony, that for me was not clever enough to sustain the character beyond a first appearance, the character is a normal guy who has a lisp, and most of the humour derived from the character has been through how he says it rather than what he says.

But I thought that this week’s story was less let down by Kripke (who on only a few occasions fell into traps like “Wiot”) and more by a single decision. I like the general principle of the storyline, with Sheldon’s big moment turning into an embarrassment and his attempt at vengeance going horribly, horribly wrong. There’s something very solid about that, and even when I know that we’re never going to get to see the aftermath (since everything will, conveniently for Sheldon, reset next week) the uncontrollable chaos of the final sequence was even communicated through webcam. However, where the storyline suffered was that the joke of Sheldon and his high-pitched voice didn’t appear to actually be Jim Parsons with helium, nor Jim Parsons faking such a voice. Unless I’m mistaken, the voice was looped in during post-production, which if true is a huge disappointment, and took me out of the scene regardless.

There were a number of things in this episode that bugged me a bit, like how the other guys so quickly joined in on laughing at Sheldon on the radio (as it was national radio, after all), or how Raj was too busy making fun of Sheldon to help Leonard try to get him out of bed, or how Penny’s self-awareness about her relationship with Leonard didn’t extend to her realizing that they have no actual chemistry and that sitting in close proximity to each other does not a relationship make. But none of these elements felt like they were the point of their respective storylines: Sheldon’s embarrassment was necessary to get to his vengeance gone awry, and Penny needed to be aware of her own relationship so she could objectively view Wolowitz’s and be able to ward off Bernadette.

And those two storylines worked, coming to solid conclusions that were either narratively satisfying or humorously destructive. They didn’t offer any particular comic highs, but they didn’t offend any of my sensibilities either, so I can’t really complain.

Cultural Observations

• Katee Sackhoff in the tub makes me realize that some part of me feels obligated to watch 24 this season with her being part of the cast.
• It says something about the show’s conditioning to not bother remembering things from previous episodes that it took me a while to figure out if Bernadette was actually the person on whom Wolowitz went on a double date a while back. However, I’ll give them this: her trait of not getting Wolowitz’s jokes was memorable enough that I was at least 75% sure.
• While some small moments bugged me, I thought Sheldon nailing the whoopie cushion gag on Leonard really did prove its comic validity.
• And just in case we weren’t sure, apparently Raj is delicious caramel.
• If Sepinwall writes a review, I think “as soon as I play Cylon and Colonist” seems like the obvious “after the jump” line. We’ll see if I’m right.

A good interview question: what is the value of the following form?

CL-USER> (mapcar #'funcall
		 (loop
		    as i from 1 upto 3
		    collect (lambda () i)))
???

“The Truth Is Out There” where macroexpand lives.

CL-USER> (macroexpand `(loop for i from 1 upto 3 collect (lambda () i)))
(BLOCK NIL
  (LET ((I 1))
    (DECLARE (TYPE (AND REAL NUMBER) I))
    (SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD (#:LOOP-LIST-HEAD-1070
                                              #:LOOP-LIST-TAIL-1071)
      (SB-LOOP::LOOP-BODY NIL
                          (NIL NIL (WHEN (> I '3) (GO SB-LOOP::END-LOOP)) NIL)
                          ((SB-LOOP::LOOP-COLLECT-RPLACD
                            (#:LOOP-LIST-HEAD-1070 #:LOOP-LIST-TAIL-1071)
                            (LIST (LAMBDA () I))))
                          (NIL (SB-LOOP::LOOP-REALLY-DESETQ I (1+ I))
                           (WHEN (> I '3) (GO SB-LOOP::END-LOOP)) NIL)
                          ((RETURN-FROM NIL
                             (SB-LOOP::LOOP-COLLECT-ANSWER
                              #:LOOP-LIST-HEAD-1070)))))))
T
CL-USER>

Therefore i is a variable and different values are bound to it during the loop. This is explained very well here.

The good candidate answers (4 4 4), because it’s clearly stated on previous page, how this type of loop terminates.

For biomedical devices, Software/Firmware Developer – Lisp (Contract to Hire).

Um dos maiores problemas da sociedade moderna é a dificuldade de locomoção diária, a maioria das pessoas passa horas em seus carros, ou em meios de transporte públicos para irem de lugar a outro. Há alguns anos atrás quando morava na zona norte de São Paulo e trabalha na zona sul, essa era minha realidade. Uma vez que naquela época passar por isso era inevitável procurei formas de fazer com esse tempo pudesse de alguma forma torna-se produtivo, foi então que comecei a ouvir à podcasts.

iPod FM radio remote por dan taylor

De acordo com a Wikipedia, Podcasting é uma forma de publicação de arquivos de mídia digital (áudio, vídeo, foto, etc.) pela Internet, através de um feed RSS, que permite aos utilizadores acompanhar a sua atualização. Assim, é possível o acompanhamento e/ou download automático do conteúdo de um podcast.

Neste post apresentarei os podcasts aos quais escuto e os episódios principais para que você ouça. Sugiro que você utilize o iTunes para inscrever-se nos podcasts e sincronizar com seu iPod.

Desenvolvimento Ágil

por pcalcado

Podcast da ImproveIt

por Vinícius Teles
http://improveit.com.br/podcast
Português

• Entrevista com Alisson Vale da Phidelis
• Entrevista com Alexandre Magno na Série Experiências Ágeis
• Entrevista com Carlos Barbieri sobre o MPS.BR
• Entrevista com a equipe da Ancar na Série Experiências Ágeis

AgilCast

Por AgilCoop
http://agilcoop.incubadora.fapesp.br/portal/agilcast
Português

• Uma Visão Geral Sobre Scrum
• Testes Automatizados
• Bancos de dados ágeis e refatoração de bancos de dados

Agile Toolkit Podcast
http://agiletoolkit.libsyn.com
Inglês

• Tom Goulet – Cucumber, Ruby and the transition to Generalizing Specialist (2009)
• Jim Miller – The Product Owner Role and Business Alignmnet
• Tips and Advice – Retrospectives

ThoughtWorks Podcast

http://www.thoughtworks.com/what-we-say/podcasts.html
Inglês

Open Source

FLOSS Weekly

por Leo Laport, Jono Bacon e Randal Schwartz
Inglês

• Entrevista com Kent Beck sobre Extreme Programming (XP)
• Entrevista com Linus Torvalds, o criador do Linux e do Git
• Entrevista com David Heinemeier Hansson criador do Ruby On Rails
• Entrevista com Tim O’Reilly, fundador e CEO da  O’Reilly Media
• Entrevista com John Resig criador e líder do Projeto jQuery
• Entrevista com Jan Lehnardt evangelista do projeto CouchDB
• Entrevista com  Jacob Kaplan-Moss criador do Django
• Entrevista com Bruno Souza sobre o OpenJDK
• Entrevista com Ward Cunningham inventor do Wiki e grande Personalidade da Comunidade Ágil
• Entrevista com  D. Richard Hipp criador do SQLite
• Entrevista com Nate Koechley sobre o Yahoo User Interface Library (YUI)
• Entrevista com Junio Hamano, Mantenedor do Git
• Entrevista com Rasmus Lerdorf, criador do PHP
• Entrevista com Guido van Rossum, Criador do Python
• Entrevista com o fundador da Wikipedia, Jimmy Wales

Java

HorecaExpo - Java por bramloquet

JavaPosse

Por Tor Norbye, Carl Quinn, Dick Wall e Joe Nuxoll
Inglês
http://www.javaposse.com

Java Technology Insider

Inglês
http://www.javaworld.com/podcasts/jtech

• Rod Johnson: SpringSource and the future of Spring (2008)

Grails Podcast

Por Glen Smith e Sven Haiges
http://grailspodcast.com

Ruby

Ruby on Rails por Andrew*

Rails Envy

Por Jason Seifer e Gregg Pollack
Inglês
http://railsenvy.com

Rails Podcast

por Geoffrey Grosenbach
Inglês
http://podcast.rubyonrails.com/

• Entrevista com David Heinemeier Hansson (2005)
• Entrevista com Dave Thomas (2005)
• Entrevista com Chad Fowler (2005)
• Entrevista com Obie Fernandez (2006)
• Entrevista com Dave Thomas e Mike Clark (2006)

Rubiverse Podcast

Por Mike Moore
Ingles
http://rubiverse.com

• Dave Hoover on Software Crafsmanship (2009)
• Obie Fernandez on the Rails Maturity Model (2009)
• Ola Bini on Polyglot Programming (2008)

JavaScript

jQuery Podcast

Português
http://blog.jquery.com/2009/11/13/announcing-the-official-jquery-podcast/

Gadgets

GeekBrief TV

por Cali Lewis
Inglês
http://www.geekbrief.tv

Software

Desk por Guillermo Esteves

Pragmatic Podcasts

por Pragmatic Bookshelf
Inglês
http://www.pragprog.com/podcasts

• Chad Fowler on the Passionate Programmer
• Fred Daoud on Stripes
• Chad Fowler Finding the Jagged Edges
• Andy Hunt on Pragmatic Wetware

Software Engineering Radio

por Software Engineering Radio
http://www.se-radio.net
Inglês

• Software Archaelogy with Dame Thomas
• Fearless Change with Linda Rising
• Learning as a Part of Development with Allan Kelly
• SQL with Jim Melton
• Continuous Integration with Chris Read
• Top 10 Architecture Mistakes with Eoin Woods
• Usability with Joachim Machate
• Introduction to AOP with Christa Schwanninger e Iris Groher
• Retrospectives with Linda Rising
• 10 years of Agile Experiences
• Joe Armstrong on Erlang
• Interview Dave Thomas
• Dick Gabriel on Lisp
• Jeff DeLuca on Feature Driven Development
• Interview Erich Gamma
• Gerard Meszaros on XUnit Test Patterns
• Static Code Analysis with Jonathan Aldrich
• Refactoring Pt. 1
• Refactoring Pt. 2
• eXtreme Programming Pt.1
• eXtreme Programming Pt.2
• Agile Documentation
• Interview Jutta Eckstein
• Interview Eric Evans
• Patterns

Elegant Code

por Elegant Code Community
http://elegantcode.com
Inglês

• Agile for Families
• Entrevista com Jim Wierich o Criador do Rake (Ruby)
• David Laribee on Lean / Kanban
• Uncle Bob Martin on Clean Code
• Alan Shalloway on Lean
• Entrevista com Jarod Ferguson
• Entrevista com Darrel Carver
• Entrevista com Scott Nichols
• Entrevista com Scott Schimanski

Google Developer Podcast

http://code.google.com/p/google-developer-podcast/downloads/list
Inglês

Hearding Code

http://herdingcode.com
Inglês

Tecnologia

IT Conversations

http://itc.conversationsnetwork.org
Inglês

net@Night

por Amber MacArthur e Leo Laport
http://www.twit.tv/natn

Twit – This Week in Tech

por  Leo Laporte, Jeff Jarvis, Baratunde Thurston, e John C. Dvorak
http://www.twit.tv/twit

MacBreak Weekly

por Leo Laporte, Don McAllister, Paul Kent, and Andy Ihnatko
http://www.twit.tv/mbw

This Week in Google

por Leo Laporte, Gina Trapani, Jeff Jarvis e Mary Hodder
http://www.twit.tv/twig

SitePoint Podcast

inglês
http://www.sitepoint.com/podcast

Empreendedorismo e Negócios

37 Signals Podcast

por 37 Signals
Inglês
http://37signals.com/podcast

Max Gehringer (CBN)

por Max Gehringer
Português
http://cbn.globoradio.globo.com/servicos/podcast/NOME.htm

Mundo Corporativo (CBN)

por Heródoto Barbeiro
Português em Áudio
http://cbn.globoradio.globo.com/servicos/podcast/NOME.htm

The Startup Success Podcast

http://startuppodcast.wordpress.com
Inglês

TED Talks

por TED Talks
Inglês
http://www.ted.com

Se você quiser incluir algum outro podcast nesta lista, deixe um comentário. Espero que seja Útil!

I got this idea from Belle de Jour’s blog. It seemed cool enough, so yeah. The meme evolves into a new form. (She still uses Blogspot, bless her. I left that one half a decade ago. WordPress is way more awesome. *totally unnecessary plug*)

I can’t believe I’m going to try to limit it to five things I like, since I am a Certified Geek Girl (I object to the term ‘chick,’ for philosophical reasons) and have a peculiar affinity to tech. Anyway:

Five things I dislike about technology:

• LISP dialect: Scheme. Programming language from hell, aka the Final Straw That Finally Made Me Quit Trying To Study I.T. as a Career. (Computers are fun as a hobby, but not as a life choice.)  Oh, how I hate it. It’s a monster. More specific, language-based languages like Basic are okay, but Scheme? It’s over thirty years old, and it is nothing like the current languages. Sure, it’s dynamic and easy to use if you can grasp it, and no one wants a repeat of some of the Y2K problems, but it’s a horrendous thing to inflict on a first year IT student. The class had a 70-80% fail rate. I’ve more or less quit ranting about it by now – it’s been, like, four years – but I still hate it passionately.
• The fact that on the web, nothing is private and nobody is truly anonymous. If you’re skilled enough, you can grab important, basic details about people and use them against them. It’s not especially hard. I find that scary, and it’s only going to get worse.
• There’s so much junk clogging the net and obscuring the awesome stuff.
• The technology is beginning to evolve faster than I am. I used to keep up with its changes effortlessly, but since computer-geekery became a hobby instead of a way of life, I’ve lost a little bit of my instant adaptability. I actually passed up the opportunity to get a new phone to replace my years-old chunky one because I tohught the new ones were a bit fussy. (Of course, that decision lasted only until I saw the Sony Walkman phone. Instant tech lust.)
• That the truly awesome stuff costs more money than  have.

Five things I like about technology:

• The internet. My life would be an empty, sad shell without the internet. I use it to connect with people, and I use it constantly to learn. I am on a never-ending quest to learn new things, and the internet’s like the never ending bag of Unexpected Awesomeness. You get a lot of unexpected totally-uncoolness, but hey, you gotta take the bad with the good.
• My mp3 player. Music I can take with me! And it’s so easy to use, and to carry around!
• Lego Batman, Star Wars:Racer and Sonic the Hedgehog. Because they rock the casbah.
• It makes life more complicated, but also more interesting. I read a thing by a scientist where he asserted that through the constant pressure to adapt to new technologies that we are putting ourselves through, we are actually putting great evolutionary pressure upon ourselves and are forcing ourselves to evolve more quickly. I don’t know if it’s true, but it helps life stop getting stale and unchanging.
• Man, does it help with uni work! I can just download lecture notes, enroll online, spare my lecturers my infamous handwriting…

When I started to learn Lisp by myself, I found there are many books mentioned and recommended  by people on the internet.

One is Practical Common Lisp.And the other one is Structure and Interpretation of Computer Programs.

Today, I read a review on SICP by Peter Norvig.

It is really worthy of reading.So, I post the site address here.

http://www.amazon.com/review/R403HR4VL71K8?ie=UTF8&*Version*=1&*entries*=0

Hope someone who is interested in learning Lisp will think this  helpful.

SICP Exercise 4.19

I read the footnote of this exercise before I thought about this carefully. So I already knew the opinion of the authors of SICP. I guess they were right that it would be very hard to implement Eva’s view. The order of internal definitions has to been carefully rearranged. In the example, the definition of a should appear before that of b because b depends on a.

As for Ben’s view, his approach would make the language much less powerful.

SICP Exercise 4.18

Using the alternative strategy in this exercise for scanning out definitions, the solve procedure becomes

(define (solve f y0 dt)
  (let ((y '*unassigned*)
        (dy '*unassigned*))
    (let ((a (integral (delay dy) y0 dt))
          (b (stream-map f y)))
      (set! y a)
      (set! dy b))
    y))

Then converting the inner let to a lambda function gives

(define (solve f y0 dt)
  (let ((y '*unassigned*)
        (dy '*unassigned*))
    ((lambda (a b)
       (set! y a)
       (set dy b))
     (integral (delay dy) y0 dt)
     (stream-map f y))
    y))

We can see that this approach does not work because the evaluation of the second argument to the lambda function (stream-map f y) uses y, which is still *unassigned* at that time.

SICP Exercise 4.17

There is an extra frame in the transformed program because let will be converted to a call to a lambda function. Since that is the only difference, it is obvious that this difference should not make any difference in the behavior of a correct program.

To make the interpreter implement the “simultaneous” scope rule for internal definitions without constructing the extra frame, we can rearrange the order of the procedure body making sure internal definitions always appear before being called.

(define (rearrange-defines body)
  (let ((defs '())
        (others '()))
    (let scan-iter ((b body))
      (cond ((null? b)
             '())
            ((definition? (car b))
             (set! defs (append defs (list (car b)))))
            (else
             (set! others (append others (list (car b))))))
      (if (not (null? b))
          (scan-iter (cdr b))))
    (if (null? defs)
        body
        (append defs others))))

(define (make-procedure parameters body env)
  (list 'procedure parameters (rearrange-defines body) env))

There are a lot of people @Lab who know things like Erlang, Haskell, Python, R, etc., etc., etc.  I’m actually considering learning Lisp, but I need a project.  I “learned” php for a project over the summer, but I didn’t really like it since its so much like classic ASP (really messy).  Maybe I’ll learn F# instead…  That shouldn’t be such a strech since I built an ML compiler in grad school (F# is based on ML).  I wonder what kind of project I’d be interested in would benefit from a functional language…  I suppose I’ll have to read up on the language and maybe that will give me some ideas.

Its funny, doing WPF, my umpteenth technology, is just not enough.

Qualys, Inc. is looking for a Policy Compliance Engineer who can research and write new capabilities in the form of LISP/QScheme functions to support signature development efforts.