presentation.tex

\documentclass[16pt]{beamer}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{graphicx}
\usepackage[polish]{babel}
\usepackage{url}
\input{pygments}

\usetheme{Pittsburgh}
\usenavigationsymbolstemplate{} % turn off navigation icons
\setbeamercovered{transparent}

\author{Silesian Ruby Users Group\\\footnotesize{Jakub Kuźma}}
\title{Lisp - Introduction}

\begin{document}

\frame{\titlepage}

\begin{frame}
  \frametitle{WTF?}
  \begin{center}
    Lisp?!?
  \end{center}
\end{frame}

\begin{frame}
  \frametitle{Lisp Dialects}
  \begin{itemize}
  \item Common Lisp (gcl)
  \item Scheme (guile)
  \item Clojure (JVM)
  \item AutoLISP (AutoCAD)
  \item Emacs Lisp (Emacs)
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{John McCarthy\\September 4, 1927 -- October 24, 2011}
  \begin{figure}
    \includegraphics[width=0.8\linewidth]{mccarthy.jpg}
  \end{figure}
\end{frame}

\begin{frame}
  \frametitle{Atoms}
  \begin{block}{}
    Atoms are strings of letters and digits and other characters not
    otherwise used in Lisp.
  \end{block}
  \begin{itemize}
  \item 0, 42, 3.14
  \item ``hello, world!''
  \item foo, car, +
  \item nil, t
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Lists}
  \begin{block}{}
    A list consist of a left parenthesis followed by zero or more
    atoms or lists separated by spaces and ending with a right
    parenthesis.
  \end{block}
  \begin{itemize}
  \item ()
  \item (foo)
  \item (1 + 2)
  \item (foo (bar (baz)))
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Symbolic Expressions}
  \begin{block}{}
    Not all s-expressions are valid Lisp programs.
  \end{block}
\end{frame}

\begin{frame}
  \frametitle{Primitives}
  \begin{itemize}
  \item (quote $e$)
  \item (car $e$)
  \item (cdr $e$)
  \item (cons $e_1$ $e_2$)
  \item (equal $e_1$ $e_2$)
  \item (atom $e$)
  \item (cond ($p_1$ $e_1$) ... ($p_n$ $e_n$))
  \item An atom $v$, regarded as a variable, may have a value.
  \item ((lambda ($v_1$ ... $v_n$) $e$) $e_1$ ... $e_n$)
  \item ((label $f$ (lambda ($v_1$ ... $v_n$) $e$)) $e_1$ ... $e_n$)
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Cons cell}
  \begin{figure}
    \includegraphics[width=0.6\linewidth]{cons.pdf}
  \end{figure}
\end{frame}

\begin{frame}
  \frametitle{List, first example}
  \begin{figure}
    \includegraphics[width=0.6\linewidth]{list-1.pdf}
  \end{figure}
  \begin{itemize}
  \item (cons 1 nil)
  \item (1 . nil)
  \item (1)
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{List, second example}
  \begin{figure}
    \includegraphics[width=0.6\linewidth]{list-2.pdf}
  \end{figure}
  \begin{itemize}
  \item (cons 1 (cons 2 (cons 3 nil)))
  \item (1 . (2 . (3 . nil)))
  \item (1 2 3)
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{List, third example}
  \begin{figure}
    \includegraphics[width=0.6\linewidth]{list-3.pdf}
  \end{figure}
  \begin{itemize}
  \item (cons (cons 1 2) (cons 3 4))
  \item ((1 . 2) . (3 . 4))
  \item ((1 . 2) 3 . 4)
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Calling functions}
  \begin{block}{}
    The most common way of invoking a function in Lisp is by
    evaluating a list. Others are: funcall, apply, etc.
  \end{block}
  \begin{itemize}
  \item (+ 2 2)
  \item (* (+ 1 3) 5)
  \item (concat ``a'' ``b'')
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Defining functions}
  \begin{itemize}
  \item anonymous: (lambda (a b) (+ a b))
  \item named: (defun double (x) (* 2 x))
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Defining variables}
  \begin{itemize}
  \item (set 'x 1)
  \item (setq x 1)
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Bindings}
  \begin{block}{}
  A ``binding'' is a relationship of
  correspondence between a name and a memory location.
  \end{block}
  \begin{itemize}
  \item ((lambda (a b) (...)) 1 3)
  \item (let (x y z) (...))
  \item (let ((a 1) (b 2)) (...))
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Conditions}
  \begin{itemize}
  \item (cond ((= x 0) 1) (t x))
  \item (if (= x 0) 1 x)
  \item (unless (> x 0) (print x))
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Collections}
  \begin{itemize}
  \item lists: (1 2 3 4 5)
  \item arrays: [1 2 3 4]
  \item hashes: (make-hash-table)
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Map, reduce}
  \begin{itemize}
  \item (mapcar (lambda (x) (* x 2)) '(1 2 3 4 5))
  \item (reduce (lambda (acc x) (+ acc x)) [1 2 3 4 5])
  \item (reduce #'+ [1 2 3 4 5])
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Macros}
  \begin{block}{}
  Macros are programs that generate programs.
  \end{block}
  \begin{itemize}
  \item (loop for i from 1 to 10 do (print i) finally return 1)
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Books}
  \begin{itemize}
  \item Land of Lisp -- Conrad Barski
  \item Practical Common Lisp -- Peter Seibel
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Questions?}
  \begin{center}
  CAN HAS QUESTION?
  \end{center}
\end{frame}

\end{document}