\PassOptionsToPackage{unicode=true}{hyperref} % options for packages loaded elsewhere
\PassOptionsToPackage{hyphens}{url}
%
\documentclass[]{article}
\usepackage{lmodern}
\usepackage{amssymb,amsmath}
\usepackage{ifxetex,ifluatex}
\usepackage{fixltx2e} % provides \textsubscript
\ifnum 0\ifxetex 1\fi\ifluatex 1\fi=0 % if pdftex
  \usepackage[T1]{fontenc}
  \usepackage[utf8]{inputenc}
  \usepackage{textcomp} % provides euro and other symbols
\else % if luatex or xelatex
  \usepackage{unicode-math}
  \defaultfontfeatures{Ligatures=TeX,Scale=MatchLowercase}
\fi
% use upquote if available, for straight quotes in verbatim environments
\IfFileExists{upquote.sty}{\usepackage{upquote}}{}
% use microtype if available
\IfFileExists{microtype.sty}{%
\usepackage[]{microtype}
\UseMicrotypeSet[protrusion]{basicmath} % disable protrusion for tt fonts
}{}
\IfFileExists{parskip.sty}{%
\usepackage{parskip}
}{% else
\setlength{\parindent}{0pt}
\setlength{\parskip}{6pt plus 2pt minus 1pt}
}
\usepackage{hyperref}
\hypersetup{
            pdftitle={CSci 658-01: Software Language Engineering Spring 2018 Lecture Notes},
            pdfauthor={H. Conrad Cunningham},
            pdfborder={0 0 0},
            breaklinks=true}
\urlstyle{same}  % don't use monospace font for urls
\setlength{\emergencystretch}{3em}  % prevent overfull lines
\providecommand{\tightlist}{%
  \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}
\setcounter{secnumdepth}{0}
% Redefines (sub)paragraphs to behave more like sections
\ifx\paragraph\undefined\else
\let\oldparagraph\paragraph
\renewcommand{\paragraph}[1]{\oldparagraph{#1}\mbox{}}
\fi
\ifx\subparagraph\undefined\else
\let\oldsubparagraph\subparagraph
\renewcommand{\subparagraph}[1]{\oldsubparagraph{#1}\mbox{}}
\fi

% set default figure placement to htbp
\makeatletter
\def\fps@figure{htbp}
\makeatother

\usepackage{caption}
\DeclareCaptionLabelFormat{nolabel}{}
\captionsetup{labelformat=nolabel}

\title{CSci 658-01: Software Language Engineering\\
Spring 2018 Lecture Notes}
\author{\textbf{H. Conrad Cunningham}}
\date{\textbf{12 February 2018 (after class)}}

\begin{document}
\maketitle

{
\setcounter{tocdepth}{4}
\tableofcontents
}
Copyright (C) 2018, \href{http://www.cs.olemiss.edu/~hcc}{H. Conrad
Cunningham}

Professor of \href{https://www.cs.olemiss.edu}{Computer and Information
Science}\\
\href{http://www.olemiss.edu}{University of Mississippi}\\
211 Weir Hall\\
P.O. Box 1848\\
University, MS 38677\\
(662) 915-5358

I maintain these notes as text in the Pandoc's dialect of Markdown using
embedded LaTeX markup for the mathematical formulas and then translate
the notes to HTML, PDF, and other formats as needed.

\textbf{Advisory}: The HTML version of this document requires use of a
browser that supports the display of MathML. A good choice as of
February 2018 is a recent version of Firefox from Mozilla.

\hypertarget{lecture-notes}{%
\section{Lecture Notes}\label{lecture-notes}}

\protect\hyperlink{current_lecture}{\textbf{Go To Current Lecture}}

\hypertarget{schedule-notes-and-examples}{%
\subsection{Schedule, Notes, and
Examples}\label{schedule-notes-and-examples}}

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\item
  \textbf{(22 Jan) Review syllabus.} Distribute papers to be discussed
  over next two weeks.
\item
  \textbf{(24, 26 Jan) Discuss ``Little Languages'' paper} and related
  issues

  Jon Bentley. \href{localcopy/BentleyLittleLanguages.pdf}{Programming
  Pearls: Little Languages}, \emph{Communications of the ACM}, Vol. 29,
  No.~8, pp.~711-721, August 1986.

  Instructor's note on \texttt{pic}: On my iMac, I installed (using
  Homebrew) the \texttt{groff} package, which includes the GNU
  \texttt{pic} implementation. (I also installed the \texttt{plotutils}
  package to help with display in various formats.)

  Additional references for little language \texttt{pic} (not discussed)

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \tightlist
  \item
    Brian W. Kernighan.
    \href{http://doc.cat-v.org/unix/v8/picmemo.pdf}{PIC -\/- A Graphics
    Language for Typesetting, Revised User Manual}, Computing Science
    Technical Report No.~116, Bell Laboratories, December 1984.
    {[}\href{localcopy/picmemo.pdf}{local}{]}
  \item
    Eric S. Raymond.
    \href{http://floppsie.comp.glam.ac.uk/Glamorgan/gaius/web/pic.html}{Making
    Pictures with GNU PIC}, August 1995.
  \item
    Philipp K. Janert.
    \href{http://www.onlamp.com/pub/a/onlamp/2007/06/21/in-praise-of-pic.html}{In
    Praise of Pic}, \emph{ONLamp.com}, O'Reilly Media, June 2007,
    Retrieved 24 January, 2018.
  \item
    W. Richard Stevens. \href{localcopy/pic_examples.pdf}{Examples of
    \texttt{pic} Macros}, Retrieved from
    \url{http://www.kohala.com/start/} (troff resources, pic), 24
    January 2018. {[}\href{localcopy/pic_examples.txt}{\texttt{pic}
    source}{]}
  \end{enumerate}

  Additional references for little graph language \texttt{dot} and the
  GraphViz package (not discussed)

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \setcounter{enumii}{4}
  \tightlist
  \item
    \href{http://www.graphviz.org/}{GraphViz -\/- Graph Visualization
    Software}, Retrieved 26 January 2018.
  \end{enumerate}

  Additional references for the little languages \texttt{lex},
  \texttt{yacc}, \texttt{make}, and \texttt{chem} (not discussed)

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \setcounter{enumii}{5}
  \tightlist
  \item
    Jon L. Bentley, Lynn W. Jelinski, and Brian W. Kernighan.
    \href{localcopy/chem.pdf}{Chem -- A Program for Phototypesetting
    Chemical Structure Diagrams}, AT\&T Bell Laboratories, Murray Hill,
    NJ 07974, U.S.A.
  \item
    Stuart I. Feldman. \href{localcopy/make.pdf}{Make -- A Program for
    Maintaining Computer Program}, \emph{Software: Practice and
    Experience}, Vol. 9, no. 4 pp.~255-265, 1979.
  \item
    Stephen C. Johnson. \href{localcopy/yacc.pdf}{Yacc: Yet Another
    Compiler-Compiler}, Vol. 32. Murray Hill, NJ: Bell Laboratories,
    1975.
  \item
    Michael E. Lesk and Eric Schmidt. \href{localcopy/lex.pdf}{Lex: A
    Lexical Analyzer Generator}, Bell Laboratories Murray Hill, NJ,
    1975.
  \item
    \href{https://learnxinyminutes.com/docs/make/}{Learn X in Y Minutes,
    Where X = make (GNU)}
  \end{enumerate}
\item
  \textbf{(26, 29 Jan) Discuss ``No Silver Bullet'' paper} and related
  issues

  Frederick P. Brooks. \href{localcopy/NoSilverBullet.pdf}{No Silver
  Bullet: Essence and Accident in Software Engineering}, \emph{IEEE
  Computer}, Vol. 20, No.~4, 10-19, 1987.
\item
  \textbf{(29, 31 Jan) Discuss ``Language-Oriented Programming'' paper}

  M. P. Ward.
  \href{http://www.cse.dmu.ac.uk/~mward/martin/papers/middle-out-t.pdf}{Language-Oriented
  Programming}, \emph{Software--Concepts and Tools,} Vol. 15, No.~4,
  pp.~147-161, 1994.
  {[}\href{localcopy/LanguageOrientedProgramming.pdf}{local}{]}

  Other references from paper (not discussed)

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \tightlist
  \item
    Charles Antony Richard Hoare.
    \href{localcopy/Hoare_Turing_Address.pdf}{The Emperor's Old Clothes}
    (1980 Turing Award Address), \emph{Communications of the ACM}, Vol.
    24, No.~2, 75-83, 1981.
  \end{enumerate}
\item
  \textbf{(31 Jan; 2, 5, 14 Feb) Discuss
  \href{DomainSpecificLanguages.html}{Domain Specific Languages} notes}
  and related issues

  References used in notes (not discussed directly)

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \tightlist
  \item
    Martin Fowler. Using Domain-Specific Languages, Chapter 2,
    \emph{Domain-Specific Languages}, Addison Wesley, 2011.
  \item
    Steve Freeman and Nat Pryce.
    \href{http://www.jmock.org/oopsla2006.pdf}{Evolving an Embedded
    Domain-Specific Language in Java}, In \emph{Proceedings of the ACM
    SIGPLAN International Conference on Object-Oriented Programming,
    Systems, Languages, and Applications (OOPSLA)}, 12 pages, 2006.
    {[}\href{localcopy/EvolvingEmbeddedDSLJava.pdf}{local}{]}
  \item
    Gabor Karsai, Holger Krahn, Claas Pinkernell, Bernhard Rumpe, Martin
    Schindler and Steven Voelkel.
    \href{https://arxiv.org/pdf/1409.2378}{Design Guidelines for Domain
    Specific Languages}, In \emph{Proceedings of OOPSLA Workshop on
    Domain-Specific Modeling}, 2009. Also arXiv preprint
    arXiv:1409.2378, 2014.
    {[}\href{localcopy/Design_Guidelines_DSLs.pdf}{local}{]}
  \item
    M. Mernik, J. Heering, and A. M. Sloane.
    \href{https://pdfs.semanticscholar.org/bd06/01088d5f217dc136a898f577763df92891cb.pdf}{When
    and How to Develop Domain Specific Languages}, \emph{ACM Computing
    Surveys}, 37(4):316-344, December 2005.
    {[}\href{localcopy/WhenDSL.pdf}{local}{]}
  \end{enumerate}
\item
  \textbf{(5, 14 Feb) Discuss Fowler's introductory DSL example}

  Martin Fowler.
  \href{http://www.informit.com/articles/article.aspx?p=1592379}{An
  Introductory Example}, Chapter 1, \emph{Domain-Specific Languages},
  Addison Wesley, 2011.
\item
  \textbf{Survey Design Patterns} (see dates on items)

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    \textbf{(5, 7 Feb)} \href{Patterns/Patterns.html}{Introduction to
    Patterns} {[}\href{Patterns/Intro_Patterns.html}{HTML slides}{]}
  \item
    \textbf{(7 Feb)} \href{Patterns/Pipes.html}{Pipes and Filters
    Architectural Pattern} (Not fully covered, used mainly to illustrate
    approach to pattern definition)
    {[}\href{Patterns/sle_Pipes_Filters_Pattern.ppt}{Powerpoint}{]}
  \item
    \textbf{(9, 12 Feb)} John Vlissides. Designing with Patterns, In
    \emph{Pattern Hatching: Design Patterns Applied}, Addison-Wesley,
    1998. {[}\href{Patterns/sle_Designing_with_Patterns.ppt}{slides}{]}
  \item
    Additional references from instructor's notes (not directly
    disucssed in class)

    \begin{itemize}
    \tightlist
    \item
      \href{Patterns/sle_Factory_Method_Pattern.ppt}{Factory Method
      Design Pattern (Powerpoint)}
    \item
      \href{Patterns/sle_Strategy_Pattern.ppt}{Strategy Design Pattern
      (Powerpoint)}
    \item
      \href{Patterns/sle_Template_Method_Pattern.ppt}{Template Method
      Design Pattern (Powerpoint)}
    \end{itemize}
  \item
    Additional references (mentioned in class, but not discussed in
    depth)

    \begin{itemize}
    \tightlist
    \item
      {[}Siemens book{]} Frank Buschmann, Regine Meunier, Hans Rohnert,
      Peter Sommerlad, and Michael Stal. \emph{Pattern-Oriented Software
      Architecture: A System of Patterns}, Wiley, 1996.
    \item
      {[}``Gang of Four'' (GoF) book{]} Erich Gamma, Richard Helm, Ralph
      Johnson, and John Vlissides. \emph{Design Patterns: Elements of
      Reusable Object-Oriented Software}, Addison Wesley, 1995.
      Patterns*, Wiley, 1996.
    \item
      Mary Shaw.
      \href{http://www.google.com/url?sa=t\&source=web\&ct=res\&cd=9\&ved=0CDMQFjAI\&url=http\%3A\%2F\%2Fciteseerx.ist.psu.edu\%2Fviewdoc\%2Fdownload\%3Fdoi\%3D10.1.1.131.4205\%26rep\%3Drep1\%26type\%3Dpdf\&ei=pA7XS82YIYHMNN_HqPsF\&usg=AFQjCNGBwu48uiRxFJO1pgCIi94jSdu4FA\&sig2=Ut3P0nKWRUwqByT_CFsIZw}{Some
      Patterns for Software Architecture}, In John M. Vlissides, James
      O. Coplien, and Norman L. Kerth, editors, \emph{Pattern Languages
      of Program Design 2}, Addison Wesley, 1996, pages 255-270.
      {[}\href{localcopy/Shaw_Patterns_Arch.pdf}{local}{]}
    \end{itemize}
  \end{enumerate}
\item
  Reference material possibly useful at this point (may discuss
  explicitly later if needed)

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Python 3

    \begin{itemize}
    \tightlist
    \item
      \href{https://learnxinyminutes.com/docs/python3/}{Learn X in Y
      Minutes, Where X = Python3}\\
    \end{itemize}
  \item
    Scala

    \begin{itemize}
    \tightlist
    \item
      \href{https://learnxinyminutes.com/docs/scala/}{Learn X in Y
      Minutes, Where X = Scala}
    \item
      \href{ScalaForJava/ScalaForJava.html}{Notes on Scala for Java
      Programmers}
    \item
      Paul Chiusano and Runar Bjarnason. \emph{Functional Programming in
      Scala}, Manning, 2015.

      \begin{itemize}
      \tightlist
      \item
        Notes on \href{FPS03/FunctionalDS.html}{Functional Data
        Structures (Chapter 3)}
      \item
        Notes on \href{FPS04/ErrorHandling.html}{Error Handling without
        Exceptions (Chapter 4)}
      \item
        Notes on \href{FPS05/Laziness.html}{Strictness and Laziness
        (Chapter 5)}
      \end{itemize}
    \item
      Martin Odersky.
      \href{http://www.scala-lang.org/docu/files/ScalaByExample.pdf}{\emph{Scala
      by Example}}, EPFL, 2014.
      {[}\href{localcopy/ScalaByExample.pdf}{local}{]}
    \item
      Martin Odersky, Lex Spoon, and Bill Venners.
      \href{http://www.artima.com/pins1ed/}{\emph{Programming in
      Scala}}, First Edition, Artima, 2008.
    \end{itemize}
  \item
    Object-oriented software development

    \begin{itemize}
    \tightlist
    \item
      \href{OOSoftDev.html}{Object-Oriented Software Development}
    \item
      \href{ProgrammingParadigms.html}{Programming Paradigms}
      (especially sections on the
      \href{ProgrammingParadigms.html\#object-oriented}{object-oriented}
      and
      \href{ProgrammingParadigms.html\#prototype-based}{prototype-based}
      paradigms)
    \item
      \href{UsingCRC.html}{Using CRC Cards
      (Class-Responsibility-Collaboration)}
    \item
      Kent Beck and Ward Cunningham.
      \href{http://c2.com/doc/oopsla89/paper.html}{A Laboratory for
      Teaching Object-Oriented Thinking}, In \emph{Proceedings of the
      OOPSLA'89 Conference}, ACM, 1989.
    \item
      Paul Gestwicki.
      \href{https://www.youtube.com/watch?v=otKUer13HnA}{CRC Card
      Analysis (YouTube)}, Ball State University, February 2016.
    \end{itemize}
  \item
    \href{Free_Prog_Lang_Textbooks.html}{Free online programming
    language textbooks and tutorials}
  \end{enumerate}
\item
  \textbf{(2, 5, 14 Feb) Discuss State Machine DSLs} based on Martin
  Fowler's Secret Panel Controller (State Machine) DSLs

  \emph{Caveat}: I developed the Scala versions in 2009 by referring to
  an in-work version of Fowler's book on his website, so they may not
  follow his final book precisely. Fowler's code is in Scala, Ruby, C\#,
  etc. I updated the Scala programs in 2018 to make sure they would
  compile under the current Scala.

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Background: Martin Fowler. \emph{Domain Specific Languages}, Addison
    Wesley, 2011.

    \begin{itemize}
    \item
      Fowler introduces the Secret Panel Controller (State Machine) case
      study in Chapter 1
      (\href{http://www.informit.com/articles/article.aspx?p=1592379}{An
      introductory example}) It is an example running through several of
      the 57 chapters of the book.
    \item
      Martin Fowler's \href{http://martinfowler.com/dslCatalog/}{List of
      DSL Patterns} from \emph{Domain Specific Languages}, Addison
      Wesley, 2011
    \end{itemize}

    \emph{Scala versions (2009)}
  \item
    Scala State Machine Semantic Model (Ch. 1, 3, 11)

    \begin{itemize}
    \tightlist
    \item
      \href{StateMachineDSL/Scala/StateMachine.scala}{StateMachine.scala}
    \item
      \href{StateMachineDSL/Scala/StateMachineTest.scala}{StateMachineTest.scala}
    \item
      \href{StateMachineDSL/Scala/CommandChannel.scala}{CommandChannel.scala
      (mock)}
    \item
      \href{StateMachineDSL/Scala/StateMachineDirect.sh}{StateMachineDirect.sh
      test script}
    \end{itemize}
  \item
    Scala XML-based External DSL (Ch. 1, 3, 5)

    \begin{itemize}
    \tightlist
    \item
      \href{StateMachineDSL/Scala/StateMachineXMLTest.scala}{StateMachineXMLTest
      .scala}
    \item
      \href{StateMachineDSL/Scala/IncrementalStateMachineBuilder.scala}{IncrementalStateMachineBuilder.scala}
    \item
      \href{StateMachineDSL/Scala/SecretPanel.xml}{input file
      SecretPanel.xml}
    \item
      \href{StateMachineDSL/Scala/StateMachineXML.sh}{StateMachineXML.sh
      test script}
    \end{itemize}
  \item
    Scala Custom External DSL with a Delimiter-Directed parser (Ch. 1,
    3, 5, 17)

    \begin{itemize}
    \tightlist
    \item
      \href{StateMachineDSL/Scala/DelimiterDSLTest.scala}{DelimiterDSLTest.scala}
    \item
      \href{StateMachineDSL/Scala/IncrementalStateMachineBuilder.scala}{IncrementalStateMachineBuilder.scala}
    \item
      \href{StateMachineDSL/Scala/CustomExternalStateMachineDSL.dsl}{input
      file CustomExternalStateMachineDSL.dsl}\\
    \item
      \href{StateMachineDSL/Scala/DelimiterDSL.sh}{DelimiterDSL.sh test
      script}
    \end{itemize}
  \item
    Scala Custom External DSL with hand-coded Ad Hoc Recursive-Descent
    parser (Ch. 1, 3, 5, 21)

    \begin{itemize}
    \tightlist
    \item
      \href{StateMachine/Scala/RecursiveDescemt.sh}{RecursiveDescent.scala}
    \item
      \href{StateMachineDSL/Scala/IncrementalStateMachineBuilder.scala}{IncrementalStateMachineBuilder.scala}
    \item
      \href{StateMachineDSL/Scala/CustomExternalStateMachineDSL2.dsl}{input
      file CustomExternalStateMachineDSL2.dsl}
    \item
      \href{StateMachineDSL/Scala/RecursiveDescent.sh}{RecursiveDescent.sh
      test script}
    \end{itemize}
  \item
    Scala Custom External DSL (using Scala parser combinator library)
    with embedded state machine builder (Ch. 1, 3, 5, 22)

    \begin{itemize}
    \tightlist
    \item
      \href{StateMachineDSL/Scala/CombinatorParserBuilderTest.scala}{CombinatorParserBuilderTest.scala}
    \item
      \href{StateMachineDSL/Scala/IncrementalStateMachineBuilder.scala}{IncrementalStateMachineBuilder.scala}
    \item
      \href{StateMachineDSL/Scala/CustomExternalStateMachineDSL2.dsl}{input
      file CustomExternalStateMachineDSL2.dsl}
    \item
      \href{StateMachineDSL/Scala/CombinatorParserBuilder.sh}{CombinatorParserBuilder.sh
      test script}
    \end{itemize}
  \item
    Scala Custom External DSL (using Scala parser combinator library)
    with full AST construction (Ch. 1, 3, 5, 22)

    \begin{itemize}
    \tightlist
    \item
      \href{StateMachineDSL/Scala/CombinatorParserASTTest.scala}{CombinatorParserASTTest.scala}
    \item
      \href{StateMachineDSL/Scala/CustomExternalStateMachineDSL2.dsl}{input
      file CustomExternalStateMachineDSL2.dsl}
    \item
      \href{StateMachineDSL/Scala/CombinatorParserAST.sh}{CombinatorParserAST.sh
      test script}
    \end{itemize}
  \item
    Scala Static C Code Generator with Model-Aware target platform
    library (Ch. 1, 3, 5, 8, 52, 55)

    \begin{itemize}
    \tightlist
    \item
      \href{StateMachineDSL/Scala/StaticC_GeneratorTest.scala}{StaticC\_GeneratorTest.scala}
    \item
      \href{StateMachineDSL/Scala/output.c}{generated C output file
      output.c}
    \item
      \href{StateMachineDSL/Scala/StaticC_Generator.sh}{StaticC\_Generator.sh
      test script}
    \item
      Note: The needed framework code needed to run the generated C
      program is not yet available in this form. It needs to be
      reconstructed from Fowler's book.
    \end{itemize}
  \end{enumerate}
\item
  \textbf{(5, 14 Feb) Discuss Fowler's Computer Configuration Internal
  DSLs} (Ch. 4, 35, 36, 38)

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Background: Martin Fowler. \emph{Domain Specific Languages},
    (Addison Wesley, 2011).

    \emph{Scala versions (2009)}
  \item
    \href{CompConfigDSL/Scala/Computer.scala}{Scala semantic model
    (shared)}
  \item
    \href{CompConfigDSL/Scala/CompConfigChaining.scala}{Scala internal
    DSL using Method Chaining}
  \item
    \href{CompConfigDSL/Scala/CompConfigClosure.scala}{Scala internal
    DSL using Nested Closures and Object Scoping}
  \item
    \href{CompConfigDSL/Scala/CompConfig.sh}{CompConfig.sh test script}
  \end{enumerate}
\item
  (TBD) Discuss Fowler's Email Message Building Internal DSL (Ch. 35)

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Background: Martin Fowler. \emph{Domain Specific Languages},
    (Addison Wesley, 2011).

    \emph{Scala versions (2009)}
  \item
    \href{EmailDSL/Scala/EmailProgressive.scala}{Scala internal DSL
    using Method Chaining and Progressive Interfaces}
  \item
    \href{EmailDSL/Scala/EmailProgressive.sh}{EmailProgressive.sh test
    script}
  \end{enumerate}
\item
  \textbf{(assigned, not discussed yet, TBD) Discuss Coplien's SCV
  paper}

  James Coplien, Daniel Hoffman, and David Weiss.
  \href{localcopy/CoplienCommonalityVariability.pdf}{Commonality and
  Variability in Software Engineering}, \emph{IEEE Software}, Vol. 15,
  No.~6, November 1998.
\end{enumerate}

\hypertarget{materials-under-phase-2-reconstruction}{%
\subsection{Materials under Phase 2
Reconstruction}\label{materials-under-phase-2-reconstruction}}

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\setcounter{enumi}{100}
\item
  (TBD) \href{slides/DomainModeling.ppt}{Domain Modeling slides}, for
  course registration system example.
\item
  (TBD) Mark Ardis, Nigel Daley, Daniel Hoffman, Harvey Siy, and David
  Weiss.
  \href{https://pdfs.semanticscholar.org/75bf/823305d898014d50ec4b47ed1d6cf42a17bf.pdf}{Software
  Product Lines: A Case Study}, \emph{Software Practice and Experience},
  Vol. 30, No.~7, pp.~825-847, 2000.
\item
  (TBD) S. Thibault, R. Marlet, and C. Consel.
  \href{localcopy/DSLDesignImpleVideo.pdf}{Domain-Specific Languages:
  From Design to Implementation--Application to Video Device Drivers
  Generation}. \emph{IEEE Transactions on Software Engineering},
  25(3):363--377, May/June 1999.
\item
  (TBD) Ralph E. Johnson and Brian Foote.
  \href{http://www.laputan.org/drc/drc.html}{Designing Reusable
  Classes}, \emph{Journal of Object-Oriented Programming}, Vol. 1,
  No.~2, pages 22-35, June/July 1988.
\item
  (TBD) Develop a Survey DSL

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Background: H. Conrad Cunningham. A Little Language for Surveys:
    Constructing an Internal DSL in Ruby, In \emph{Proceedings of the
    ACM SouthEast Conference}, 6 pages, March 2008.

    \begin{itemize}
    \tightlist
    \item
      \href{localcopy/surveyLangFinal.pdf}{manuscript}
    \item
      \href{SurveyDSL/Ruby/surveyLanguage4.ppt}{presentation}
    \end{itemize}
  \item
    Ruby source code (2006, 2008)

    \begin{itemize}
    \tightlist
    \item
      \href{SurveyDSL/Ruby/SurveyLanguage_rb.txt}{Ruby source code
      SurveyLanguage.rb}
    \item
      \href{SurveyDSL/Ruby/survey_rb.txt}{test DSL input file}
    \item
      \href{SurveyDSL/Ruby/surveyErrors_rb.txt}{test DSL input file with
      errors}
    \end{itemize}
  \end{enumerate}
\item
  (reference material on Lua, from Fall 2016 CSci 450 notes)

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Reference: Roberto Ierusalimshcy. \emph{Programming in Lua}, Fourth
    Edition, Lua.org, Rio de Janiero, Brazil, 2016. The
    \href{https://www.lua.org/pil/contents.html}{First Edition} of this
    book is available online at
    \url{https://www.lua.org/pil/contents.html}; it covers Lua 5.0.
  \item
    Background: The slides below are adapted, in part, from
    \href{http://www.dcc.ufrj.br/~fabiom/lua/}{\emph{Programming in Lua,
    Slides for Course}} by Fabio Mascarenhas from the Federal University
    of Rio de Janeiro, Brazil. He taught a course, which used Lua 5.2,
    at Nankai University, P. R. China, in July 2013.
  \item
    \href{LuaIntro/01IntroLua.html}{Introduction to Lua} slides based,
    in part, on Mascarenhas slide sets 0-5
  \item
    \href{LuaIntro/02IntroLua.html}{Advanced Lua Functions} slides
    based, in part, on Mascarenhas slide set 6
  \item
    \href{LuaIntro/03IntroLua.html}{Modules in Lua} slides based, in
    part, on Mascarenhas slide set 9
  \item
    \href{LuaIntro/04IntroLua.html}{Lua Metatables} slides based, in
    part, on Mascarenhas slide set 10
  \item
    \href{LuaIntro/05IntroLua.html}{Lua Objects} slides based, in part,
    on Mascarenhas slide set 11
  \end{enumerate}
\item
  (TBD) Discuss Fowler's Lair Configuration DSL

  \emph{Caveat}: Some of these DSL programs may depend upon features
  from Lua 5.1 that were changed in Lua 5.2 and 5.3.

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Background:

    \begin{itemize}
    \tightlist
    \item
      Case study: Martin Fowler's
      \href{http://media.pragprog.com/titles/twa/martin_fowler.pdf}{One
      Lair and Twenty Ruby DSLs}, Chapter 3,
      \href{http://pragprog.com/book/twa/thoughtworks-anthology}{\emph{The
      ThoughtWorks Anthology: Essays on Software Technology and
      Innovation}}, The Pragmatic Bookshelf, 2008
      \href{LairDSL/FowlerOneLairTwentyDSLs.pdf}{{[}local chapter}{]}
    \item
      Patterns (repeated from above): Martin Fowler's
      \href{http://martinfowler.com/dslCatalog/}{List of DSL Patterns}
      from \emph{Domain Specific Languages}, Addison Wesley, 2011
    \item
      Source code:
      {[}\href{https://pragprog.com/titles/twa/source_code}{entire
      book}{]} {[}\href{LairDSL/FowlerRubyCode}{Fowler's Ruby DSLs}{]}
    \end{itemize}

    \emph{Lua versions (2013)}
  \item
    Lua shared modules

    \begin{itemize}
    \tightlist
    \item
      \href{LairDSL/Lua/class_support.lua}{Class support module (for
      implementing classes in Lua)}
    \item
      \href{LairDSL/Lua/model.lua}{Semantic model}
    \item
      \href{LairDSL/Lua/rules00.lua}{Test driver for semantic model
      (rules00.lus)}
    \end{itemize}
  \item
    Lua internal DSLs

    \begin{itemize}
    \item
      Using Global Function Sequence pattern\\
      \href{LairDSL/Lua/builder08.lua}{builder module (builder08.lua)}
      -- \href{\%3CLairDSL/Lua/rules08.lua}{dsl script (rules08.lua)} --
      \href{\%3CLairDSL/Lua/test08.lua}{test driver (test08.lua)}
    \item
      Using Class Method Function Sequence and Method Chaining
      patterns\\
      \href{LairDSL/Lua/builder11.lua}{builder module (builder11.lua)}
      -- \href{LairDSL/Lua/test11.lua}{dsl script (rules11.lua)}
    \item
      Using Expression Builder and Method Chaining patterns\\
      \href{LairDSL/Lua/builder14.lua}{builder module (builder14.lua)}
      -- \href{LairDSL/Lua/rules14.lua}{dsl script (rules14.lua)} --
      \href{LairDSL/Lua/test14.lua}{test driver (test14.lua)}
    \item
      Using Nested Closures pattern\\
      \href{LairDSL/Lua/builder03.lua}{builder module (builder03.lua)}
      -- \href{LairDSL/Lua/rules03.lua}{dsl script (rules03.lua)} --
      \href{LairDSL/Lua/test03.lua}{test driver (test03.lua)}
    \item
      Using Expression Builder, Object Scoping, and Method Chaining
      patterns\\
      \href{LairDSL/Lua/builder17.lua}{builder module (builder17.lua)}
      -- \href{LairDSL/Lua/rules17.lua}{dsl script (rules17.lua)} --
      \href{LairDSL/Lua/test17.lua}{test driver (test17.lua)}
    \item
      Using Literal Collection pattern\\
      \href{LairDSL/Lua/builder22.lua}{builder module (builder22.lua)}
      -- \href{LairDSL/Lua/rules22.lua}{dsl script (rules22.lua)} --
      \href{LairDSL/Lua/test22.lua}{test driver (test22.lua)}
    \end{itemize}
  \item
    Lua external DSLs

    \begin{itemize}
    \tightlist
    \item
      Using LPEG Parser/Builder (no corresponding example in Fowler
      paper)\\
      \href{LairDSL/Lua/builderLPEG1.lua}{builder module
      (builderLPEG1.lua)} -- \href{LairDSL/Lua/rulesLPEG1.dsl}{dsl
      script (rulesLPEG1.dsl)} -- \href{LairDSL/Lua/testLPEG1.lua}{test
      driver (testLPEG1.lua)}
    \end{itemize}
  \end{enumerate}
\item
  (TBD) Discuss Fowler's DSL Reader framework

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Background:

    \begin{itemize}
    \tightlist
    \item
      Martin Fowler.
      \href{http://www.martinfowler.com/articles/languageWorkbench.html}{Language
      Workbenches: The Killer-App for Domain Specific Languages?} June
      2005.
    \item
      Martin Fowler.
      \href{http://www.martinfowler.com/articles/codeGenDsl.html}{Generating
      Code for DSLs,}, June 2005.
    \end{itemize}

    \emph{Ruby DSLs (2006)}
  \item
    Ruby shared modules

    \begin{itemize}
    \tightlist
    \item
      \href{ReaderDSL/Ruby/ReaderFramework.rb}{DSL Reader Framework
      module}
    \item
      \href{ReaderDSL/Ruby/ReaderUtilities.rb}{DSL Reader Utilities
      mix-in module}
    \item
      \href{ReaderDSL/Ruby/fowlerdata.txt}{Data input file}
    \item
      \href{ReaderDSL/Ruby/dslinput.txt}{Text DSL description}
    \item
      \href{ReaderDSL/Ruby/dslinput.rb}{XML DSL description}
    \end{itemize}
  \item
    Ruby direct configuration and testing of Reader

    \begin{itemize}
    \tightlist
    \item
      \href{ReaderDSL/Ruby/BuilderDirect.rb}{BuilderDirect.rb}
    \end{itemize}
  \item
    Ruby single-pass external text DSL

    \begin{itemize}
    \tightlist
    \item
      \href{ReaderDSL/Ruby/TextSinglePass.rb}{TextSinglePass.rb}
    \end{itemize}
  \item
    Ruby two-pass external XML DSL

    \begin{itemize}
    \tightlist
    \item
      \href{ReaderDSL/Ruby/TwoPass.rb}{TwoPass.rb}
    \item
      \href{ReaderDSL/Ruby/GeneratedBuilderExternal.rb}{class
      BuilderExternal source code generated by TwoPass.rb}
    \end{itemize}
  \item
    Ruby internal DSL

    \begin{itemize}
    \tightlist
    \item
      \href{ReaderDSL/Ruby/RubyDSL.rb}{RubyDSL.rb}
    \end{itemize}
  \end{enumerate}
\item
  (TBD) Sandwich DSL Case Study

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    \href{SandwichDSL/Haskell/SandwichDSL.html}{Haskell version (2017)}
  \item
    \href{SandwichDSL/Scala/SandwichDSL.html}{Scala version (2016)}
  \item
    Lua version (simpler, 2013)

    \begin{itemize}
    \tightlist
    \item
      \href{SandwichDSL/Lua/sandwich_model.lua}{Semantic model module}
    \item
      \href{SandwichDSL/Lua/sandwich_builder.lua}{DSL builder module
      using function sequence pattern}
    \item
      \href{SandwichDSL/Lua/test_sandwichDSL.lua}{Test driver}
    \end{itemize}
  \end{enumerate}
\item
  (TBD) Abstract data types and modular design

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Background: Abstract data types

    \begin{itemize}
    \item
      Nell Dale and Henry Walker. Abstract specification techniques,
      Chapter 1, In \emph{Abstract Data Types: Specifications,
      Implementations, and Applications}, pp.~1-34,D. C. Heath, 1996.
    \item
      H. Conrad Cunningham, Yi Liu, and Jingyi Wang. Designing a
      flexible framework for a table abstraction, Chapter 13 in Y. Chan,
      J. Talburt, and T. Talley, editors, \emph{Data Engineering:
      Mining, Information, and Intelligence}, pp.~279-314, Springer,
      2010.\\
      {[}\href{localcopy/Cunningham_Table_Abstraction.pdf}{manuscript}{]}
      {[}\href{slides/TableFramework8.ppt}{slides}{]}
    \end{itemize}
  \item
    \href{ModularDesign.html}{Modular Design}
  \item
    \href{DataAbstraction.html}{Data Abstraction}:
    {[}\href{slides/Data_Abstraction_rev2.ppt}{slides}{]}
  \item
    (OO reference materia, repeated from abovel)
    \href{OOSoftDev.html}{Object-Oriented Software Development}
  \item
    (Programming paradigms reference material, repeated from above)
    \href{ProgrammingParadigms.html}{Programming Paradigms}
  \item
    William R. Cook.
    \href{http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf}{On
    understanding data abstraction revisited}. In \emph{Proceedings of
    OOPSLA}, October 2009.\\
    {[}\href{localcopy/Understanding_Data_Abstraction_Revisited.pdf}{local}{]}
  \item
    K. H. Britton, R. A. Parker, and D. L. Parnas.
    \href{localcopy/Parnas_Abstract_Interfaces.pdf}{A procedure for
    designing abstract interfaces for device interface modules}, In
    \emph{Proceedings of the 5th International Conference on Software
    Engineering}, pp.~195-204, March 1981.
  \item
    D. L. Parnas. \href{localcopy/Parnas_Criteria_Decomposing.pdf}{On
    the criteria to be used in decomposing systems into modules},
    \emph{Communications of the ACM}, Vol. 15, No.~12, pp.~1053-1058,
    1972.
  \item
    D. L. Parnas. \href{localcopy/Parnas_Families.pdf}{On the design and
    development of program families}, \emph{IEEE Transactions on
    Software Engineering}, Vol. SE-2, No.~1, pp.~1-9, March 1976.
  \item
    D. L. Parnas.
    \href{localcopy/Parnas_Extension_Contraction.pdf}{Designing software
    for ease of extension and contraction}, \emph{IEEE Transactions on
    Software Engineering}, Vol. SE-5, No.~1, pp.~128-138, March 1979.
  \item
    D. L. Parnas, P. C. Clements, and D. M. Weiss.
    \href{localcopy/Parnas_Modular_Structure.pdf}{The modular structure
    of complex systems}, \emph{IEEE Transactions on Software
    Engineering}, Vol. SE-11, No.~3, pp.~259-266, March 1985.
  \end{enumerate}
\end{enumerate}

\hypertarget{materials-under-phase-1-reconstruction}{%
\subsection{Materials under Phase 1
Reconstruction}\label{materials-under-phase-1-reconstruction}}

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\setcounter{enumi}{200}
\item
  (TBD) Examine the CookieJar ADT case study (in Scala)

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    \href{CookieJar/Scala/CookieJar_problem.html}{Cookie Jar ADT Problem
    Description}
  \item
    \href{CandyBowl/Lua/candybowl_semantics.html\#specifying-semantics}{Specification
    concepts and notation} -- from Candy Bowl ADT description
  \item
    Immutable CookieJar ADT Implementation in Scala
    (\texttt{ICookieJar}) -- uses method chaining functional style with
    immutable objects

    \begin{itemize}
    \tightlist
    \item
      \href{CookieJar/Scala/immutable/ICookieJar.scala}{ADT
      specification as Scala trait}
    \item
      \href{CookieJar/Scala/immutable/ICookieJarList.scala}{List
      version}
    \item
      \href{CookieJar/Scala/immutable/ICookieJarMap.scala}{HashMap
      version}
    \item
      \href{CookieJar/Scala/immutable/ICookieJarTupleList.scala}{List of
      tuples version}
    \item
      \href{CookieJar/Scala/immutable/ICookieJarTest.scala}{Blackbox
      test script}
    \end{itemize}
  \item
    Mutable CookieJar ADT Implementation in Scala (\texttt{CookieJar})
    -- uses object-oriented style with mutable state

    \begin{itemize}
    \tightlist
    \item
      \href{CookieJar/Scala/mutable/CookieJar.scala}{ADT specification
      as Scala trait}
    \item
      {[}List version
      \href{CookieJar/Scala/mutable/CookieJarArrayBuffer.scala}{ArrayBuffer
      version}
    \item
      \href{CookieJar/Scala/mutable/CookieJarMap.scala}{HashMap version}
    \item
      \href{CookieJar/Scala/mutable/CookieJarTupleList.scala}{List of
      tuples version}
    \item
      \href{CookieJar/Scala/mutable/CookieJarArray.scala}{Array version}
    \item
      \href{CookieJar/Scala/mutable/CookieJarTest.scala}{Blackbox test
      script}
    \end{itemize}
  \item
    \href{CookieJar/Ruby/CookieJarRuby.txt}{Similar specification and
    Ruby program}
  \end{enumerate}
\item
  (TBD) Examine Carrie's Candy Bowl ADT (abstract data type) case study

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Lua

    \begin{itemize}
    \tightlist
    \item
      \href{CandyBowl/Lua/candybowl_semantics.html}{ADT Semantics}
    \item
      \href{CandyBowl/Lua/candybowl_hash.lua}{Hashed version}
    \item
      \href{CandyBowl/Lua/candybowl_list.lua}{Unsorted List version}
    \item
      \href{CandyBowl/Lua/test_candybowl.lua}{Test driver}
    \end{itemize}
  \item
    Scala

    \begin{itemize}
    \tightlist
    \item
      \href{CandyBowl/Scala/CandyBowl.scala}{CandyBowl trait}
    \item
      \href{CandyBowl/Scala/CandyBowlList.scala}{CandyBowlList class}
    \end{itemize}
  \end{enumerate}
\item
  (TBD) Examine the Labeled Digraph case study

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Background:

    \begin{itemize}
    \item
      Nell Dale and Henry Walker. ``Directed Graphs or Digraphs,''
      Chapter 10, In \emph{Abstract Data Types: Specifications,
      Implementations, and Applications}, pp.~439-469, D. C. Heath,
      1996.
    \item
      Conrad Barski. ``Building a Text Game Engine,'', Chapter 5, In
      \emph{Land of Lisp: Learn to Program in Lisp, One Game at a Time},
      pp.~69-84, No Starch Press, 2011.

      The Common Lisp example in this chapter is similar to the classic
      Adventure game; the underlying data structure is a labeled
      digraph.
    \end{itemize}
  \item
    Haskell solutions (2015)

    \begin{itemize}
    \tightlist
    \item
      \href{Digraph/Haskell/DigraphADT.html}{Labelled Digraph Abstract
      Data Type}
    \item
      List representation for vertices and edges:
      {[}\href{Digraph/Haskell/DigraphADT_List.hs}{module}{]}
      {[}\href{Digraph/Haskell/DigraphADT_TestList.hs}{test module}{]}
    \item
      Map representation for graph:
      {[}\href{Digraph/Haskell/DigraphADT_Map.hs}{module}{]}
      {[}\href{Digraph/Haskell/DigraphADT_TestMap.hs}{test module}{]}
    \end{itemize}
  \item
    Elixir solutions (2015)

    \begin{itemize}
    \tightlist
    \item
      Tuple and list representation for graph:
      {[}\href{Digraph/Elixir/Digraph_List.ex}{module}{]}
      {[}\href{Digraph/Elixir/Digraph_Test.exs}{test module}{]}
    \end{itemize}
  \item
    Scala solutions (2016)

    \begin{itemize}
    \tightlist
    \item
      Abstract data type specification and Scala trait (interface):
      {[}\href{Digraph/Scala/Digraph.scala}{ADT interface}{]}
    \item
      List representation for vertices and edges:
      {[}\href{Digraph/Scala/DigraphList.scala}{class source}{]}
      {[}\href{Digraph/Scala/Test_DigraphList.scala}{test source}{]}
    \item
      Map (HashMap) representation for graph:
      {[}\href{Digraph/Scala/DigraphMap.scala}{class source}{]}
      {[}\href{Digraph/Scala/Test_DigraphMap.scala}{test source}{]}
    \end{itemize}
  \item
    Using the Elixir Digraph ADT module to build the Wizard's Adventure
    game (2015)

    \begin{itemize}
    \item
      \href{Wizard/Elixir/wizards_game.ex}{Wizard's Adventure game,
      Version 1,} adapted from Chapter 5, 6, and 17 of Conrad Barski's
      \emph{Land of Lisp: Learn to Program in Lisp, One Game at a Time},
      No Starch Press, 2011.
    \item
      \href{Wizard/Elixir/wizards_game2a.ex}{Wizard's Adventure game,
      Version 2,} that uses a higher order function to generate game
      actions and improved handling of the game state.
    \end{itemize}
  \end{enumerate}
\item
  (TBD) Parsing Expression Grammars

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Wikipedia entry on
    \href{http://en.wikipedia.org/wiki/Parsing_expression_grammar}{Parsing
    Expression Grammar}
  \item
    Bryan Ford. Parsing Expression Grammars: A recognition-based
    syntactic foundation.\\
    {[}\href{http://www.brynosaurus.com/pub/lang/peg-slides.pdf}{slides}{]}
  \end{enumerate}
\item
  (TBD) Doug Rosenberg with Kendall Scott. ``Domain Modeling,'' Chapter
  2 in \emph{Use Case Driven Object Modeling with UML}, Addison Wesley
  1999.
\item
  (TBD) Doug Rosenberg with Kendall Scott. ``Use Case Modeling,''
  Chapter 3 in \emph{Use Case Driven Object Modeling with UML}, Addison
  Wesley 1999.
\item
  (TBD) Reference: Alistair Cockburn. ``Introduction,'' Chapter 1 in
  \emph{Writing Effective Use Cases}, Addison-Wesley, 2001.
\item
  (TBD) Understanding Inheritance, based on Timothy Budd's
  \emph{Understanding Object-Oriented Programming with Java}, Chapter
  8:\\
  {[}\href{sd_08_Inheritance.ppt}{slides}{]}
\item
  (TBD) Simple, silly Employee hierarchy example

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    \href{Employee/Scala/EmployeeTest.scala}{Scala (2008, 2010)}
  \item
    \href{Employee/Ruby/employee.rb}{Ruby (2006)}
  \end{enumerate}
\item
  (TBD) Examine a natural number arithmetic package

  This case study has implementations in four different languages (with
  some slight differences among the examples). So it can be used to
  compare implementations in different languages.

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Background on Peano arithmetic

    \begin{itemize}
    \tightlist
    \item
      \href{http://en.wikipedia.org/wiki/Peano_axioms}{Peano Axioms},
      Wikipedia article
    \item
      \href{http://mathworld.wolfram.com/PeanosAxioms.html}{Peano's
      Axioms}, Wolfram MathWorld article
    \end{itemize}
  \item
    Background on software design patterns

    \begin{itemize}
    \tightlist
    \item
      \href{https://sourcemaking.com/design_patterns}{Source Making}
      website
    \end{itemize}
  \item
    \href{Nat/Lua/nats2.lua}{Lua version (2013)}
  \item
    Elixir version (2015)

    \begin{itemize}
    \tightlist
    \item
      \href{Nat/Elixir/Nat.ex}{Nat module}
    \item
      \href{Nat/Elixir/Nat_Test.ex}{test module}
    \item
      \href{Nat/Elixir/Nat.exs}{test script}
    \end{itemize}
  \item
    Scala versions (2012, 2016)

    \begin{itemize}
    \tightlist
    \item
      \href{Nat/Scala/TestNats.scala}{Functional object-oriented style
      with ordinary classes}
    \item
      \href{Nat/Scala/TestCaseObjNats.scala}{Functional object-oriented
      style with case classes}
    \item
      \href{Nat/Scala/TestCaseExtNats.scala}{Functional module style
      with case classes}
    \end{itemize}
  \item
    \href{Nat/Ruby/Nat.txt}{Ruby version (2006)}
  \item
    Java version (2004, 2016), simpler, no generics

    \begin{itemize}
    \tightlist
    \item
      \href{Nat/Java/Nat.txt}{abstract base class Nat}
    \item
      \href{Nat/Java/Zero.txt}{subclass Zero}
    \item
      \href{Nat/Java/Succ.txt}{subclass Succ}
    \item
      \href{Nat/Java/Err.txt}{subclass Err}
    \item
      \href{Nat/Java/TestNat.txt}{TestNat main program}
    \end{itemize}
  \end{enumerate}
\item
  (TBD) Software Reuse, based on Timothy Budd's \emph{Understanding
  Object-Oriented Programming with Java}, Chapter 10:\\
  {]}\href{sd_10_Software_Reuse.ppt}{slides}{]}\\

  \begin{itemize}
  \tightlist
  \item
    \href{Frog/Scala/FrogTest.scala}{Scala translation of Frog dynamic
    composition example}
  \end{itemize}
\item
  (TBD) Replacement and Refinement, loosely based on Timothy Budd's
  \emph{An Introduction to Object-Oriented Programming}, Third Edition,
  Section 16.2:\\
  {[}\href{slides/sd_Replace_Refine.ppt}{slides}{]}
\item
  (TBD) Implications of Inheritance, based on Timothy Budd's
  \emph{Understanding Object-Oriented Programming with Java}, Chapter
  11:\\
  {[}\href{slides/sd_11Implication_Inheritance.ppt}{slides}{]}\\
\item
  (TBD) Multiple Inheritance, based on Timothy Budd's \emph{An
  Introduction to Object-Oriented Programming}, Third Edition, Chapter
  13:\\
  {[}\href{slides/sd_11Multiple_Inheritance.ppt}{slides}{]}\\

  \begin{itemize}
  \item
    {[}Scala Modified Philosophical Frog example from Odersky et a
    {[}\href{PhilFrog/Scala/PhilFrog.scala}{source}{]}
  \item
    Scala Modified Stackable traits example (IntQueue) from Odersky et
    al: {[}\href{Stackable/Scala/StackableTest.scala}{source}{]}
  \end{itemize}
\item
  (TBD) Polymorphism, based on Timothy Budd's \emph{Understanding
  Object-Oriented Programming with Java}, Chapter 12:\\
  {[}\href{slides/sd_12Polymorphism.ppt}{slides}{]}\\
\item
  (TBD) Second Look at Classes, loosely based on Timothy Budd's \emph{An
  Introduction to Object-Oriented Programming}, Chapter 25 on Reflection
  and Introspection:\\
  {[}\href{slides/sd_Second_Look_at_Classes.ppt}{slides}{]}
\item
  (TBD) Frameworks, based on Timothy Budd's \emph{An Introduction to
  Object-Oriented Programming}, Third Edition, Chapter 21.

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Simple Sorting Framework in Scala

    \begin{itemize}
    \tightlist
    \item
      \href{SortFramework/Scala/SortEmployee.scala}{Low-level concrete
      Employee sorting}
    \item
      \href{SortFramework/Scala/InsertionSorter.scala}{Insertion Sorting
      framework}
    \item
      \href{SortFramework/Scala/EmployeeSorter.scala}{Employee Sorting
      application of framework}
    \item
      \href{SortFramework/Scala/TestEmployeeSorter.scala}{Test code for
      Employee Sorting application of framework}
    \end{itemize}
  \item
    Ice Cream Store discrete event simulation

    \begin{itemize}
    \tightlist
    \item
      \href{IceCreamStore/Scala/SimFramework.scala}{Simulation
      framework}
    \item
      \href{IceCreamStore/Scala/IceCreamStoreApp.scala}{Ice Cream Store
      application}
    \end{itemize}
  \end{enumerate}
\item
  (TBD) Scala Divide-and-Conquer Framework, similar to the Java
  framework in the paper:

  H. C. Cunningham, Y. Liu, and C. Zhang. Using classic problems to
  teach Java framework design, \emph{Science of Computer Programming},
  Special Issue on Principles and Practice of Programming in Java (PPPJ
  2004), Vol. 59, No.~1-2, pp.~147-169, January 2006. doi:
  10.10.16/j.scico.2005.07.009.
  {[}\href{http://www.cs.olemiss.edu/~hcc/papers/classicProblems.pdf}{manuscript}{]}

  Note: The above paper was not discussed in class, but the Scala
  versions of the Divide-and-Conquer (immediately below) and Binary Tree
  Traversal (farther down on this page) frameworks were discussed.

  \begin{itemize}
  \tightlist
  \item
    \href{DivConq/Scala/DivConqTemplate.scala}{Template-based
    Divide-and-Conquer Framework (DivConqTemplate)}
  \item
    \href{DivConq/Scala/DivConqStrategy.scala}{Strategy-based
    Divide-and-Conquer Framework (DivConqStrategy)}
  \item
    \href{DivConq/Scala/DivConqProblemSolution.scala}{Traits for Problem
    and Solution descriptions for both frameworks
    (DivConqProblemSolution)}
  \item
    \href{DivConq/Scala/QuickSortTemplateApp.scala}{Application of
    Template-based framework to QuickSort (QuickSortTemplateApp)}
  \item
    \href{DivConq/Scala/QuickSortStrategyApp.scala}{Application of
    Strategy-based framework to QuickSort (QuickSortStrategyApp)}
  \item
    \href{DivConq/Scala/QuickSortDesc.scala}{Descriptor for QuickSort
    state for both QuickSort applications (QuickSortDesc)}
  \end{itemize}
\item
  (TBD) Introduction to Design Patterns, Chapter 6 in, Eric Braude,
  \emph{Software Design: From Programming to Architecture}, Wiley, 2004.
\item
  (TBD) {[}Siemens book{]} Frank Buschmann, Regine Meunier, Hans
  Rohnert, Peter Sommerlad, and Michael Stal. \emph{Pattern-Oriented
  Software Architecture: A System of Patterns}, Wiley, 1996.
\item
  (TBD) (``Gang of Four'' (GoF) book) Erich Gamma, Richard Helm, Ralph
  Johnson, and John Vlissides. \emph{Design Patterns: Elements of
  Reusable Object-Oriented Software}, Addison Wesley, 1995.
\item
  (TBD) Mark Grand. \emph{Patterns in Java: A Catalog of Reusable Design
  Patterns Illustrated with UML}, Volume 1, Wiley, 1998.

  \begin{itemize}
  \item
    Template Method Design Pattern:
    {[}\href{slides/sd_Template_method_pattern.ppt}{slides}{]}\\
    Reference: Gof, ``Template Method,'' pp.~325-329.\\
    Reference: Grand, ``Template Method,'' pp.~377-384.
  \item
    Strategy Design Pattern:
    {[}\href{slides/sd_Strategy_pattern.ppt}{slides}{]}\\
    Reference: GoF, ``Strategy,'' pp.~315-323.\\
    Reference: Grand, ``Strategy,'' pp.~371-376.
  \item
    Factory Method Design Pattern:
    {[}\href{slides/sd_Factory_method_pattern.ppt}{slides}{]}\\
    Reference: GoF, ``Factory Method,'' pp.~107-116.~
  \end{itemize}
\item
  (TBD) Binary Tree Visitor Scala Framework

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Background: H. C. Cunningham, Y. Liu, and C. Zhang. Using classic
    problems to teach Java framework design, \emph{Science of Computer
    Programming}, Special Issue on Principles and Practice of
    Programming in Java (PPPJ 2004), Vol. 59, No.~1-2, pp.~147-169,
    January 2006. doi: 10.10.16/j.scico.2005.07.009.\\
    {[}\href{http://www.cs.olemiss.edu/~hcc/papers/classicProblems.pdf}{manuscript}{]}
  \item
    Additional pattern references

    \begin{itemize}
    \item
      GoF, ``Composite,'' pages 163-174.\\
      Grand, ``Composite,'' pages 165-174.
    \item
      GoF, ``Visitor,'' pages 331-344.\\
      Grand, ``Visitor,'' pages 385-395.
    \end{itemize}

    \emph{Scala versions (2008, 2010)}
  \item
    Straightforward translation of the non-generic Java program to Scala

    \begin{itemize}
    \tightlist
    \item
      \href{BinTree/Scala/Nongeneric/BinTreeFramework.scala}{Top-level
      framework (BinTreeFramework)}
    \item
      \href{BinTree/Scala/Nongeneric/EulerTourVisitor.scala}{Second-level
      Euler tour framework (EulerTourVisitor)}
    \item
      \href{BinTree/Scala/Nongeneric/MappingVisitor.scala}{Second-level
      mapping visitor framework (MappingVisitor)}
    \item
      \href{BinTree/Scala/Nongeneric/BreadthFirstVisitor.scala}{Second-level
      breadth-first framework (BreadthFirstVisitor)}
    \item
      \href{BinTree/Scala/Nongeneric/BinTreeTest.scala}{Application of
      BinTree frameworks (BinTreeTest)}
    \end{itemize}
  \item
    Generic implementation of BinTree framework in Scala.

    \begin{itemize}
    \tightlist
    \item
      \href{BinTree/Scala/Generic/BinTreeFramework.scala}{Top-level
      framework (BinTreeFramework)}
    \item
      \href{BinTree/Scala/Generic/EulerTourVisitor.scala}{Second-level
      Euler tour framework (EulerTourVisitor)}
    \item
      \href{BinTree/Scala/Generic/BreadthFirstVisitor.scala}{Second-level
      breadth-first framework (BreadthFirstVisitor)}
    \item
      \href{BinTree/Scala/Generic/BinTreeTest.scala}{Application of
      BinTree frameworks (BinTreeTest)}
    \end{itemize}
  \end{enumerate}
\item
  (TBD) Use the Digraph ADT module to build the Wizard's Adventure game

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    \href{Wizard/Elixir/wizards_game.ex}{Wizard's Adventure game,
    Version 1,} adapted from Chapter 5, 6, and 17 of Conrad Barski's
    \emph{Land of Lisp: Learn to Program in Lisp, One Game at a Time},
    No Starch Press, 2011.
  \item
    \href{Wizard/Elixir/wizards_game2a.ex}{Wizard's Adventure game,
    Version 2,} that uses a higher order function to generate game
    actions and improved handling of the game state.
  \end{enumerate}
\item
  (TBD) Examine the Dice of Doom game.

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Background: Conrad Barski. \emph{Land of Lisp: Learn to Program in
    Lisp, One Game at a Time}, No Starch Press, 2011.
  \item
    \href{Dice_of_Doom/Elixir/dice_of_doom_v1a.ex}{Dice of Doom, Version
    1a}, is a basic eagerly evaluated version (similar to that developed
    on pages 303-325 of \emph{Land of Lisp}). This version supports
    either two human players or a human player and a simple, minimax
    search-based ``AI'' (artificial intelligence) opponent.
  \item
    \href{Dice_of_Doom/Elixir/dice_of_doom_v1b.ex}{Dice of Doom, Version
    1b}, is an eager version above with an attempt at memoization of
    functions \texttt{neighbors} and \texttt{game\_tree} using the
    Elixir \texttt{Agent} modules.
  \item
    \href{Dice_of_Doom/Elixir/dice_of_doom_v2a.ex}{Dice of Doom, Version
    2a,} is a lazy version using Elixir \texttt{Stream} data structures
    (but without the memoization optimizations). This is based on
    version 1a above plus the discussion from pages 384-389 in chapter
    18 of \emph{Land of Lisp}. This version implements a limited depth
    minimax search, but it does not implement the artificial
    intelligence heuristics given in the last part of chapter 18.
  \end{enumerate}
\item
  (TBD) Arithmetic expression tree program skeletons

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Background: These are expanded from the example in
    \href{ScalaForJava/ScalaForJava.html}{Notes on Scala for Java
    Programmers}.

    \emph{Lua versions (2013-16)}
  \item
    Lua recursive function versions (2013, 2014)

    \begin{itemize}
    \tightlist
    \item
      \href{Expression/Lua/exprRecFuncRecord.lua}{Lua Recursive
      Functions with Record Representation}
    \item
      \href{Expression/Lua/exprRecFuncList2.lua}{Lua Recursive Functions
      with List Representation}
    \item
      \href{Expression/Lua/exprEvalTable2.lua}{Lua Evaluation Function
      Table with List Representation}
    \end{itemize}
  \item
    Lua object-oriented versions (2013, 2016)

    \begin{itemize}
    \tightlist
    \item
      \href{Expression/Lua/exprObjBased.lua}{Lua Prototype Object-Based}
    \item
      \href{Expression/Lua/exprObjInherit.lua}{Lua Object-Oriented with
      Inheritance}
    \end{itemize}
  \item
    Lua LPEG parsers (2013)

    \begin{itemize}
    \tightlist
    \item
      \href{ExprParser/Lua/exprParser.lua}{Parser with captures}
    \item
      \href{ExprParser/Lua/exprParserSemantic.lua}{Parser with semantic
      actions}
    \end{itemize}

    \emph{Scala versions (2008-16)}
  \item
    \href{Expression/Scala/ExprCase.scala}{Scala recursive function
    version using case classes}
  \item
    \href{Expression/Scala/ExprObj.scala}{Scala traditional
    object-oriented version}
  \end{enumerate}
\item
  (TBD) Study the Movable and Named Objects case study (in Lua but based
  on a Haskell case study by Thompson)

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    \emph{Purpose}: The Named and Movable Objects case study explores
    use of inheritance hierarchies and multiple inheritance in Lua. I
    also extracted a ``class support module'' from the initial version
    of this code; this module was used in later case studies (e.g., Lair
    Configuration DSL).

    The ``makeClass'' function dynamically creates a ``class'' that has
    zero or more superclasses. It creates the class prototype object
    with an appropriate constructor/initialization function, appropriate
    default definitions of instance methods, and the needed settings of
    metaclasses and the \texttt{\_\_index} metamethod to support the
    inheritance hierarchy.
  \item
    Background reading on object-oriented programming languages:
    \href{Fundamentals/01Fundamental450.html\#object-oriented}{Object-oriented}
    subsection of the
    \href{Fundamentals/01Fundamental450.html}{Fundamental Concepts of
    Programming Languages} notes
  \item
    Background reading on case study: Section 14.6 of Simon Thompson.
    \emph{Haskell: The Craft of Functional Programming}, Third Edition,
    Addison Wesley, 2011

    Note: We should readdress the design and implementation of this case
    study and the class support module. The latter may be too complex
    for our purposes in this course.
  \item
    \href{Movable/Lua/movable.lua}{First Lua version} (movable.lua)
  \item
    Modularized Lua version with improved class support:

    \begin{itemize}
    \tightlist
    \item
      \href{Movable/Lua/class_support.lua}{class support module}
      (class\_support.lua)
    \item
      \href{Movable/Lua/movable2.lua}{module using class-support}
      (movable2.lua)
    \item
      \href{Movable/Lua/movable2Test.lua}{test driver}
      (movable2Test.lua)
    \end{itemize}
  \item
    Other older versions:

    \begin{itemize}
    \tightlist
    \item
      \href{Movable/Scala/MovableNamedTypes.hs}{Haskell source}
    \item
      \href{Movable/Scala/Movable.scala}{Scala source (partial)}
    \end{itemize}
  \end{enumerate}
\item
  (TBD) Examine the complex number arithmetic modules in Lua

  Modules are repeated in each package in which they are used

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \tightlist
  \item
    \emph{Background} reading:
    \href{http://mitpress.mit.edu/sicp/}{\emph{Structure and
    Interpretation of Computer Programs}}, Second Edition, MIT Press,
    1996, Section 2.4
  \end{enumerate}

  \begin{quote}
  \href{https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/video-lectures/}{SICP
  video lectures, Hal Abelson}
  \end{quote}

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \setcounter{enumii}{1}
  \item
    Rectangular coordinates modules:\\
    \href{Complex/Lua/complexRectangular.lua}{{[}arithmetic{]}}
    \href{Complex/Lua/complexRectangularRep.lua}{{[}rectangular
    representation{]}}
    \href{Complex/Lua/complexUtilities.lua}{{[}utilities{]}}
    \href{Complex/Lua/testComplexRectangular.lua}{{[}test driver{]}}
  \item
    Polar coordinates modules: ~\\
    \href{Complex/Lua/complexPolar.lua}{{[}arithmetic{]}}
    \href{Complex/Lua/complexPolarRep.lua}{{[}polar representation{]}}
    \href{Complex/Lua/complexUtilities.lua}{{[}utilities{]}}
    \href{Complex/Lua/testComplexPolar.lua}{{[}test driver{]}}
  \item
    Tagged data modules: ~
    \href{Complex/Lua/complexTagged.lua}{{[}arithmetic{]}}
    \href{Complex/Lua/dataTagging.lua}{{[}data tagging{]}}
    \href{Complex/Lua/complexUtilities.lua}{{[}utilities{]}}
    \href{Complex/Lua/testComplexTagged.lua}{{[}test driver{]}}
  \item
    Data-directed programming modules: ~\\
    \href{Complex/Lua/complexDataDirected.lua}{{[}arithmetic{]}}
    \href{Complex/Lua/complexRectangularRep.lua}{{[}rectangular
    representation{]}} \href{Complex/Lua/complexPolarRep.lua}{{[}polar
    representation{]}} \href{Complex/Lua/dataTagging.lua}{{[}data
    tagging{]}} \href{Complex/Lua/complexUtilities.lua}{{[}utilities{]}}
    \href{Complex/Lua/testComplexDataDirected.lua}{{[}test driver{]}}
  \item
    Object-oriented modules:\\
    \href{Complex/Lua/complexObjOriented.lua}{{[}arithmetic{]}}
    \href{Complex/Lua/complexUtilities.lua}{{[}utilities{]}}
    \href{Complex/Lua/testComplexObjOriented.lua}{{[}test driver{]}}
  \end{enumerate}
\item
  (TBD) Kamin Interpreters in Lua Toolset (KILT)

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    \href{Kamin_Budd_interpreters/}{Kamin-Budd Interpreters}
  \item
    Language/Interpreter-independent modules:\\
    {[}\href{KILT/repl.lua}{REPL Module (repl.lua)}{]}\\
    {[}\href{KILT/environment.lua}{Environment Module
    (environment.lua)}{]}\\
    {[}\href{KILT/funtab.lua}{Function Table Module (funtab.lua)}{]}\\
    {[}\href{KILT/utilities.lua}{Utilities Module (utilities.lua)}{]}\\
    {[}\href{KILT/opcodes.lua}{Opcodes Factory Module
    (opcodes.lua)}{]}\\
    {[}\href{KILT/values.lua}{Values Factory Module (values.lua)}{]}\\
    {[}\href{KILT/parser.lua}{Parser Factory Module (parser.lua)}{]}\\
    {[}\href{KILT/evaluator.lua}{Evaluator Factory Module
    (evaluator.lua)}{]}
  \item
    Kamin Chapter 1 Core language interpreter:\\
    {[}\href{KILT/Core.lua}{Core Interpreter (Core.lua)}{]}\\
    {[}\href{KILT/opcodes_core.lua}{Core Opcodes
    (opcodes\_core.lua)}{]}\\
    {[}\href{KILT/values_core.lua}{Core Values Module
    (values\_core.lua)}{]}\\
    {[}\href{KILT/parser_core.lua}{Core Parser Module
    (parser\_core.lua)}{]}\\
    {[}\href{KILT/evaluator_core.lua}{Core Evaluator Module
    (evaluator\_core.lua)}
  \item
    Kamin Chapter 2 Lisp language interpreter:\\
    {[}\href{KILT/Lisp.lua}{Lisp Interpreter (Lisp.lua)}{]}\\
    {[}\href{KILT/opcodes_lisp.lua}{Lisp Opcodes
    (opcodes\_lisp.lua)}{]}\\
    {[}\href{KILT/values_lisp.lua}{Lisp Values Module
    (values\_lisp.lua)}{]}\\
    {[}\href{KILT/parser_lisp.lua}{Lisp Parser Module
    (parser\_lisp.lua)}{]}\\
    {[}\href{KILT/evaluator_lisp.lua}{Lisp Evaluator Module
    (evaluator\_lisp.lua)}\\
    {[}\href{KILT/LispExamplesKaminChap2.txt}{A few Lisp examples}{]}
  \item
    Kamin Chapter 4 Scheme language interpreter:\\
    {[}\href{KILT/Scheme.lua}{Scheme Interpreter (Scheme.lua)}{]}\\
    {[}\href{KILT/opcodes_scheme.lua}{Scheme Opcodes
    (opcodes\_scheme.lua)}{]}\\
    {[}\href{KILT/values_scheme.lua}{Scheme Values Module
    (values\_scheme.lua)}{]}\\
    {[}\href{KILT/parser_scheme.lua}{Scheme Parser Module
    (parser\_scheme.lua)}{]}\\
    {[}\href{KILT/evaluator_scheme.lua}{Scheme Evaluator Module
    (evaluator\_scheme.lua)}\\
    {[}\href{KILT/SchemeExamples.txt}{A few Scheme examples}{]}
  \end{enumerate}
\item
  (TBD) Lua list module case study (Cell List)

  \emph{Purpose}: This Lua case study illustrates (i) functional
  programming principles, (ii) design and implementation methods for
  abstract data types and information hiding modules, and, (iii) Lua
  programming techniques (linked lists, stateless iterators, closures,
  metatables, etc.)

  \emph{Background reading} on Lua: Chapter 11 on data structures (pages
  107-116) and Chapter 15 on modules (pages 151-161) of
  \emph{Programming in Lua} (PiL), Third Edition

  \emph{Caveats}: (1) These modules (from 2013-14) internally layer the
  operations into primitive and non-primitive operations, but they do
  not separate the primitive operations into its own module. That can be
  done similarly to the Rational Arithmetic case study. (2) In the
  future, I plan to construct a more efficient implementation that uses
  array-style tables. The table-based versions likely also need to use
  weak tables to avoid memory leaks.

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Cell-based list module:\\
    \href{CellLists/Lua/cellList.lua}{{[}module source{]}}
    \href{CellLists/Lua/cellListTest.lua}{{[}test driver{]}}
  \item
    Closure-and-table-based list module variant:\\
    \href{CellLists/Lua/cellListClosure.lua}{{[}module source{]}}
    \href{CellLists/Lua/cellListClosureTest.lua}{{[}test driver{]}}
  \item
    Function-based cell list module variant:\\
    \href{CellLists/Lua/cellListFunct.lua}{{[}module source{]}}
    \href{CellLists/Lua/cellListFunctTest.lua}{{[}test driver{]}}
  \item
    Lazy list module variant using C preprocessor (cpp -P):\\
    \href{CellLists/Lua/lazyList1.lua}{{[}module source{]}}
    \href{CellLists/Lua/lazyList1X.lua}{{[}source after cpp{]}}\\
    \href{CellLists/Lua/lazyList1Test.lua}{{[}test driver{]}}
    \href{CellLists/Lua/lazyList1TestX.lua}{{[}driver after cpp{]}}
    \href{CellLists/Lua/lazyList1run.sh}{{[}sh script{]}}
  \item
    Lazy list module variant using
    \href{https://github.com/stevedonovan/LuaMacro}{Lua Macro 2.5}:\\
    \href{CellLists/Lua/lazyListMacros.lua}{{[}macro definitions{]}}
    \href{CellLists/Lua/lazyList2.luam}{{[}module macro source{]}}
    \href{CellLists/Lua/lazyList2.lua}{{[}source after luam -o{]}}\\
    \href{CellLists/Lua/lazyList2Test.luam}{{[}macro test driver{]}}
    \href{CellLists/Lua/lazyList2Test.lua}{{[}driver after luam -o{]}}
    \href{CellLists/Lua/lazyList2run.sh}{{[}sh script{]}}
  \end{enumerate}
\item
  (TBD) Examine functions adapted from SICP

  \begin{enumerate}
  \def\labelenumii{\alph{enumii}.}
  \item
    Background reading: Chapter 1 of the classic textbook SICP -- Harold
    Abelson and Gerald J. Sussman with Julie Sussman. \emph{Structure
    and Interpretation of Computer Programs}, Second Edition, MIT Press,
    1996:\\
    {[}\href{http://mitpress.mit.edu/sicp/}{book site at MIT Press}{]}
    {[}\href{http://mitpress.mit.edu/sicp/full-text/book/book.html}{HTML}{]}
    {[}\href{http://sicpebook.wordpress.com/}{SICP ebook site}
  \item
    First-order functions in Scala

    \begin{itemize}
    \tightlist
    \item
      \href{SICP_examples/Scala/sqrt.scala}{Square root (Newton's
      Method) with all public functions}
    \item
      \href{SICP_examples/Scala/sqrt2.scala}{Square root (Newton's
      Method) with nested function definitions}
    \item
      \href{SICP_examples/Scala/factorial.scala}{Factorial}
    \item
      \href{SICP_examples/Scala/fibonacci.scala}{Fibonacci}
    \item
      \href{SICP_examples/Scala/exponentiation.scala}{Exponentiation}
    \item
      \href{SICP_examples/Scala/gcd.scala}{Greatest common divisor}
    \end{itemize}
  \item
    Higher-order functions in Scala

    \begin{itemize}
    \tightlist
    \item
      \href{SICP_examples/Scala/summation.scala}{Summation (takes
      function arguments)}
    \item
      \href{\%3CSICP_examples/Scala/derivative.scala\%3E}{Derivative
      (returns function result)}
    \end{itemize}
  \item
    Lua versions

    \begin{itemize}
    \tightlist
    \item
      \href{SICP_examples/Lua/sqrt.lua}{Square root (Newton's Method)}
    \item
      \href{SICP_examples/Lua/factorial.lua}{Factorial}
    \item
      \href{SICP_examples/Lua/fibonacci.lua}{Fibonacci}
    \item
      \href{SICP_examples/Lua/exponentiation.lua}{Exponentiation}
    \item
      \href{SICP_examples/Lua/gcd.lua}{Greatest common divisor}
    \item
      \href{SICP_examples/Lua/summation.lua}{Summation}
    \item
      \href{SICP_examples/Lua/derivative.lua}{Derivative}
    \end{itemize}
  \item
    Also various \href{SICP_examples/Haskell/}{Haskell},
    \href{SICP_examples/Elixir/}{Elixir},
    \href{SICP_examples/Elm/}{Elm}, and
    \href{SICP_examples/Scheme/}{Scheme} versions
  \end{enumerate}
\end{enumerate}

\hypertarget{unprocessed-old-materials}{%
\subsection{Unprocessed Old Materials}\label{unprocessed-old-materials}}

\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\setcounter{enumi}{300}
\item
  \href{RecursionConcepts.html}{Notes on Recursion Concepts and
  Terminology}
\item
  \href{EvaluationConcepts.html}{Notes on Functional Program Evaluation
  Concepts}
\item
  Jim Weirich. ``Rake Tutorial,'' ``Rake User Guide,'' and ``Rake by
  Example,'' 2005.\\
  (Basic ideas discussed.) {[}\href{http://docs.rubyrake.org}{Ruby Rake
  web site}{]}
\item
  Jim Freeze. Creating DSLs with Ruby, Artima Developer,
  \url{http://www.artima.com/rubycs/articles/ruby/_as/_dsl.html}, March
  2006.\\
  {[}\href{http://www.artima.com/rubycs/articles/ruby_as_dsl.html}{Artima
  website}{]} {[}{[}local printer-friendly
  copy{]}(\url{http://www.cs.olemiss.edu/~hcc/engr692ruby/notes/ruby/_as/_dslP.htm}l){]}
\item
  Jamis Buck. Writing Domain Specific Languages,
  \texttt{the\ \{\ buckblogs\ :here\ \}}, 20 April 2006.\\
  {[}\href{\%3Chttp://weblog.jamisbuck.org/2006/4/20/writing-domain-specific-languages}{blog
  entry}{]}
\end{enumerate}

\end{document}
