\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:
