From 9aa2037958cd9f9425ee48d6fb81a634559d80c2 Mon Sep 17 00:00:00 2001
From: dakkar <dakkar@luxion>
Date: Mon, 4 Aug 2008 09:34:18 +0000
Subject: importazione pezzi

git-svn-id: svn://luxion/repos/intro-perl@344 fcb26f47-9200-0410-b104-b98ab5b095f3
---
 vecchio-corso.tex | 824 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 824 insertions(+)
 create mode 100755 vecchio-corso.tex

(limited to 'vecchio-corso.tex')

diff --git a/vecchio-corso.tex b/vecchio-corso.tex
new file mode 100755
index 0000000..0043487
--- /dev/null
+++ b/vecchio-corso.tex
@@ -0,0 +1,824 @@
+\documentclass[12pt]{beamer}
+
+% - preambolo: stili, package, comandi
+
+% -- questo imposta lo stile della presentazione
+\mode<presentation>{
+% \usetheme{Frankfurt}
+% \usetheme[secheader]{Boadilla}
+  \usetheme[hideallsubsections,right]{PaloAlto}
+  \usecolortheme{sidebartab}
+  \usecolortheme{seahorse}
+ \setbeamercovered{transparent}
+}
+
+% -- package
+% --- questo è per la grafica
+\usepackage{pgf}
+
+% --- font, encoding, lingua
+\usepackage{times}
+\usepackage[T1]{fontenc}
+\usepackage[italian]{babel}
+
+% -- metadati per la pagina del titolo
+\title[Perl]{Corso introduttivo a Perl}
+\author{dakkar}
+
+\subject{Perl}
+
+% -- comandi di comodo
+% --- slide con titolo implicito
+\newenvironment{slide}[1][c]
+  {\begin{frame}[#1]
+      \frametitle{\insertsubsection}}
+  {\end{frame}}
+% --- come sopra, ma per gli esempi di comandi
+\newenvironment{fslide}[1][c]
+  {\begin{frame}[fragile,environment=fslide,#1]
+      \frametitle{\insertsubsection}}
+  {\end{frame}}
+% --- lista a comparsa progressiva
+\newenvironment{mylist}
+  {\begin{itemize}[<+->]}
+  {\end{itemize}}
+% --- cosa far vedere all'inizio di una ``parte''
+%% \AtBeginPart
+%% {
+%%   \begin{frame}<beamer>
+%%     \frametitle{\insertpart}
+%%     \tableofcontents[hideallsubsections]
+%%   \end{frame}
+%% }
+% --- cosa far vedere all'inizio di una sezione
+\AtBeginSection[]
+{
+  \begin{frame}<beamer>[shrink]
+    \frametitle{\insertsection}
+    \tableofcontents[sectionstyle=show/hide,subsectionstyle=show/show/hide]
+  \end{frame}
+}
+%% \AtBeginSubsection[]
+%% {
+%%   \begin{frame}<beamer>
+%%     \frametitle{Struttura}
+%%     \tableofcontents[sectionstyle=show/hide,subsectionstyle=show/shaded/hide]
+%%   \end{frame}
+%% }
+
+% - contenuti
+\begin{document}
+
+\begin{frame}
+  \titlepage
+\end{frame}
+
+\section[Obiettivi]{Obiettivi del corso}
+
+\subsection{Cosa imparerete}
+
+\begin{slide}
+\begin{itemize}
+\item come si scrive ed esegue un programma Perl
+\item nomi, variabili e valori in Perl
+\item strutture di controllo
+\item subroutine
+\item moduli
+\item espressioni regolari
+\end{itemize}
+\end{slide}
+
+\subsection{Cosa suppongo sappiate}
+
+\begin{slide}
+\begin{itemize}
+\item usare un editor di testi
+\item usare la linea di comando
+\item programmare in qualche linguaggio imperativo
+\end{itemize}
+\end{slide}
+
+\section{Cos'è Perl}
+
+\subsection{Il nome}
+
+\begin{slide}
+\begin{itemize}[<+->]
+\item \texttt{Perl} è il nome del linguaggio
+\item \texttt{perl} è il nome del programma
+\item \texttt{PERL} è un errore
+\end{itemize}
+\end{slide}
+
+\begin{slide}
+\begin{itemize}[<+->]
+\item \emph{non} è una sigla
+\item è un nome
+\item se proprio volete...
+ \begin{itemize}[<+->]
+ \item Practical Extraction and Report Language
+ \item Pathologically Eclectic Rubbish Lister
+ \item Polymorphic Existential Recursive Lambdas
+ \end{itemize}
+\end{itemize}
+\end{slide}
+
+\subsection{Interprete o compilatore?}
+
+\begin{slide}
+\addtocounter{beamerpauses}{1}
+\begin{description}
+\item[Interprete] legge un'istruzione alla volta e la esegue
+ \begin{itemize}[<+->]
+ \item scova gli errori solo quando ci sbatte
+ \item non fa ottimizzazioni serie
+ \end{itemize}
+\item[Compilatore] trasforma il programma da un linguaggio a un altro
+ \begin{itemize}[<+->]
+ \item può scovare molti errori staticamente
+ \item può ottimizzare il codice
+ \item \emph{non è mai sufficiente}
+ \end{itemize}
+\end{description}
+\end{slide}
+
+\begin{slide}
+\begin{itemize}[<+->]
+\item la CPU è un interprete
+\item \texttt{bash} è un interprete
+\item la JVM è un interprete
+\item \texttt{perl} è un interprete
+\end{itemize}
+\end{slide}
+
+\begin{slide}
+\begin{itemize}[<+->]
+\item \texttt{GCC} è un compilatore
+\item \texttt{javac} è un compilatore
+\item \texttt{perl} è un compilatore
+\end{itemize}
+\end{slide}
+
+\begin{slide}
+\texttt{perl} esamina l'intero programma, e se non ci sono errori lo
+\emph{compila} in una struttura dati in RAM, la quale viene poi
+\emph{interpretata}
+\end{slide}
+
+\subsection{La filosofia}
+
+\begin{slide}
+\begin{itemize}[<+->]
+\item simile a un linguaggio naturale
+\item TMTOWTDI
+\item making easy things easy, and hard things possible
+\item \emph{manipulexity} vs. \emph{whipuptitude}
+\end{itemize}
+\end{slide}
+
+\section[Programmi]{Scrivere ed eseguire programmi}
+
+\subsection{File di testo}
+
+\begin{slide}
+\uncover<+->{Come la maggior parte dei linguaggi di programmazione,
+Perl legge i programmi da semplici file di testo.}
+
+\uncover<+->{Per il momento supponiamo di usare soltanto i caratteri
+  dell'insieme ASCII (niente accentate)}
+
+\uncover<+->{È più semplice se usate i fine-linea normali per la
+  vostra piattaforma}
+\end{slide}
+
+\subsection{Convenzioni}
+
+\begin{slide}
+\begin{itemize}[<+->]
+\item per i programmi potete usare i nomi che volete
+\item certe volte si usa \texttt{.pl} come estensione
+\item \texttt{\#!/usr/bin/perl} o \texttt{\#!/usr/bin/env perl}
+\item i file che contengono moduli devono avere nomi particolari
+\end{itemize}
+\end{slide}
+
+\begin{fslide}
+\begin{verbatim}
+#!/usr/bin/env perl
+use strict;
+use warnings;
+
+# qui il vostro programma
+\end{verbatim}
+\end{fslide}
+
+\subsection{Esecuzione}
+
+\begin{slide}
+\begin{itemize}[<+->]
+\item \texttt{perl nomefile}
+\item *NIX: \texttt{chmod +x nomefile; ./nomefile}
+\item Windows: trucchi con i file \texttt{.BAT}
+\end{itemize}
+\end{slide}
+
+\section{Sintassi}
+
+\subsection{Istruzioni}
+
+\begin{slide}
+Le istruzioni sono terminate da punto-e-virgola:
+
+\vspace{1em}\hspace{2em}\texttt{print 'Buh!';}
+\end{slide}
+
+\subsection{Commenti}
+
+\begin{slide}
+Il carattere \texttt{\#} inizia un commento che si estende fino alla
+fine della linea:
+
+\vspace{1em}\hspace{2em}\texttt{print 'Buh!'; \# commento}
+\end{slide}
+
+\subsection{Spazi}
+
+\begin{slide}
+Gli spazi \emph{tra parole} non sono significativi:
+
+\vspace{1em}\hspace{2em}\texttt{print}\\
+\hspace{2em}\texttt{\ \ 'Buh!';}
+\end{slide}
+
+\begin{slide}
+Gli spazi \emph{dentro le stringhe} sono mantenuti:
+
+\vspace{1em}\hspace{2em}\texttt{print 'Buh!}\\
+\hspace{2em}\texttt{\ \ Bah!';}
+\end{slide}
+
+\subsection{Valori}
+
+\begin{slide}
+I numeri si scrivono normalmente:
+\begin{itemize}[<+->]
+\item \texttt{12}
+\item \texttt{7.45}
+\item \texttt{7.3e-2}
+\item \texttt{015}
+\item \texttt{0x40}
+\end{itemize}
+\end{slide}
+
+\begin{fslide}
+Le stringhe si scrivono tra virgolette:
+\begin{itemize}[<+->]
+\item \texttt{'gino'}
+\item \verb|'$&^@$&*^#'|
+\end{itemize}
+\end{fslide}
+
+\begin{fslide}
+Il tipo di virgolette fa differenza!
+\addtocounter{beamerpauses}{1}
+\begin{itemize}[<+->]
+\item \verb|'abc\ndef'| sono 8 caratteri
+\item \verb|"abc\ndef"| sono 7 caratteri, e il 4$^o$ è un a-capo
+\end{itemize}
+\uncover<+->{Le virgolette doppie \emph{interpolano}}
+\end{fslide}
+
+\section[Variabili]{Variabili e valori}
+
+\subsection{Tipi}
+
+\begin{fslide}
+Perl converte tra numeri e stringhe secondo l'uso:
+
+\begin{itemize}
+\item \verb|'23'+2| fa \texttt{25}
+\item \verb|23 . 'c'| fa \texttt{'23c'}
+\end{itemize}
+\end{fslide}
+
+\begin{slide}
+I tipi base di Perl sono:
+
+\begin{itemize}[<+->]
+\item \emph{scalari}, singoli valori
+\item \emph{array}, sequenze di scalari indicati per posizione
+\item \emph{hash}, dizionario di scalari indicati con chiave stringa
+\end{itemize}
+\end{slide}
+
+\subsection[Nomi]{Nomi e visibilità}
+
+\begin{slide}
+Perl usa i \emph{sigilli} per indicare i tipi dei nomi:
+
+\begin{itemize}[<+->]
+\item \texttt{\$} indica uno scalare
+\item \texttt{@} indica un array
+\item \texttt{\%} indica un hash
+\end{itemize}
+\end{slide}
+
+\begin{frame}[c]
+\frametitle{Accedere agli elementi}
+\begin{itemize}[<+->]
+\item \texttt{\$array[1]} è il secondo elemento (scalare) dell'array
+  \texttt{@array}
+\item \texttt{@array[1,2]} è uno \emph{slice} (pezzo di array)
+\item \texttt{\$hash\{a\}} è l'elemento (scalare) dell'hash \texttt{\%hash}
+  corrispondente alla chiave \texttt{'a'}
+\end{itemize}
+\end{frame}
+
+\begin{slide}
+È buona norma dichiarare i nomi che vogliamo usare:
+
+\vspace{1em}\hspace{2em}\texttt{my \$scalare;}\\
+\hspace{2em}\texttt{my @array;}\\
+\hspace{2em}\texttt{my \%hash;}
+\end{slide}
+
+\begin{fslide}
+I nomi dichiarati con \texttt{my} sono visibili solo all'interno del
+blocco in cui compare la dichiarazione:
+
+\begin{verbatim}
+my $a=3;
+{
+ my $b=5;
+ print "a=$a\n"; # a=3
+ print "b=$b\n"; # b=5
+}
+print "a=$a\n";  # a=3
+print "b=$b\n";  # b=
+\end{verbatim}
+\end{fslide}
+
+\subsection[Contenitori]{Contenitori e durata}
+
+\begin{slide}
+\begin{itemize}[<+->]
+\item \emph{Non} scendo nei dettagli
+\item Un nome riferisce un contenitore di un certo tipo
+\item Il contenitore contiene un valore del tipo giusto
+\item Più nomi possono riferire lo stesso contenitore
+\item La memoria occupata viene liberata quando non ce n'è più bisogno
+  (\emph{garbage collection})
+\end{itemize}
+\end{slide}
+
+\subsection{Valori}
+
+\begin{slide}
+Valori immediati:
+
+\begin{itemize}[<+->]
+\item numeri: \texttt{2.24}
+\item stringhe: \texttt{'gino'}
+\item liste: \texttt{(1,2,'pino')}
+\item liste con la freccia: \texttt{( a => 1, b => 'buh')}
+\end{itemize}
+\end{slide}
+
+\begin{slide}
+Assegnamento:
+
+\begin{itemize}[<+->]
+\item \texttt{\$numero = 2.24;}
+\item \texttt{\$stringa = 'gino';}
+\item \texttt{@array = (1,2,'pino');}
+\item \texttt{\%hash = (a => 1, b => 'buh');}
+\end{itemize}
+\end{slide}
+
+\begin{slide}
+\uncover<+->{Un contenitore scalare cui non è mai stato assegnato
+nulla ha valore \texttt{undef}.}
+
+\uncover<+->{\texttt{undef} ha valore numerico \texttt{0} e valore
+stringa \texttt{''}}
+\end{slide}
+
+
+\subsection{Contesto}
+
+\begin{slide}
+\uncover<+->{Ogni espressione Perl viene valutata in un certo
+\emph{contesto}, e il suo valore di solito dipende dal contesto.}
+
+\uncover<+->{Esempi:}
+
+\uncover<.->{\vspace{1em}\hspace{2em}\texttt{@array=1;}}\\
+\uncover<+->{array di 1 elemento, \texttt{\$array[0]==1}}
+
+\uncover<+->{\vspace{0.5em}\hspace{2em}\texttt{\$scalare=('a','b','c');}}\\
+\uncover<+->{\texttt{\$scalare} vale 'c'}
+
+\uncover<+->{\vspace{0.5em}\hspace{2em}\texttt{@array=('a','b','c');}\\
+\hspace{2em}\texttt{\$scalare=@array;}}\\
+\uncover<+->{\texttt{\$scalare} vale 3}
+\end{slide}
+
+\begin{slide}
+Esempi (cont.):
+
+\uncover<+->{\vspace{1em}\hspace{2em}\texttt{\%hash=1;}}\\
+\uncover<+->{errore!}
+
+\uncover<+->{\vspace{1em}\hspace{2em}\texttt{\%hash=('a',1);}}\\
+\uncover<+->{\texttt{\$hash\{a\}} vale 1}
+
+\uncover<+->{\vspace{0.5em}\hspace{2em}\texttt{\$scalare=\%hash;}}\\
+\uncover<+->{\texttt{\$scalare} è 0 se \texttt{\%hash} è vuoto,
+  qualcos'altro altrimenti}
+\end{slide}
+
+\section[Struttura]{Strutture di controllo}
+
+\subsection{Condizionali}
+
+\begin{fslide}[t]
+\begin{semiverbatim}
+if ($guardia) \{
+ # blocco da eseguire
+ # se $guardia e` vero
+\}
+\only<3->{elsif ($guardia2) \{
+ # blocco da eseguire
+ # se $guardia e` falso
+ # e $guardia2 e` vero
+\}
+}\only<2->{else \{
+}\only<2>{ # blocco da eseguire
+ # se $guardia e` falso
+}\only<3->{ # blocco da eseguire
+ # se $guardia e` falso
+ # e $guardia2 e` falso
+}\only<2->{\}}
+\end{semiverbatim}
+\end{fslide}
+
+\begin{fslide}
+\begin{verbatim}
+unless ($guardia) {
+ # blocco da eseguire
+ # se $guardia e` falso
+}
+\end{verbatim}
+\end{fslide}
+
+\begin{frame}
+\frametitle{Vero e falso}
+
+\begin{itemize}[<+->]
+\item \texttt{0} è falso
+\item \texttt{''} (stringa vuota) è falso
+\item \texttt{'0'} è falso (!)
+\item \texttt{undef} è falso
+\item \emph{tutto il resto} è vero
+\end{itemize}
+\end{frame}
+
+\subsection{Cicli limitati}
+
+\begin{fslide}
+\begin{verbatim}
+for my $elemento (@array) {
+  # blocco che usa $elemento
+}
+\end{verbatim}
+
+\uncover<2->{NOTA: se assegnate a \texttt{\$elemento}, cambiate i
+  valori in \texttt{@array}.}
+\end{fslide}
+
+\begin{fslide}
+\begin{verbatim}
+for my $elemento (1,2,3,4) {
+  # blocco che usa $elemento
+}
+\end{verbatim}
+
+Qui \emph{non potete} assegnare a \texttt{\$elemento}.
+\end{fslide}
+
+\begin{fslide}
+\begin{verbatim}
+for my $elemento (1..4) {
+  # blocco che usa $elemento
+}
+\end{verbatim}
+
+Come prima.
+\end{fslide}
+
+\subsection{Cicli illimitati}
+
+\begin{fslide}
+\begin{verbatim}
+while ($guardia) {
+ # blocco ripetuto
+ # finche' $guardia e` vero
+}
+\end{verbatim}
+\end{fslide}
+
+\begin{fslide}
+\begin{verbatim}
+until ($guardia) {
+ # blocco ripetuto
+ # finche' $guardia e` falso
+}
+\end{verbatim}
+
+NOTA: il blocco può anche non essere mai eseguito!
+\end{fslide}
+
+\begin{fslide}
+\begin{verbatim}
+for(my $i=0;$i<10;++$i) {
+ # blocco
+}
+\end{verbatim} %$
+
+Come in C. Si usa di rado.
+\end{fslide}
+
+\subsection{Modificatori}
+
+\begin{fslide}
+\begin{semiverbatim}
+\uncover<+->{print ``ok\\n'' if $debug;}
+\uncover<+->{print ``$_\\n'' for @array;}
+\uncover<+->{$i++ while $array[$i]<=0;}
+\end{semiverbatim} %$
+\end{fslide}
+
+\section[Predefiniti]{Operatori e funzioni predefinite}
+
+\subsection{Aritmetica}
+
+\begin{fslide}
+\begin{verbatim}
+++$numero; $numero--;
+
+$c = $a * $b; $c = $a / $b; $c = $a % $b;
+
+$c = $a + $b; $c = $a - $b;
+\end{verbatim}
+\end{fslide}
+
+\subsection{Stringa}
+
+\begin{fslide}
+\begin{verbatim}
+++$stringa; $stringa--;
+
+$c = $a x $b;
+
+$c = $a . $b;
+\end{verbatim}
+\end{fslide}
+
+\subsection{Confronto}
+
+\begin{fslide}
+\begin{verbatim}
+$a < $b    $a lt $b
+$a <= $b   $a le $b
+$a == $b   $a eq $b
+$a >= $b   $a ge $b
+$a > $b    $a gt $b
+\end{verbatim}
+\end{fslide}
+
+\subsection{Booleani}
+
+\begin{fslide}
+\begin{verbatim}
+&&      and
+||      or
+!       not
+\end{verbatim}
+\end{fslide}
+
+\subsection{Assegnamento}
+
+\begin{slide}
+Quasi tutti gil operatori binari possono essere combinati con
+l'assegnamento:
+
+\vspace{1em}\hspace{2em}\texttt{\$a .= \$b;}\\
+\hspace{2em}\texttt{\$a += \$b;}
+\end{slide}
+
+\section[I/O]{File e I/O}
+
+\subsection[Aprire]{Aprire un file}
+
+\begin{fslide}
+\begin{verbatim}
+open HANDLE,'<nomefile';
+
+open my $handle,'>','nomefile';
+\end{verbatim} %$
+\end{fslide}
+
+\subsection[Scrivere]{Scrivere su un file}
+
+\begin{fslide}
+\begin{verbatim}
+print HANDLE "qualcosa\n";
+
+print $handle $qualcosa,"\n";
+\end{verbatim}
+\end{fslide}
+
+\subsection[Leggere]{Leggere da un file}
+
+\begin{fslide}
+\begin{verbatim}
+$linea=<HANDLE>;
+
+@linee=<$handle>;
+\end{verbatim}
+
+\uncover<2->{In contesto scalare, \texttt{<>} restituisce
+  \texttt{undef} a fine file.}
+\end{fslide}
+
+\subsection[Chiudere]{Chiudere un file}
+
+\begin{fslide}
+\begin{verbatim}
+close HANDLE;
+
+close $handle;
+\end{verbatim} %$
+
+\uncover<2->{Se usate l'handle scalare, il file viene chiuso dal
+  garbage collector: non serve chiamare \texttt{close}.}
+\end{fslide}
+
+\subsection{Esempio}
+
+\begin{fslide}
+\begin{verbatim}
+open my $input,'<',$ARGV[0];
+open my $output,'>',$ARGV[1];
+
+while (my $linea=<$input>) {
+ print $output $linea;
+}
+\end{verbatim}
+\end{fslide}
+
+\section{Subroutine}
+
+\subsection[Definire]{Definire una subroutine}
+
+\begin{fslide}
+\begin{verbatim}
+sub saluta {
+  print "Ciao!\n";
+  return;
+}
+\end{verbatim}
+\end{fslide}
+
+\subsection[Parametri]{Il passaggio dei parametri}
+
+\begin{fslide}
+Le subroutine ricevono i parametri nell'array \texttt{@\_}.
+
+\begin{verbatim}
+sub somma {
+ my $ret=0;
+ for my $numero (@_) {
+  $ret+=$numero;
+ }
+ return $ret;
+}
+\end{verbatim} %$
+\end{fslide}
+
+\subsection[Chiamare]{Chiamare una subroutine}
+
+\begin{fslide}
+\begin{verbatim}
+saluta();saluta;
+
+my $tot=somma(1..10);
+\end{verbatim} %$
+
+Le parentesi non sono strettamente necessarie, se avete già dichiarato
+la subroutine.
+\end{fslide}
+
+\subsection[Ritorno]{Valore di ritorno}
+
+\begin{slide}
+L'istruzione \texttt{return} viene usata per restituire un valore al
+chiamante.
+
+\uncover<2->{L'argomento di \texttt{return} è un'espressione che viene
+  valutata nel contesto in cui è stata chiamata la subroutine.}
+\end{slide}
+
+\begin{fslide}
+\begin{verbatim}
+sub leggi_file {
+ my ($filename)=@_;
+ open my $handle,'<',$filename;
+ return <$handle>;
+}
+
+$prima_riga  = leggi_file '/tmp/file1';
+@tutte_righe = leggi_file '/tmp/file1';
+\end{verbatim} %$
+\end{fslide}
+
+\section[Moduli]{Moduli e CPAN}
+
+\subsection[Usare]{Usare i moduli}
+
+\begin{slide}
+\texttt{use Text::Wrap;}
+
+\begin{itemize}[<+->]
+\item cerca \texttt{Text/Wrap.pm} e lo ``carica''
+\item ci sono parecchi dettagli, ma per ora possiamo ignorarli
+\end{itemize}
+\end{slide}
+
+\begin{fslide}
+\begin{verbatim}
+use Text::Wrap;
+
+$Text::Wrap::columns=40;
+my $result=wrap('  ','',$text);
+\end{verbatim} %$
+
+\addtocounter{beamerpauses}{1}
+\begin{itemize}[<+->]
+\item un modulo spesso introduce un \emph{namespace}
+\item un modulo spesso \emph{esporta} delle subroutine
+\end{itemize}
+\end{fslide}
+
+\subsection{CPAN}
+
+\begin{slide}
+\begin{itemize}[<+->]
+\item non scendo nei dettagli
+\item se avete un problema, molto probabilmente qualcuno l'ha già
+  risolto
+\item \texttt{http://search.cpan.org/}
+\item 11450 pacchetti, liberamente usabili
+\end{itemize}
+\end{slide}
+
+\section[Oltre]{Oltre questo corso}
+
+\subsection{Libri}
+
+\begin{slide}
+\begin{itemize}
+\item Learning Perl
+\item Intermediate Perl
+\item Programming Perl
+\end{itemize}
+\end{slide}
+
+\subsection{In rete}
+
+\begin{slide}
+\begin{itemize}
+\item \texttt{http://www.perl.it/}
+\item \texttt{http://use.perl.org/}
+\item \texttt{http://learn.perl.org/}
+\item \ldots\texttt{/library/beginning\_perl/}
+\item \texttt{http://www.perlmonks.org/}
+\end{itemize}
+\end{slide}
+
+\begin{slide}
+\begin{itemize}
+\item \texttt{\#perl.it} su FreeNode
+\item \texttt{mongers@perl.it}
+\end{itemize}
+\end{slide}
+
+\end{document}
+
+% - 
+% Local Variables:
+% mode: outline-minor
+% outline-regexp: "\\(. -+ \\)\\|\\\\part\\|\\\\section\\|\\\\subsection"
+% coding: iso-8859-1
+% tex-command: "pdflatex"
+% End:
-- 
cgit v1.2.3

