Add WIP

presentation.lisp

@@ -0,0 +1,26 @@
+(declaim (ftype (function (number number) number) add))
+(defun add (x y)
+  (declare (number x y))
+  (the number (+ x y)))
+(defun add2 (x y)
+  (+ x y))
+(defclass dog ()
+  ((name :reader name :initarg :name :type string)
+   (age :accessor age :type fixnum :initarg :age)))
+(defgeneric speak (thing))
+(defmethod speak ((rover dog))
+  (dotimes (times (age rover))
+    (format t "~A SPEAK!~%" (name rover))
+    (format t "WOOF!~%")))
+(let ((our-dog
+        (make-instance 'dog :name "Stupid dog!" :age 1)))
+  (speak our-dog)
+  ; Stupid dog! SPEAK!
+  ; WOOF!
+  (incf (age our-dog))
+  (speak our-dog)
+  ; Stupid dog! Speak!
+  ; WOOF!
+  ; Stupid dog! Speak!
+  ; WOOF!
+  )

presentation.tex

@@ -28,6 +28,10 @@
   \tableofcontents
 \end{frame}
 
+\begin{frame}
+  \frametitle{Get it here!}
+  \href{https://gitlab.com/azrazalea/lisp-game-dev-presentation}{https://gitlab.com/azrazalea/lisp-game-dev-presentation}
+\end{frame}
 \section{What is lisp?}
 
 \begin{frame}
@@ -39,20 +43,117 @@
 
 \begin{frame}[fragile]
   \frametitle{An example}
-  \begin{minted}[gobble=4,fontsize=\footnotesize]{cl}
+\begin{minted}[gobble=4,fontsize=\footnotesize]{cl}
     ;; From http://rosettacode.org/wiki/Fibonacci_sequence
     (defun fibonacci-tail-recursive (n &optional (a 0) (b 1))
       (if (= n 0)
         a
         (fibonacci-tail-recursive (- n 1) b (+ a b))))
-  \end{minted}
+\end{minted}
+\end{frame}
+
+\begin{frame}
+  \frametitle{Lisp Implementations}
+  \begin{itemize}
+  \item Common Lisp is an ansi standard.
+  \item There are many implementations of this standard, both commercial and open source.
+  \item The current most popular appear to be \href{http://sbcl.org/}{SBCL} and \href{http://ccl.clozure.com/}{CCL}.
+  \item There are many differences between implementations, but they are generally easy to deal with using libraries built for the purpose.
+  \end{itemize}
+\end{frame}
+
+\begin{frame}
+  \frametitle{Lisp Libraries}
+  \begin{itemize}
+  \item Quicklisp is the library manager for Lisp. \href{https://beta.quicklisp.org}{https://beta.quicklisp.org}.
+  \item While still marked as ``beta'' it is stable and usable. It just lacks some features the author wants to add before considering it released.
+  \item Coolest feature is the ability to install + load libraries completely from the Lisp repl without restarting the process.
+  \end{itemize}
 \end{frame}
 
 \section{Useful Lisp Features}
 
+\begin{frame}[fragile]
+  \frametitle{Compiled and Interpreted (simultaneously)}
+\begin{minted}{lisp}
+ (disassemble (defun add () (+ 2 4)))
+; disassembly for ADD
+; Size: 22 bytes. Origin: #x1003BA0A04
+; 04:       498B4C2460       MOV RCX, [R12+96]                ; thread.binding-stack-pointer
+                                                              ; no-arg-parsing entry point
+; 09:       48894DF8         MOV [RBP-8], RCX
+; 0D:       BA0C000000       MOV EDX, 12
+; 12:       488BE5           MOV RSP, RBP
+; 15:       F8               CLC
+; 16:       5D               POP RBP
+; 17:       C3               RET
+; 18:       CC10             BREAK 16                         ; Invalid argument count trap
+\end{minted}
+\end{frame}
+
 \begin{frame}
-  \frametitle{Dummy}
+  \frametitle{"Gradual Typing"}
+  \begin{itemize}
+  \item Can declare types of arguments and function returns values. Commonly only argument types are declared.
+  \item Type system integrated with Object System, used for generics/method dispatch.
+  \item In SBCL types are verified at compile time in certain cases, some other implementations only verify at run time.
+  \item SBCL will use types to optimize the compiled code, resulting in large performance improvements in some cases.
+  \item Unfortunately compile-time checking is not that advanced, mostly only catches constants/literals.
+  \end{itemize}
+\end{frame}
 
+\begin{frame}[fragile]
+  \frametitle{Types Example}
+\begin{minted}{lisp}
+(declaim (ftype (function
+ (number number)
+ number) add))
+(defun add (x y)
+ (declare (number x y))
+ (the number (+ x y)))
+; NIL
+(add 1 2)
+; 3
+(add "string" 2)
+; The value "string" is not of type NUMBER.
+\end{minted}
 \end{frame}
 
+\begin{frame}
+  \frametitle{Object System}
+  \begin{itemize}
+  \item Classes have slots (``instance variables'')
+  \item Methods are defined in terms of generic functions.
+  \item Uses multiple dispatch instead of single.
+  \item Has multiple inheritance.
+  \item Has cool :before, :after, and :around methods
+  \item Super dynamic, can change class definitions at runtime even when instances already exist.
+  \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Simple CLOS Example}
+\begin{minted}[fontsize=\footnotesize]{lisp}
+(defclass dog ()
+  ((name :reader name :initarg :name :type string)
+   (age :accessor age :type fixnum :initarg :age)))
+(defgeneric speak (thing))
+(defmethod speak ((rover dog))
+  (dotimes (times (age rover))
+    (format t "~A SPEAK!~%" (name rover))
+    (format t "WOOF!~%")))
+(let ((our-dog
+        (make-instance 'dog :name "Stupid dog!" :age 1)))
+  (speak our-dog)
+  ; Stupid dog! SPEAK!
+  ; WOOF!
+  (incf (age our-dog))
+  (speak our-dog)
+  ; Stupid dog! Speak!
+  ; WOOF!
+  ; Stupid dog! Speak!
+  ; WOOF!
+  )
+\end{minted}
+\end{frame}
 \end{document}