% -*- coding: raw-text-unix -*-

\documentclass{beamer}
\usepackage{beamerthemesplit}
\usepackage[brazilian,english]{babel}
\usepackage[latin1]{inputenc}
\usepackage{amsmath}
\usepackage{graphicx}

\catcode`=13 \def{$\bullet$}
\catcode`=13 \def{\item}
\catcode`=13 \long\def{\par}
\def\xtot#1{\xrightarrow{\text{#1}}}
\def\xtote{\xrightarrow{\;\;\;\;}}
\def\mtot#1{\mapstochar\xrightarrow{\text{#1}}}
\def\mtote{\mapstochar\xrightarrow{\;\;\;\;}}

\def\newslide#1{\bigskip \hrule {\bf #1}}
\def\Newslide#1{\newpage \hrule {\bf #1}}
\long\def\myslide#1#2{\frame{\frametitle{#1}#2}}

\def\ssk{\smallskip}
\def\msk{\medskip}
\def\bsk{\bigskip}
\def\bsl{\hbox{$\backslash$}}

% (find-angg "LATEX/edrx.sty" "arrows")
\def\bij{\leftrightarrow}

%-------------------------------
\title{Emacs e eev, ou: como automatizar quase tudo}
\author{Eduardo Ochs - http://angg.twu.net/}
\date{13 de agosto de 2005}

\begin{document}

%-------------------------------
\frame{\maketitle}

%-------------------------------
\myslide{O que se diz por aí}{
Emacs é um editor de texto
\begin{itemize}
  \item enorme		   
  \item complicado	   
  \item ocupa muita memória
  \item	usa muitas teclas  
\end{itemize}
\bigskip
Mas na verdade o Emacs é o editor de texto {\sl extensível} mais simples
possível.
}

%-------------------------------
\myslide{Outra definição pro Emacs}{
 Emacs é um {\sl ambiente Lisp}
 (criado na década de 1970)
 e Lisp é uma linguagem de programação
 (criada na década de 1950).

\medskip

{\sl Isso não é meio velho?}
 Geometria, números inteiros e frações têm milhares de anos.
 A noção de número que a gente tem hoje em dia é de 1858.\footnote{
    definida por ``cortes de Dedekind'': \\
    0.999999999... = 1.0000000000... = 1
  }

\medskip
 {\bf O que é um computador?}
 Como fazer uma máquina que executa operações em seqüência?
\begin{itemize}
   1822: Difference Engine (Charles Babbage; mecânica)
   1936: Turing Machine (Alan Turing; teórica)
   ~1940+: computadores eletrônicos
\end{itemize}
}

%-------------------------------
\myslide{O que é um computador}{
 = Memória + processador.
  \bigskip
 O processador lê alguns bytes da memória e
 ``executa uma instrução'' ---
 a memória (o ``estado'' do computador) se modifica.
  \bigskip
 Um trecho da memória corresponde aos pontos da tela.
 Algumas posições da memória correspondem ao teclado.
  \bigskip
 Um computador assim é parecido com uma Máquina de Turing. \\
 Ele é fácil de construir mas difícil de programar.
}

%-------------------------------
\myslide{O que é um programa?}{
 (Estamos na décadas de 1950).
 Como expressar um procedimento como uma série de passos?
 Como fazer uma máquina que executa estes passos para nós?
\bigskip
 Considere: {\sl as pessoas que estão inventando computadores e
  linguagens de programação em 1950 estão a par de 2500 anos de
  discussões.}
\bigskip
 {\bf 1950: Lisp.} É mais natural (para seres humanos) expressar \\
algoritmos em Lisp do que em "linguagem de máquina".

\bigskip

Problema $\xtot{\phantom{aaaaaaaaaa} programador \phantom{aaaaaaaaaa}}$
linguagem de máquina

\medskip

Problema $\xtot{programador}$ programa em Lisp
}

%-------------------------------
\myslide{Objetos em Lisp}{
Objetos em Lisp podem ser dos seguintes tipos:
\begin{itemize}
   Números: 0, 1, 2, -20, 3.14
   Strings: "", "AbC", " Foo bar", "(+ 1 2)"
   Símbolos: a, b, nil, t, square, +, *
   Listas: (), (2 "dois"), \\
    (* (+ 1 2) (+ 3 4)), \\
    (concat "abc" "def")
\end{itemize}

\bigskip

Truque: TODAS as coisas mais complicadas são
implementadas usando listas, e listas são
construídas usando `cons'es.

}

%-------------------------------
\myslide{Como um ambiente Lisp tradicional funciona}{

 LISP$>$ (+ 1 2)
 3
 LISP$>$ (* (+ 1 2) (+ 3 4))
 21
 LISP$>$ (setq a 5)
 5
 LISP$>$ a
 5
 LISP$>$ (* a a)
 25

\bigskip

"(+ 1 2)" $\mtot{read}$
(+ 1 2)   $\mtot{eval}$
3         $\mtot{print}$
"3"       $\quad$ (na tela)
}

%-------------------------------
\myslide{Como o eval funciona}{

\begin{tabular}{lrrll}
  (* &       3 &       7) & $\mtote$ & 21 \\
  (* & (+ 1 2) & (+ 3 4)) & $\mtote$ & 21
\end{tabular}

\medskip

\begin{tabular}{rclcc}
  (setq & a & 22) & $\mtote$ & 22 \\
        & a &     & $\mtote$ & 22 \\
\end{tabular}

\medskip

\begin{tabular}{lll}
22    & $\mtote$ & 22    \\
"abc" & $\mtote$ & "abc" \\
t     & $\mtote$ & t     \\
nil   & $\mtote$ & nil   \\
()    & $\mtote$ & nil
\end{tabular}

\medskip

\begin{tabular}{lllll}
($<$ 1 2)   & $\mtote$ & t    && (verdadeiro) \\
($<$ 2 0)   & $\mtote$ & nil  && (falso)
\end{tabular}

\bigskip

\begin{tabular}{ccc}
(if ($<$ 1 2) "sim" "nao") & $\mtote$ & "sim"
\end{tabular}

}

%-------------------------------
\myslide{Tudo num sistema Lisp são objetos em Lisp}{

Funções (programas):

\begin{tabular}{ccc}
  5 & $\mtot{square}$ & 25      \\
  x & $\mtote$        & (* x x)
\end{tabular}

\medskip

square = (lambda (x) (* x x))

\medskip

 (setq a 22)
 (setq square 33)
 (defun square (x) (* x x))

\medskip

% (find-sh0 "cd /tmp/beamer/ && convert ~/IMAGES/diad_symbols.png symbols.eps")
% (find-eimage0 "~/IMAGES/diad_symbols.png")
$\includegraphics[scale=0.90]{twosymbols.eps}$
}

%-------------------------------
\myslide{Como listas são construídas usando "cons"}{

%% http://www.paulgraham.com/lib/paulgraham/jmc.ps
%% (code-ps "pgroots" "$S/http/www.paulgraham.com/lib/paulgraham/jmc.ps")
%% (find-pgrootspage 8)

% (find-sh0 "cd /tmp/beamer/ && convert ~/IMAGES/diad_lambdax.png lambdax.eps")
% (find-eimage0 "~/IMAGES/diad_lambdax.png")
$\includegraphics[scale=0.85]{lambdax.eps}$

\bigskip

O estado do sistema é determinado pelo(s) valor(es) dos símbolos.

\bigskip

É possível explicar o Lisp inteiro, com {\sl todos} os detalhes, em
uma hora ou menos --- a parte difícil é o eval.

Nós não temos esse tempo, mas não precisamos dos detalhes do Lisp
agora --- é melhor vermos o Emacs primeiro.

}
%-------------------------------
\myslide{Editores de texto extensíveis}{
 O núcleo do Emacs é o editor de texto extensível
 o mais simples possível.

\bigskip

 Início da década de 70: TECO (editor programável)
 Linguagem de progração ruim, extensões incompatíveis entre si.
 Como fazer o melhor editor programável possível?

\bigskip

 Idéia: pegue a linguagem de programação mais flexível de todas ---
  Lisp --- e acrescente funções para transformá-la num editor.

\bigskip

 Outra idéia importante: o editor seria desenvolvido pela {\sl
  comunidade}.

}

%-------------------------------
\myslide{Emacs = Lisp + umas poucas coisas}{

Interface Lisp convencional:

 LISP$>$ (+ 1 2)
 3

"(+ 1 2)" $\mtot{read}$
(+ 1 2)   $\mtot{eval}$
3         $\mtot{print}$
"3"       $\quad$ (na tela)

\bsk

Interface do Emacs:

C-x C-f foo RET
$\mtote$ "{\bsl}C-x{\bsl}C-ffoo{\bsl}r"

$\mtote$ (find-file "foo")
$\mtot{eval}$ nil

\bsk

Além disso:
\begin{itemize}
 Buffers ($\bij$) arquivos
 Cursor (``point'')
 ``Windows'' (cada uma mostra um buffer)
 ``Frames'' (cada uma mostra uma ou mais windows; 1992)
 Última linha da tela: ``echo area'' (quando mostra mensagens),
  ``minibuffer'' (durante comandos complicados)
\end{itemize}

}

%-------------------------------
\myslide{Emacs = Lisp + umas poucas coisas (2)}{

(Continuação...)
\begin{itemize}
 M-x eval-last-sexp (ou: C-x C-e)
 eval-region, load-library
 Arquivo de inicialização: .emacs
 Modos:
  \begin{itemize}
   ``Fundamental'' (básico, para edição)
   ``Dired'' (``directory editor'')
   ``Info''
   ``Lisp Interaction''
  \end{itemize}
 Suporte a ``faces'' (cores e fontes) e imagens (1992)
\end{itemize}

% (find-eetcfile "")

}

%-------------------------------
\myslide{...e em cima disso montaram um sistema modular...}{

 Exemplo: hippie-expand (hippie-exp.el)
 (Prefixos: hippie-, he-, try-)

\bsk

Como aprender?
\begin{itemize}
 Como eu faço X?
  \begin{itemize}
   Perguntar pra pessoa do seu lado no laboratório
   Ler a documentação
  \end{itemize}
 Como Y funciona (ou: porque Y funciona assim e não como eu esperava)?
  \begin{itemize}
   Perguntar pro autor do Y
   Perguntar pra mais alguém
   Ler o código-fonte
   Fazer experimentos (e hipóteses) (*)
   Rodar o código de Y passo-a-passo
  \end{itemize}
\end{itemize}

\msk

Obs: em programas comerciais fechados a única possibilidade é (*).

}

%-------------------------------
\myslide{Acesso à documentação}{

  \begin{itemize}
   Arquivos de texto
   Arquivos HTML (formato recente: 1992?)
   Manpages
   Código-fonte (indentação, syntax highlighting, tags)
   Manuais em formato Info
   Programas externos:
    \begin{itemize}
     Web browsers
     Visualizadores de arquivos ps, pdf, dvi, etc
    \end{itemize}
  \end{itemize}

}

%-------------------------------
\myslide{Emacs = comunidade (1)}{

% http://www.gnu.org/software/emacs/emacs-paper.html#SEC29
De $<$http://www.gnu.org/software/emacs/emacs-paper.html$>$
 (um artigo do Stallman de 1979):

\medskip

The programmable editor is an outstanding opportunity to learn to
program! A beginner can see the effect of his simple program on the
text he is editing; this feedback is fast and in an easily understood
form. Educators have found display programming to be very suited for
children experimenting with programming, for just this reason (see
LOGO).

\medskip

Programming editor commands has the additional advantage that a
program need not be very large to be tangibly useful in editing. A
first project can be very simple. One can thus slide very smoothly
from using the editor to edit into learning to program with it.

\medskip

(continua)
}

%-------------------------------
\myslide{Emacs = comunidade (2)}{

(Continuação:)

\medskip

When large numbers of nontechnical workers are using a programmable
editor, they will he tempted constantly to begin programming in the
course of their day-to-day lives. This should contribute greatly to
computer literacy, especially because many of the people thus exposed
will be secretaries taught by society that they are incapable of doing
mathematics, and unable to imagine for a moment that they can learn to
program. But that won't stop them from learning it if they don't know
that it is programming that they are learning! According to Bernard
Greenberg, this is already happening with Multics EMACS.

}

%-------------------------------
\myslide{Um pouco de etologia}{

\begin{itemize}
 Macho alfa - competição, liderança, visibilidade
 Machos beta - cooperação, trabalho de grupo, educação dos filhotes
 Machos ômega - ou muito inferiores na hierarquia ou solitários
    (vivem fora da matilha)
\end{itemize}

\msk

 Todo mundo presta atenção a cada movimento do macho alfa.
 A cultura atual (noticiários, propagandas, filmes)
    fala principalmente de alfas.
 As fêmeas preferem os alfas.

\msk

 O alfa não sabe lavar pratos.

}

%-------------------------------
\myslide{O método polonês para quase acabar com os ratos}{
 
 Pegue dez ratos.
 Ponha-os no tanque da área de serviço.
 Dê um jeito deles não conseguirem sair.
 Deixe-os com água e sem comida.
 Eles vão começar a se comer uns aos outros.
 Depois de um tempo (uma semana?) vai sobrar um único rato.
 Solte-o na sua casa.
 Os outros ratos da casa percebem o que ele passou
  e o que ele sabe fazer e se mudam pra outro lugar.

\bsk

Esse rato é o mais forte (característica de alfa) mas os outros não
querem tê-lo como líder.

}

%-------------------------------
\myslide{O programador alfa vende produtos acabados}{

No mundo do software grupos de programadores competem para fazer o
melhor produto.

O eev não é ``o melhor programa'' nem ``a melhor solução''.

}

\end{document}



%:::::::::::::::::::::::::::::::::::::::


Idéias ainda não escritas:

aberto: se você quer saber como uma tecla funciona 


Ordem no workshop: avaliação

M-?


windows, buffers, frames, keys, keymaps

#
# (find-eevfile "slides/")
cd ~/eev-current/slides/
latex         slides-pt.tex && \
  dvips -o    slides-pt.ps   slides-pt.dvi   && \
  dvipdf      slides-pt.dvi  slides-pt.pdf   && \
  gzip -c9  < slides-pt.ps > slides-pt.ps.gz && \
  regv-beamer slides-pt.ps
rm         -v slides-pt.{aux,log,nav,out,snm,toc}

#
cd ~/eev-current/slides/
Scp -C {lambdax,twosymbols}.{svg,eps} \
  edrx@angg.twu.net:slow_html/eev-current/slides/

#
cd ~/eev-current/slides/
Scp -C slides-pt.{tex,ps,ps.gz,pdf} \
  edrx@angg.twu.net:slow_html/eev-current/slides/

#
Scp -C ~/TODO ~/BEAMER/eev-slides.tex edrx@angg.twu.net:important/


w prep-apti-X
alias apti='aptitude install'
aptitude install expect
aptitude install fvwm xzoom tkdiff
aptitude install latex-beamer gv
aptitude install unclutter
chmod 666 /var/cache/fonts/ls-R
laf /var/cache/fonts/ls-R
prep-apti-eev-full
prep-apti-X