Código Maldito: febrero 2008

2/24/2008

Las ideas, las patentes, las personas y bla!

Vale la pena que lo lean no el ataque personalizado que hace al monigote de Microsoft sino el porque la supuesta apertura de protocolos de Microsoft no significa más
que una jugada publicitaria con poca incidencia en la industria. Gallí lo explica bien, pero para mi las personas son circunstanciales, acá lo que hay que discutir son las ideas.

Desde emacs II

Hace poco comenté como postear desde GNU/Emacs con g-client, pero últimamente estoy bastante desde GNUS así que acá va una función para invocar rápidamente un nuevo correo a la dirección secreta de Blogger, con el header Content-type en html.

(defun entrada-codigomaldito ()
  "Inserta una entrada en código maldito"
  (interactive)
   (compose-mail "codigomaldito "
                "Sujeto"
                '(("Content-Type" . "text/html;"))
                nil
                )
   (message-sort-headers)
   )

Chau!

2/21/2008

Las raíces de Lisp

Traducción

El siguiente documento es una traducción bastante libre del documento publicado por Paul Graham en su sitio web [The Roots Of Lisp], es un ensayo sobre los fundamentos del lenguaje de programación Lisp.

(Traducción por Emilio Astarita, lamento todos los errores que pudiesen encontrar, la siguiente función en emacs lisp devuelve mi correo electrónico dónde pueden reportarlos.)

      (defun no-spam()
      "Correo para reportar errores."
      (let ((f "emilio")
      (l "astarita"))
      (concat "<" f "." l "@gmail.com" ">")))

Autor: Paul Graham, borrador Enero 18, 2002

En 1960, John McCarthy publicó un notable paper en el cuál, hizo por la programación algo parecido a lo que Euclides hizo por la geometría ^[1]. Mostró de que manera con un puñado de operadores simples y una notación para funciones, se puede construir un lenguaje de programación. Llamó a este lenguaje Lisp, por "List Processing", debido a que una de sus principales ideas era usar una estructura de datos simple llamada list, para el código y los datos.

Vale la pena comprender lo que McCarthy descubrió, no sólo como un hito en la historia de las computadores, sino como un modelo de lo que la programación está tendiendo a convertirse en nuestro propio tiempo. Parece que se han producido dos claros modelos consistentes de programación hasta la fecha: el modelo de C y el modelo de Lisp. Una receta popular para los nuevos lenguajes de programación en los pasados 20 años fue tomar el modelo de C y agregarle, pequeñas partes tomadas del modelo de Lisp, tales como tipado en tiempo de ejecución y recolección de basura.

En este artículo se intentará explicar en los términos más simples posibles lo que McCarthy descubrió. El punto no es sólo aprender acerca de un interesante resultado teórico que alguien averiguó hace cuarenta años, sino mostrar de dónde los lenguajes partieron. La característica inusual de Lisp -en realidad, la definición de la calidad de Lisp- es que puede escribirse a si mismo. Para entender lo que McCarthy quiere decir con esto, vamos a recorrer sus pasos, con su notación matemática traducida en código Common Lisp ejecutable.

1. Siete operadores primitivos

Para empezar, se define una expresión. Una expresión es a la vez un átomo, el cual es una secuencia de letras (e.g. foo), o una lista de cero o más expresiones, separadas por espacios en blanco y encerradas por paréntesis. Algunas expresiones:

      foo
      ()
      (foo)
      (foo bar)
      (a b (c) d)

La última expresión es una lista de cuatro elementos, el tercero de ellos es a su vez una lista de un elemento.

En aritmética la expresión 1 + 1 tiene el valor 2. Las expresiones válidas en Lisp también tienen valores. Si de una expresión e se obtiene el valor v, se dice que e devuelve v. El próximo paso es definir que tipo de expresiones puden existir, y que valor devuelve cada tipo.

Si una expresión es una lista, se llama al primer elemento el operador y a los elementos restantes los argumentos. Se van a definir siete operadores primitivos (en el sentido de axiomas): quote, atom, eq, car, cdr, cons, y cond.

1. (quote x)

(quote x) devuelve x. Por legibilidad abreviamos (quote x) como 'x.

      > (quote a)
      a
      > 'a
      a
      > (quote (a b c))
      (a b c)

Nota traducción: la mayoría de las veces traduciremos quoted, como escapar

2. (atom x)

(atom x) devuelve el átomo t si el valor de x es un átomo o la lista vacía. En Lisp se acostumbra a usar el átomo t para representar verdadero, y la lista vacia para representar falso.

      > (atom 'a)
      t
      > (atom '(a b c))
      ()
      > (atom '())
      t

Ahora que se tiene un operador cuyo argumento es evaluado se puede mostrar para que sirve quote. Escapando una lista con quote evitamos su evaluación. Una lista no escapada dada como argumento a un operador como atom es tratada como código:

      > (atom (atom 'a))
      t

en cualquier lugar en dónde aparezca una lista escapada se trata como una mera lista, en este caso una lista de dos elementos:

      > (atom '(atom 'a))
      ()

Esto es similar a la manera en que se usan las comillas en inglés. Cambridge es una ciudad en Massachusetts que tiene cerca de 90.000 personas. "Cambridge" es una palabra que contiene nueve letras.

Escapar puede parecer un concepto algo lejano, porque muy pocos lenguajes tienen algo como esto. Está muy relacionado a una de las más distintivas características de Lisp: código y datos están hechos de las mismas estructuras de datos, y el operador quote es la manera en que se distingue entre ellos.

3. (eq x y)

(eq x y) devuelve t si los valores de x e y son el mismo átomo, o los dos la lista vacía, y () en cualquier otro caso.

      > (eq 'a 'a)
      t
      > (eq 'a 'b)
      ()
      > (eq '() '())
      t

4. (car x)

(car x) espera que el valor de x sea una lista, y devuelve su primer elemento.

      > (car '(a b c))
      a

5. (cdr x)

(cdr x) espera que el valor de x sea una lista, y devuelve todo lo posterior al primer elemento.

      > (cdr '(a b c))
      (b c)

6. (cons x y)

(cons x y) espera que el valor de y sea una lista, y devuelve el valor de x seguido por los elementos del valor de y.

      > (cons 'a '(b c))
      (a b c)
      > (cons 'a (cons 'b (cons 'c '())))
      (a b c)
      > (car (cons 'a '(b c)))
      a
      > (cdr (cons 'a '(b c)))
      (b c)

7. (cond (p₁ e₁)...(p_n e_n))

(cond (p₁ e₁)...(p_n e_n)) es evaluado de la siguiente manera. La expresiones p son evaluadas en orden hasta que una devuelva t. Cuando una es encontrada, el valor de la expresión e correspondiente es devuelto como el valor de toda la expresión cond.

      > (cond ((eq 'a 'b) 'first)
                 ((atom 'a) 'second))
      second

En cinco de los siete operadores primitivos, los argumentos son siempre evaluados cuando una expresión que comienza con ese operador es evaluada.^[2] Se llama a un operador de ese tipo una función.

2. Denotar funciones

A continuación se define una notación para describir funciones. Una función se expresa como (lambda (p₁...p_n) e), dónde p₁...p_n son átomos (llamados parámetros) y e es una expresión. Una expresión cuyo primer elemento es una expresión

      ((lambda (p₁...p_n) e) a₁...a_n)

es conocida como una llamada de función y su valor es cálculado de la siguiente manera. Cada expresión a_i es evaluada. Luego e es evaluada. Durante la evaluación de e, el valor de cualquier ocurrencia de uno de los p_i , es el valor del correspondiente a_i en la llamada de función más reciente.

      > ((lambda (x) (cons x '(b))) 'a)
      (a b)
      > ((lambda (x y) (cons x (cdr y)))
            'z
            '(a b c))
      (z b c)

Si una expresión tiene como primer elemento un átomo f que no es uno de los operadores primitivos

      (f a₁...a_n)

y el valor de f es una función (lambda (p₁...p_n) e) luego el valor de la expresión es el valor de

      ((lambda (p₁...p_n) e) a₁...a_n)

En otras palabras, los parámetros pueden ser usados tanto como operadores o como argumentos en expresiones:

      > ((lambda (f) (f '(b c))) 
            '(lambda (x) (cons 'a x)))
      (a b c)

Hay otra notación para funciones que permite a la función referirse a sí misma, así se brinda una manera conveniente de definir funciones recursivas.^[3] La notación

      (label f (lambda (p₁...p_n e))

denota una función que se comporta como (lambda (p₁...p_n) e), con la propiedad adicional de que una ocurrencia de f en e evalua a la expresión label, como si f fuese un parametro de la función.

Suponiendo que se quisiera definir una función (subst x y z), la cual toma una expresión x, un átomo y, y una lista z, y devuelve una lista como z pero con cada instancia de y (a cualquier profundidad de anidamiento) en z reemplazada por x.

      > (subst 'm 'b '(a b (a b c) d))
      (a m (a m c) d)

Se puede denotar esta función como

      (label subst (lambda (x y z)
                     (cond ((atom z)
                            (cond ((eq z y) x)
                                  ('t z)))
                           ('t (cons (subst x y (car z))
                                     (subst x y (cdr z)))))))

Se abreviará f = (label f (lambda (p₁...p_n) e)) como

      (defun f (p₁...p_n) e)

así

      (defun subst (x y z)
        (cond ((atom z)
               (cond ((eq z y) x)
                     ('t z)))
              ('t (cons (subst x y (car z))
                        (subst x y (cdr z))))))

A proposito, aquí se ve como conseguir una cláusula por omisión en una expresión cond. Una cláusula cuyo primer elemento es 't será siempre éxitosa. Así

      (cond (x y) ('t z))

es equivalente a lo que tal vez se escribiría en un lenguaje con síntaxis como:

      if x then y else z

3. Algunas funciones

Ahora que se tiene una manera de expresar funciones, se definen algunas nuevas en términos de los siete operadores primitivos. Primero es conveniente introducir algunas abreviaciones de patrones comunes. Se usará el cxr, dónde x es una secuencia de as o ds, como una abreviación para la composición correspondiente de car y cdr. Así, por ejemplo (cadr e) es una abreviación de (car (cdr e)), la cual devuelve el segundo elemento de e.

      > (cadr '((a b) (c d) e))
      (c d)
      > (caddr '((a b) (c d) e))
      e
      > (cdar '((a b) (c d) e))
      (b)

También, se usará (list e₁...e_n para (cons e₁ ... (cons e_n '()) ... ).

      > (cons 'a (cons 'b (cons 'c '())))
      (a b c)
      > (list 'a 'b 'c)
      (a b c)

Ahora se definen algunas funciones nuevas. Se cambiaron los nombres de estas funciones agregando un punto al final. Esto distingue a las funciones primitivas de las definidas en términos de estas, y además evita colisiones con funciones existentes en Common Lisp.

1. (null. x)

(null. x) prueba si su arguemento es la lista vacia.

      (defun null. (x)
        (eq x '()))
      > (null. 'a)
      ()
      > (null. '())
      t

2. (and. x y)

(and. x y) devuelve t si ambos argumentos lo hacen, y () en cualquier otro caso.

      (defun and. (x y)
        (cond (x (cond (y 't) ('t '())))
              ('t '())))
      > (and. (atom 'a) (eq 'a 'a))
      t
      > (and. (atom 'a) (eq 'a 'b))
      ()

3. (not. x)

(not. x) devuelve t si su argumento devuelve (), y () si su argumento devuelve t.

      (defun not. (x)
        (cond (x '())
              ('t 't)))
      > (not. (eq 'a 'a))
      ()
      > (not. (eq 'a 'b))
      t

4. (append. x y)

(append. x y) toma dos listas y devuelve la concatenación de estas.

      (defun append. (x y)
        (cond ((null. x) y)
              ('t (cons (car x) (append. (cdr x) y)))))
      > (append. '(a b) '(c d))
      (a b c d)
      > (append. '() '(c d))
      (c d)

5. (pair. x y)

(pair. x y) toma dos listas de igual longitud y devuelve una lista de listas de dos elementos conteniendo pares sucesivos de un elemento de cada una.

      (defun pair. (x y)
        (cond ((and. (null. x) (null. y)) '())
              ((and. (not. (atom x)) (not. (atom y)))
               (cons (list (car x) (car y))
                     (pair. (cdr x) (cdr y))))))
      > (pair. '(x y z) '(a b c))
      ((x a) (y b) (z c))

6. (assoc. x y)

(assoc. x y) toma un átomo x y una lista y de la forma creada por pair., y devuelve el segundo elemento de la primera lista en y cuyo primer elemento es x.

      (defun assoc. (x y)
        (cond ((eq (caar y) x) (cadar y))
              ('t (assoc. x (cdr y)))))
      > (assoc. 'x '((x a) (y b)))
      a
      > (assoc. 'x '((x new) (x a) (y b)))
      new

4. La sorpresa

Así, se pudo definir funciones que concatenan listas, sustituyen una expresión por otra, etc. Una notación elegante, tal vez, pero. ¿Ahora qué? Ahora viene la sorpresa. Se puede también, es resultado de, escribir una función que actue como un interprete para nuestro lengauje: una función que tome como un argumento cualquier expresión Lisp, y devuelva su valor. Aquí está:

      (defun eval. (e a)
        (cond 
          ((atom e) (assoc. e a))
          ((atom (car e))
           (cond 
             ((eq (car e) 'quote) (cadr e))
             ((eq (car e) 'atom)  (atom (eval. (cadr  e) a)))
             ((eq (car e) 'eq)    (eq   (eval. (cadr  e) a)
            (eval. (cadr  e) a)))
             ((eq (car e) 'car)   (car  (eval. (cadr  e) a)))
             ((eq (car e) 'cdr)   (cdr  (eval. (cadr  e) a)))
             ((eq (car e) 'cons)  (cons (eval. (cadr  e) a)
            (eval. (caddr e) a)))
             ((eq (car e) 'cond) (evcon. (cdr e) a))
             ('t (eval. (cons (assoc. (car e) a)
         (cdr e))
          a))))
          ((eq (caar e) 'label)
           (eval. (cons (caddar e) (cdr e))
           (cons (list (cadar e) (car e)) a)))
          ((eq (caar e) 'lambda)
           (eval. (caddar e)
           (append. (pair. (cadar e) (evlis. (cdr e) a))
             a)))))
      
      (defun evcon. (c a)
        (cond ((eval. (caar c) a)
        (eval. (cadar c) a))
       ('t (evcon. (cdr c) a))))
      
      (defun evlis. (m a)
        (cond ((null. m) '())
       ('t (cons (eval. (car m) a)
          (evlis. (cdr m) a)))))

La definición de eval. es más larga que cualquiera de las otras vistas anteriormente. Vamos a considerar como trabaja cada parte.

La función toma dos argumentos: e, la expresión a ser evaluada, y a, una lista que representa los valores que los átomos fueron tomanado al aparecer como parámetros en las llamadas de función. Esta lista es llamada entorno, y es de la forma creada por pair.. ~~Su fin es construir y buscar en las listas que se escribieron para pair. y assoc.~~It was in order to build and search these lists that we wrote pair. and assoc.

La columna de eval. es una expresión cond con cuatro cláusulas. Como se evalua una expresión depende del tipo que sea. La primer cláusula evalua átomos. Si e es un átomo, se busca su valor en el entorno:

      > (eval. 'x '((x a) (y b)))
      a

La segunda cláusula de eval. es otra cond para el manejo de expresiones de la forma (a ...), dónde a es un átomo. Esto incluye todos los usos de los operadores primitivos, y existe una cláusula para cada uno.

      > (eval. '(eq 'a 'a) '())
      t
      > (eval. '(cons x '(b c))
                  '((x a) (y b)))
      (a b c)

Todos ellos (excepto quote) llaman a eval. para encontrar el valor de sus argumentos.

Las dos últimas cláusulas son más complicadas. Para evaluar una expresión cond llamamos a una función auxiliar llamada evcond., la cual trabaja a su manera a través de las cláusulas recursivamente, buscando una en la cual el primer elemento devuelva t. Cuando encuentra dicha cláusula devuelve el valor del segundo elemento.

      > (eval. '(cond ((atom x) 'atom)
                         ('t 'list))
                  '((x '(a b))))
      list

La parte final de la segunda cláusula de eval.. Maneja llamadas a funciones que han sido pasadas como parametros. Trabaja reemplazando el átomo con su valor (que debería ser una expresión lambda o label) y evaluando la expresión resultante. Así

       (eval. '(f '(b c))
              '((f (lambda (x) (cons 'a x)))))

se convierte en

      (eval. '((lambda (x) (cons 'a x)) '(b c))
             '((f (lambda (x) (cons 'a x)))))

que devuelve (a b c).

Las dos últimas cláusulas en eval. manejan llamadas a funciones en las cuales el primer argumento es una expresión lambda o label. Una expresión label es evaluada empujando la lista del nombre de la función y la función en si misma dentro del entorno, y luego llamando a eval. en una expresión con el lambda interior sustituido por la expresión label. Esto es,

      (eval. '((label firstatom (lambda (x)
                                  (cond ((atom x) x)
                                        ('t (firstatom (car x))))))
               y)
             '((y ((a b) (c d)))))

que se convierte en

      (eval. '((lambda (x) 
           (cond ((atom x) x)
                 ('t (firstatom (car x)))))
         y)
       '((firstatom 
          (label firstatom (lambda (x)
                             (cond ((atom x) x)
                                   ('t (firstatom (car x)))))))
         (y ((a b) (c d)))))

la cual termina por devolver a.

Finalmente una expresión de la forma ((lambda (p₁...p_n) e) a₁...a_n) es evaluada llamando primero a evlist. para obtener una lista de valores (v₁ ... v_n) de los argumentos a₁ ... a_n, y luego evaluando e con (p₁ v₁) ... (p_n v_n) agregado al frente del entorno. Así

      (eval. '((lambda (x y) (cons x (cdr y)))
               'a
               '(b c d))
             '())

se convierte en

      (eval. '(cons x (cdr y))
             '((x a) (y (b c d))))

que termina devolviendo (a c d).

5. Consecuencias

Ahora que se entiende como eval trabaja, volvamos un paso atras y consideremos lo que significa. Lo que se tiene aquí es un extraordinariamente elegante modelo de computación. Usando sólo quote, atom, eq, car, cdr, cons, y cons, se pudo definir una función, eval., que en realidad implementa nuestro propio lenguaje, y luego usándo se puede definir cualquier función adicional que se quiera.

Por supuesto que ya existen modelos de computación-el más notable es la máquina de Turing. Pero los programas de la máquina de Turing no son demasiado ~~fáciles~~ edifying de leer. Si se quiere un lenguaje para describir algoritmos, se debe desear algo más abstracto, y ese fue uno de los objetivos de McCarthy al definir Lisp.

Al lenguaje que él definió en 1960 le faltaba un monton. No tenía ~~efectos laterales~~ side-effects, ejecución secuencial (la cual sólo es útil con efectos laterales), no tenía números prácticos^[4] y alcance dinámico. Pero estas limitaciones pueden ser remediadas, sorprendentemente con muy código adicional. Steele y Sussman muestran como hacerlo en un famoso paper llamado "The Art of the Interpreter"^[5].

Si se entiende la función eval de McCarthy, se entiende más que sólo un estadío en la historia de los lenguajes. Estas ideas están aún presentes en el núcleo semántico de Lisp en la actualidad. Así que estudiando el paper original de McCarthy nos muestra, en un sentido, lo que Lisp realmente es. No es tanto algo que McCarthy diseño sino algo que descubrió. No es intrínsicamente un lenguaje para AI o para realizar prototipos rápidos, o cualquier otra tarea de ese nivel. Es lo que obtienes (o una de las cosas que obtienes) cuando intentas ~~axiomatizar la computación~~ axiomatize computation.

En el tiempo, el lenguaje medio, queriendo decir el lenguaje utilizado por el programador medio, ha ido acercándose considerablemente a Lisp. Así que entiendiendo eval estarás entendiendo lo que probablemente sea el principal modelo computacional en el futuro.

1 Recursive functions of symbolic expressions and their computation by machine (Part I) Communications of the ACM in April 1960. (El paper original) Volver

2 Las expresiones que comienzan con los otros dos operadores, quote and cond, son evaluadas de manera diferente. Cuando una expresión es escapada su argumento no es evaluado, es simplemente devuelto como el valor de toda la expresión escapada. Y en una expresión cond válida, sólo un camino con forma de L de subexpresiones será evaluado. Volver

3 Lógicamente no se necesita definir una nueva notación para esto. Se puede definir funciones recursivamente con la notación que se tiene hasta el momento usando una función en funciones llamada Y combinator. Puede que McCarthy no supiese acerca del Y combinator cuando escribió su paper, en cualquier caso la notación con etiqueta (labe) es más leíble. Volver

4 Es posible realizar aritmética en el Lisp de McCarthy de 1960 utilizando una lista de n átomos para representar el número n. Volver

5 Guy Lewis Steele, Jr. y Gerald Jay Sussman, "The Art of the interpreter, or the Modularity Complex (Part Zero, One, and Two)," MIT AI Lab Memo 453, Mayo de 1978. Volver

pequeña nota mental

Acordarse para mañanaa de memorizar esto:

 ################################################## #              ECB keystrokes. ################################################## C-c . ,         ecb-cycle-maximized-ecb-buffers C-c . .         ecb-cycle-through-compilation-buffers C-c . /         ecb-toggle-compile-window-height C-c . \         ecb-toggle-compile-window C-c . a         ecb-toggle-auto-expand-tag-tree C-c . e         eshell C-c . f         Prefix Command C-c . g         Prefix Command C-c . h         ecb-show-help C-c . l         Prefix Command C-c . m         Prefix Command C-c . n         ecb-nav-goto-next C-c . o         ecb-toggle-scroll-other-win C-c . p         ecb-nav-goto-previous C-c . r         ecb-rebuild-methods-buffer C-c . s         ecb-window-sync C-c . x         ecb-expand-methods-nodes

C-c . m a       ecb-maximize-window-analyse C-c . m b       ecb-maximize-window-speedbar C-c . m d       ecb-maximize-window-directories C-c . m h       ecb-maximize-window-history C-c . m m       ecb-maximize-window-methods C-c . m s       ecb-maximize-window-sources

C-c . g 1       ecb-goto-window-edit1 C-c . g 2       ecb-goto-window-edit2 C-c . g a       ecb-goto-window-analyse C-c . g b       ecb-goto-window-speedbar C-c . g c       ecb-goto-window-compilation C-c . g d       ecb-goto-window-directories C-c . g h       ecb-goto-window-history C-c . g l       ecb-goto-window-edit-last C-c . g m       ecb-goto-window-methods C-c . g s       ecb-goto-window-sources

C-c . l c       ecb-change-layout C-c . l r       ecb-redraw-layout C-c . l t       ecb-toggle-layout C-c . l w       ecb-toggle-ecb-windows

C-c . f c       ecb-methods-filter-current-type C-c . f f       ecb-methods-filter-function C-c . f h       ecb-history-filter C-c . f l       ecb-methods-filter-delete-last C-c . f m       ecb-methods-filter C-c . f n       ecb-methods-filter-nofilter C-c . f p       ecb-methods-filter-protection C-c . f r       ecb-methods-filter-regexp C-c . f s       ecb-sources-filter C-c . f t       ecb-methods-filter-tagclass

################################################## #              GNUS keystrokes. ################################################## c               gnus-summary-catchup-and-exit d               gnus-summary-mark-as-read-forward e               gnus-summary-edit-article f               gnus-summary-followup g               gnus-summary-show-article h               gnus-summary-select-article-buffer i               gnus-summary-news-other-window j               gnus-summary-goto-article k               gnus-summary-kill-same-subj l               gnus-summary-goto-last-article m               gnus-summary-mail-other-window n               gnus-summary-next-unread-article o               gnus-summary-save-article p               gnus-summary-prev-unread-article q               gnus-summary-exit r               gnus-summary-reply s               gnus-summary-isearch-article t               gnus-summary-toggle-header u               gnus-summary-tick-article-forward w               gnus-summary-stop-page-breaking x               gnus-summary-limit-to-unread |               gnus-summary-pipe-output DEL             gnus-summary-prev-page

        gnus-summary-next-thread           gnus-summary-prev-thread      gnus-summary-prev-page         gnus-summary-prev-page    mouse-face        gnus-mouse-pick-article          Prefix Command

C-c C-b         gnus-bug C-c C-d         gnus-summary-describe-group C-c C-f         gnus-summary-mail-forward C-c TAB         gnus-info-find-node C-c C-r         gnus-summary-caesar-message C-c C-s         Prefix Command C-c C-v         Prefix Command C-c ESC         Prefix Command

C-x C-s         gnus-summary-reselect-current-group

C-M-a           gnus-summary-customize-parameters C-M-b           gnus-summary-prev-thread C-M-d           gnus-summary-read-document C-M-e           gnus-summary-edit-parameters C-M-f           gnus-summary-next-thread C-M-h           gnus-summary-hide-thread C-M-k           gnus-summary-kill-thread C-M-l           gnus-summary-lower-thread M-RET           gnus-summary-scroll-down C-M-n           gnus-summary-next-same-subject C-M-p           gnus-summary-prev-same-subject C-M-s           gnus-summary-show-thread C-M-t           gnus-summary-toggle-threads C-M-u           gnus-summary-up-thread M-#             gnus-summary-unmark-as-processable M-&             gnus-summary-universal-argument M-*             gnus-cache-remove-article M-K             gnus-summary-edit-global-kill M-U             gnus-summary-clear-mark-backward M-^             gnus-summary-refer-article M-g             gnus-summary-rescan-group M-i             gnus-symbolic-argument M-k             gnus-summary-edit-local-kill M-n             gnus-summary-next-unread-subject M-p             gnus-summary-prev-unread-subject M-r             gnus-summary-search-article-backward M-s             gnus-summary-search-article-forward M-t             gnus-summary-toggle-display-buttonized M-u             gnus-summary-clear-mark-forward

/ *             gnus-summary-limit-include-cached / .             gnus-summary-limit-to-unseen / /             gnus-summary-limit-to-subject / C             gnus-summary-limit-mark-excluded-as-read / D             gnus-summary-limit-include-dormant / E             gnus-summary-limit-include-expunged / M             gnus-summary-limit-exclude-marks / N             gnus-summary-insert-new-articles / T             gnus-summary-limit-include-thread / a             gnus-summary-limit-to-author / c             gnus-summary-limit-exclude- / d             gnus-summary-limit-exclude-dormant / m             gnus-summary-limit-to-marks / n             gnus-summary-limit-to-articles / o             gnus-summary-insert-old-articles / p             gnus-summary-limit-to-display-predicate / s             gnus-summary-limit-to-subject / t             gnus-summary-limit-to-age / u             gnus-summary-limit-to-unread / v             gnus-summary-limit-to-score / w             gnus-summary-pop-limit / x             gnus-summary-limit-to-extra

A RET           gnus-summary-scroll-up A ESC           Prefix Command A SPC           gnus-summary-next-page A <             gnus-summary-beginning-of-article A >             gnus-summary-end-of-article A D             gnus-summary-enter-digest-group A M             gnus-mailing-list-insinuate A P             gnus-summary-print-article A R             gnus-summary-refer-references A T             gnus-summary-refer-thread A ^             gnus-summary-refer-parent-article A b             gnus-summary-beginning-of-article A e             gnus-summary-end-of-article A g             gnus-summary-show-article A n             gnus-summary-next-page A p             gnus-summary-prev-page A r             gnus-summary-refer-parent-article A s             gnus-summary-isearch-article A t             gnus-article-babel A DEL           gnus-summary-prev-page A       gnus-summary-prev-page

B ESC           Prefix Command B B             gnus-summary-crosspost-article B I             gnus-summary-create-article B c             gnus-summary-copy-article B e             gnus-summary-expire-articles B i             gnus-summary-import-article B m             gnus-summary-move-article B p             gnus-summary-article-posted-p B q             gnus-summary-respool-query B r             gnus-summary-respool-article B t             gnus-summary-respool-trace B w             gnus-summary-edit-article B DEL           gnus-summary-delete-article B    gnus-summary-delete-article B       gnus-summary-delete-article

G C-n           gnus-summary-next-same-subject G C-p           gnus-summary-prev-same-subject G ESC           Prefix Command G N             gnus-summary-next-article G P             gnus-summary-prev-article G b             gnus-summary-best-unread-article G f             gnus-summary-first-unread-article G g             gnus-summary-goto-subject G j             gnus-summary-goto-article G l             gnus-summary-goto-last-article G n             gnus-summary-next-unread-article G o             gnus-summary-pop-article G p             gnus-summary-prev-unread-article

H C             gnus-group-fetch-control H c             gnus-group-fetch-charter H d             gnus-summary-describe-group H f             gnus-summary-fetch-faq H h             gnus-summary-describe-briefly H i             gnus-info-find-node H v             gnus-version

K C             gnus-article-view-part-as-charset K E             gnus-article-encrypt-body K b             gnus-summary-display-buttonized K c             gnus-article-copy-part K e             gnus-article-view-part-externally K i             gnus-article-inline-part K m             gnus-summary-repair-multipart K o             gnus-article-save-part K v             gnus-article-view-part K |             gnus-article-pipe-part

M C-c           gnus-summary-catchup-all M ESC           Prefix Command M SPC           gnus-summary-clear-mark-forward M !             gnus-summary-tick-article-forward M #             gnus-summary-mark-as-processable M ?             gnus-summary-mark-as-dormant M B             gnus-summary-remove-bookmark M C             gnus-summary-catchup M H             gnus-summary-catchup-to-here M K             gnus-summary-kill-same-subject M M             Prefix Command M P             gnus-uu-mark-map M S             gnus-summary-limit-include-expunged M V             gnus-summary-mscore-map M b             gnus-summary-set-bookmark M c             gnus-summary-clear-mark-forward M d             gnus-summary-mark-as-read-forward M e             gnus-summary-mark-as-expirable M h             gnus-summary-catchup-from-here M k             gnus-summary-kill-same-subj M r             gnus-summary-mark-as-read-forward M t             gnus-summary-tick-article-forward M x             gnus-summary-mark-as-expirable

O B             gnus-summary-write-article-body-file O F             gnus-summary-write-article-file O P             gnus-summary-muttprint O b             gnus-summary-save-article-body-file O f             gnus-summary-save-article-file O h             gnus-summary-save-article-folder O m             gnus-summary-save-article-mail O o             gnus-summary-save-article O p             gnus-summary-pipe-output O r             gnus-summary-save-article-rmail O s             gnus-soup-add-article O v             gnus-summary-save-article-vm

S ESC           Prefix Command S B             Prefix Command S D             gnus-send-bounce-map S F             gnus-summary-followup-with-original S N             gnus-summary-followup-to-ma S O             Prefix Command S R             gnus-summary-reply-with-original S V             gnus-summary-very-wide-repl S W             gnus-summary-wide-reply-with-original S c             gnus-summary-cancel-article S f             gnus-summary-followup S i             gnus-summary-news-other-window S m             gnus-summary-mail-other-window S n             gnus-summary-followup-to-mail S o             Prefix Command S p             gnus-summary-post-news S r             gnus-summary-reply S s             gnus-summary-supersede-article S u             gnus-uu-post-news S v             gnus-summary-very-wide-reply S w             gnus-summary-wide-reply S y             gnus-summary-yank-message

T ESC           Prefix Command T #             gnus-uu-mark-thread T H             gnus-summary-hide-all-threads T S             gnus-summary-show-all-threads T T             gnus-summary-toggle-threads T ^             gnus-summary-reparent-thread T d             gnus-summary-down-thread T h             gnus-summary-hide-thread T i             gnus-summary-raise-thread T k             gnus-summary-kill-thread T l             gnus-summary-lower-thread T n             gnus-summary-next-thread T o             gnus-summary-top-thread T p             gnus-summary-prev-thread T s             gnus-summary-show-thread T t             gnus-summary-rethread-current

Sí, y ustedes se creían duros memorizando ################################################## # # GNUS keystrokes. # ################################################## C-d gnus-summary-enter-digest-group C-k gnus-summary-kill-same-subject C-l gnus-recenter RET gnus-summary-scroll-up C-o gnus-summary-save-article-mail C-t gnus-summary-toggle-truncation C-w gnus-summary-mark-region-as-read C-x Prefix Command ESC Prefix Command SPC gnus-summary-next-page ! gnus-summary-tick-article-forward # gnus-summary-mark-as-processable dow-scrolls-compile & gnus-summary-execute-command * gnus-cache-enter-article , gnus-summary-best-unread-article - negative-argument . gnus-summary-first-unread-article / gnus-summary-limit-map 0 .. 9 digit-argument < gnus-summary-beginning-of-article = gnus-summary-expand-window > gnus-summary-end-of-article ? gnus-summary-mark-as-dormant A gnus-summary-article-map B gnus-summary-backend-map C gnus-summary-cancel-article D gnus-summary-mark-as-read-backward E gnus-summary-mark-as-expirable F gnus-summary-followup-with-original G gnus-summary-goto-map H gnus-summary-help-map I gnus-summary-increase-score K gnus-summary-mime-map L gnus-summary-lower-score M gnus-summary-mark-map N gnus-summary-next-article O gnus-summary-save-map P gnus-summary-prev-article Q gnus-summary-exit-no-update R gnus-summary-reply-with-original S gnus-summary-send-map T gnus-summary-thread-map U gnus-summary-tick-article-backward V gnus-summary-score-map W gnus-summary-wash-map X gnus-uu-extract-map Y gnus-summary-buffer-map Z gnus-summary-exit-map ^ gnus-summary-refer-parent-article a gnus-summary-post-news b gnus-article-view-part ################################################## # # GNUS keystrokes. # ################################################## T u gnus-summary-up-thread V C gnus-score-customize V F gnus-score-flush-cache V R gnus-summary-rescore V S gnus-summary-current-score V c gnus-score-change-score-file V e gnus-score-edit-current-scores ect-and-select V f gnus-score-edit-file V m gnus-score-set-mark-below V s gnus-summary-set-score V t gnus-score-find-trace V w gnus-score-find-favourite-words V x gnus-score-set-expunge-below W 6 gnus-article-de-base64-unreadable W B gnus-article-add-buttons-to-head W C gnus-article-capitalize-sentences W D gnus-summary-wash-display-map W E gnus-summary-wash-empty-map W G gnus-summary-wash-header-map W H gnus-summary-wash-highlight-map W M gnus-summary-wash-mime-map W Q gnus-article-fill-long-lines W T gnus-summary-wash-time-map W W gnus-summary-wash-hide-map W Y gnus-summary-wash-deuglify-map W Z gnus-article-decode-HZ W a gnus-article-strip-headers-in-body W b gnus-article-add-buttons W c gnus-article-remove-cr W d gnus-article-treat-dumbquotes W e gnus-article-emphasize W f gnus-article-display-x-face W g gnus-treat-smiley W h gnus-article-wash-html W l gnus-summary-stop-page-breaking W m gnus-summary-morse-message W o gnus-article-treat-overstrike W p gnus-article-verify-x-pgp-sig W q gnus-article-de-quoted-unreadable W r gnus-summary-caesar-message W s gnus-summary-force-verify-and-decrypt W t gnus-summary-toggle-header W u gnus-article-unsplit-urls W v gnus-summary-verbose-headers W w gnus-article-fill-cited-article X B gnus-uu-decode-binhex X O gnus-uu-decode-save X P gnus-uu-decode-postscript-and-save X S gnus-uu-decode-unshar-and-save X U gnus-uu-decode-uu-and-save X b gnus-uu-decode-binhex X m gnus-summary-save-parts X o gnus-uu-decode-save X p gnus-uu-decode-postscript X s gnus-uu-decode-unshar X u gnus-uu-decode-uu X v gnus-uu-extract-view-map Y c gnus-summary-insert-cached-articles Y d gnus-summary-insert-dormant-articles Y g gnus-summary-prepare Z C gnus-summary-catchup-all-and-exit Z E gnus-summary-exit-no-update Z G gnus-summary-rescan-group Z N gnus-summary-next-group Z P gnus-summary-prev-group Z Q gnus-summary-exit Z R gnus-summary-reselect-current-group Z Z gnus-summary-exit Z c gnus-summary-catchup-and-exit Z n gnus-summary-catchup-and-goto-next-group Z s gnus-summary-save-newsrc C-c C-v C-v gnus-uu-decode-uu-view C-c C-s C-a gnus-summary-sort-by-author C-c C-s C-c gnus-summary-sort-by-chars C-c C-s C-d gnus-summary-sort-by-date C-c C-s TAB gnus-summary-sort-by-score childless-dormant C-c C-s C-l gnus-summary-sort-by-lines C-c C-s C-n gnus-summary-sort-by-number C-c C-s C-o gnus-summary-sort-by-original C-c C-s C-r gnus-summary-sort-by-random C-c C-s C-s gnus-summary-sort-by-subject C-c C-M-s gnus-summary-limit-include-expunged A M-RET gnus-summary-scroll-down B C-M-e gnus-summary-expire-articles-now G M-n gnus-summary-next-unread-subject G M-p gnus-summary-prev-unread-subject M M ! Prefix Command M M ? Prefix Command M M d Prefix Command M M e Prefix Command M M u Prefix Command M V c gnus-summary-clear-above M V k gnus-summary-kill-below M V m gnus-summary-mark-above M V u gnus-summary-tick-above M P G gnus-uu-unmark-by-regexp M P R gnus-uu-mark-by-regexp M P S gnus-uu-mark-sparse M P T gnus-uu-unmark-thread M P U gnus-summary-unmark-all-processable M P a gnus-uu-mark-all M P b gnus-uu-mark-buffer M P g gnus-uu-unmark-region M P i gnus-uu-invert-processable M P k gnus-summary-kill-process-mark M P p gnus-summary-mark-as-processable M P r gnus-uu-mark-region M P s gnus-uu-mark-series M P t gnus-uu-mark-thread M P u gnus-summary-unmark-as-processable M P v gnus-uu-mark-over M P w gnus-summary-save-process-mark M P y gnus-summary-yank-process-mark M M-# gnus-summary-unmark-as-processable S D b gnus-summary-resend-bounced-mail S D e gnus-summary-resend-message-edit S D r gnus-summary-resend-message S O m gnus-uu-digest-mail-forward S O p gnus-uu-digest-post-forward S o m gnus-summary-mail-forward S o p gnus-summary-post-forward S B R gnus-summary-reply-broken-reply-to-with-original S B r gnus-summary-reply-broken-reply-to S M-c gnus-summary-mail-crosspost-complaint T M-# gnus-uu-unmark-thread W E A gnus-article-strip-all-blank-lines W E a gnus-article-strip-blank-lines W E e gnus-article-strip-trailing-space W E l gnus-article-strip-leading-blank-lines W E m gnus-article-strip-multiple-blank-lines W E s gnus-article-strip-leading-space W E t gnus-article-remove-trailing-blank-lines W E w gnus-article-remove-leading-whitespace W T e gnus-article-date-lapsed W T i gnus-article-date-iso8601 W T l gnus-article-date-local W T o gnus-article-date-original W T p gnus-article-date-english W T s gnus-article-date-user W T u gnus-article-date-ut W T z gnus-article-date-ut W M b gnus-article-view-part W M c gnus-article-decode-charset W M v gnus-mime-view-all-parts W M w gnus-article-decode-mime-words W D D gnus-article-remove-images W D d gnus-article-display-face W D f gnus-treat-from-picon W D m gnus-treat-mail-picon W D n gnus-treat-newsgroups-picon W D s gnus-treat-smiley W D x gnus-article-display-x-face W G f gnus-article-treat-fold-headers W G n gnus-article-treat-fold-newsgroups W G u gnus-article-treat-unfold-headers W H a gnus-article-highlight W H c gnus-article-highlight-citation W H h gnus-article-highlight-headers W H s gnus-article-highlight-signature ect-and-select W W C-c gnus-article-hide-citation-maybe W W B gnus-article-strip-banner W W C gnus-article-hide-citation-in-followups W W P gnus-article-hide-pem W W a gnus-article-hide W W b gnus-article-hide-boring-headers W W c gnus-article-hide-citation W W h gnus-article-hide-headers W W l gnus-article-hide-list-identifiers W W s gnus-article-hide-signature W Y a gnus-article-outlook-repair-attribution W Y c gnus-article-outlook-rearrange-citation W Y f gnus-article-outlook-deuglify-article W Y u gnus-article-outlook-unwrap-lines X v B gnus-uu-decode-binhex-view X v O gnus-uu-decode-save-view X v P gnus-uu-decode-postscript-and-save-view X v S gnus-uu-decode-unshar-and-save-view X v U gnus-uu-decode-uu-and-save-view il-with-original X v b gnus-uu-decode-binhex-view X v o gnus-uu-decode-save-view X v p gnus-uu-decode-postscript-view y-with-original X v s gnus-uu-decode-unshar-view X v u gnus-uu-decode-uu-view M M e N gnus-summary-put-mark-as-expirable-next-unread M M e P gnus-summary-put-mark-as-expirable-prev-unread M M e e gnus-summary-put-mark-as-expirable M M e n gnus-summary-put-mark-as-expirable-next M M e p gnus-summary-put-mark-as-expirable-prev M M ? ? gnus-summary-put-mark-as-dormant M M ? N gnus-summary-put-mark-as-dormant-next-unread M M ? P gnus-summary-put-mark-as-dormant-prev-unread M M ? n gnus-summary-put-mark-as-dormant-next M M ? p gnus-summary-put-mark-as-dormant-prev M M ! ! gnus-summary-put-mark-as-ticked M M ! N gnus-summary-put-mark-as-ticked-next-unread M M ! P gnus-summary-put-mark-as-ticked-prev-unread M M ! n gnus-summary-put-mark-as-ticked-next M M ! p gnus-summary-put-mark-as-ticked-prev M M u N gnus-summary-put-mark-as-unread-next-unread M M u P gnus-summary-put-mark-as-unread-prev-unread M M u n gnus-summary-put-mark-as-unread-next M M u p gnus-summary-put-mark-as-unread-prev M M u u gnus-summary-put-mark-as-unread M M d N gnus-summary-put-mark-as-read-next-unread M M d P gnus-summary-put-mark-as-read-prev-unread M M d d gnus-summary-put-mark-as-read M M d n gnus-summary-put-mark-as-read-next M M d p gnus-summary-put-mark-as-read-prev decimales de pi. Y esto son sólo dos aplicaciones de GNU/Emacs: ECB y Gnus.

2/16/2008

Flymake en php

Agenden esta extensión para flymake, que te cambia la vida. :)

2/12/2008

Filtrar procesos con psgrep para bash

Una alias/función fundamental para cualquier usuario de BASH en GNU/Linux. Agregarle a tu .bashrc:

psgrep()
{
 ps aux | grep $1 | grep -v grep
}

Luego lo usas así:

  psgrep xmms

Útil. ¿No? Muchísimos trucos más pueden encontrarle al bash si instalan su documentación:

  sudo aptitude install bash-doc

Luego navegan el directorio /usr/share/doc/bash-doc/examples

2/10/2008

Probando g-client en emacs 22

Estamos probando hacer un post directamente desde Emacs, utilizando el cliente para servicios de google. Veremos si anda bien.

Si lo quieren probar, los pasos son más o menos los siguientes:

	# sudo aptitude install curl w3m
	# svn -co http://emacspeak.googlecode.com/svn/trunk/lisp/g-client/
	# make

Ahora editas tu ~/.emacs

	(push "~/g-client" load-path)
	(load-library "g")
	(setq g-user-email "example@gmail.com")
	(setq g-html-handler 'browse-url-of-buffer)
	(setq browse-url-browser-function 'w3m-browse-url)

Haces un M-x eval-buffer, luego un gblogger-blog y listo!

Código Maldito

2/24/2008

Las ideas, las patentes, las personas y bla!

Desde emacs II

2/21/2008

Las raíces de Lisp

Traducción

Autor: Paul Graham, borrador Enero 18, 2002

1. Siete operadores primitivos

1. (quote x)

2. (atom x)

3. (eq x y)

4. (car x)

5. (cdr x)

6. (cons x y)

7. (cond (p₁ e₁)...(p_n e_n))

2. Denotar funciones

3. Algunas funciones

1. (null. x)

2. (and. x y)

3. (not. x)

4. (append. x y)

5. (pair. x y)

6. (assoc. x y)

4. La sorpresa

5. Consecuencias

pequeña nota mental

2/16/2008

Flymake en php

2/12/2008

Filtrar procesos con psgrep para bash

2/10/2008

Probando g-client en emacs 22

Archivo del blog

Menéame: publicadas -tecnología-

Barrapunto

enlaces

2/24/2008

2/21/2008

Traducción

Autor: Paul Graham, borrador Enero 18, 2002

1. Siete operadores primitivos

1. (quote x)

2. (atom x)

3. (eq x y)

4. (car x)

5. (cdr x)

6. (cons x y)

7. (cond (p1 e1)...(pn en))

2. Denotar funciones

3. Algunas funciones

1. (null. x)

2. (and. x y)

3. (not. x)

4. (append. x y)

5. (pair. x y)

6. (assoc. x y)

4. La sorpresa

5. Consecuencias

2/16/2008

2/12/2008

2/10/2008

Archivo del blog

Menéame: publicadas -tecnología-

Barrapunto

enlaces

7. (cond (p₁ e₁)...(p_n e_n))