Motivation

From Scheme ((lambda (x) (x x)) (lambda (x) (x x))) to Julia (x → x(x)) (x → x(x))

This is a personal learning diary when exploring the scientific computer language Julia by exploiting the mile-stone computer programming book SICP (html) or vice versa. The book’s pdf compiled from TeX source can be found here. This online version is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License. This is also true for our project, here.

I used Lisp and especially Scheme regularly from time to time. I loved Scheme for its elegance and minimalism. But for production purposes in various scientic projects I had to use other languages for pragmatic reasons, like Fortran, Prolog, R, Javascript, Bugs, Stan, WebPPL and even Python. But I was always looking for a language as elegant as Scheme but with a greater usability and usefulness. Several years ago David Barber gave an advice to me to give Julia a try. In the end I stumbled across the fascinating probabilistic programming languages Gen and Turing, both embedded in Julia. This was the kicking event to self-study Julia in a project-centered approach.

Here we present transpilations of SICP-Scheme-scripts into Julia as well as alternatives exploiting idiomatic JULIA constructs within a Pluto.jl-embedding. Pluto.jl offers reactive notebooks very suitable for experimental and explorative studies.

We offer Pluto.jl as a learning environment for self-guided learning Julia. The original SICP is expected to be the accompanying study-guide. All SICP-Scheme-scripts are reconstructed in Julia in a stepwise manner. Furthermore idiomatic Julia scripts are added to demonstrate solutions made possible by advanced Julia features.

In the end it is guaranteed that the learner has acquired several competencies. S|he is competent in understanding CS-concepts (like FP, OOP, DSL, EDS,...), reading Scheme-scripts, and developing new scripts in Julia/Pluto.jl.

Learners expecting a gamified learning environment (https://en.wikipedia.org/wiki/Gamification_of_learning) will be disappointed. This is a rather academic (dry ;) ) learning experience. So your intrinsic motivation in studying Julia should be rather high.

The time investment needed is not trivial. Of course this depends on the preknowledge and the aspiration of the learner. We estimate that a newbee to programming needs 1-2 hours/day over a 12 month period (2 semesters), whereas an expert (in say Python) will need only a few weeks.

C.M.

P.S.: The electronic version of SICP can be found as html here: https://mitp-content-server.mit.edu/books/content/sectbyfn/books_pres_0/6515/sicp.zip/full-text/book/book.html and as pdf here: https://web.mit.edu/6.001/6.037/sicp.pdf

Structure And Interpretation of Computer Programs (= SICP) in Julia

1. Building Abstractions with Procedures

   1. The Elements of Programming

      1. Expressions
      2. Naming and the Environment
      3. Evaluating Combinations
      4. Compound Procedures
      5. The Substitutional Model for Procedure Application
      6. Conditional Expressions and Predicates
      7. Example: Square Roots by Newton’s Method
      8. Procedures as Black-Box Abstractions

   2. Procedures and the Processes They Generate

      1. Linear Recursion and Iteration
      2. Tree Recursion
      3. Orders of Growth
      4. Exponentiation
      5. Greatest Common Divisors
      6. Example: Testing for Primality

   3. Formulating Abstractions with Higher-Order Procedures

      1. Procedures as Arguments
         1. Procedures as Arguments: Basics (e.g. Cantor Set, Integration à la Riemann & Lebesgue (NonSICP))
         2. NonSICP: Cognitive First Choice Models
         3. NonSICP: Regression First Choice Models
      2. Constructing Procedures Using Lambda
      3. Procedures as General Methods
      4. Procedures as Returned Values
      5. NonSICP: Removing Recursion with the Fixed-point Y-Operator
      6. NonSICP: You Could Have Invented Monads

2. Building Abstractions with Data

   1. Introduction to Data Abstraction
      1. Example:Arithmetic Operations for Rational Numbers
      2. Abstraction Barriers
      3. What is Meant by Data ?
      4. Extended Exercise: Interval Arithmetic
   2. Hierarchical Data and the Closure Property
      1. Representing Sequences
      2. Hierarchical Structures
      3. Sequences as Conventional Interfaces
      4. Example: A Picture Language
   3. Symbolic Data
      1. Quotation
      2. Example: Symbolic Differentiation
      3. Example: Representing Sets
      4. Example: Huffman Encoding Trees
   4. Multiple Representations for Abstract Data
      1. Representations for Complex Numbers
      2. Tagged Data
      3. Data-directed Programming and Additivity
   5. Systems with Generic Operations
      1. Generic Arithmetic Operations
      2. Combining Data of Different Types
         1. Cross-Type Operations
         2. Coercion
         3. Hierarchies of Types
         4. Inadequacies of Type Hierarchies
      3. Example: Symbolic Algebra

3. Modularity, Objects, and State

   1. Assignment and Local State
      1. Local State Variables
      2. The Benefit of Introducing Assignment
         1. Monte Carlo I
         2. Monte Carlo II
      3. The Costs of Introducing Assignment
   2. The Environment Model of Evaluation
      1. The Rules of Evaluation
      2. Applying Simple Procedures
      3. Frames as the Repository of Local State
      4. Internal Definitions
   3. Modeling with Mutable Data
      1. Mutable List Structure
      2. Representing Queues...
         1. in Scheme-like Julia
         2. in DataStructures.jl
      3. Representing Tables
         1. in Scheme-like Julia
         2. NonSICP: in Data Matrices and Regression Analysis
         3. NonSICP: in Data Matrices and the Classical Linear Model
         4. NonSICP: in DataFrames.jl and GLM.jl
      4. A Simulator for Digital Circuits: DSL + Event Driven Simulation
         1. Simulation of Inverter, Or- and And-Gates
         2. Simulation of Half- and Fulladder Circuits
      5. Propagation of Constraints: DSL + Relational Programmming
   4. Concurrency: Time is of the Essence
      1. The Nature of Time in Concurrent Systems
      2. Mechanisms for Controlling Concurrency
   5. Streams
      1. Streams Are Delayed Lists
      2. Infinite Streams
         1. Infinite Streams I
         2. Infinite Streams II: Iterators and TCO by Trampoline
         3. Infinite Streams III: Defining Streams Implictly
      3. Exploiting The Stream Paradigm
         1. Formulating Iterations as Stream Processes
         2. Infinite Streams of Pairs
         3. Streams as Signals
      4. Streams and Delayed Evaluation
      5. Modularity of Functional Programs and Modularity of Objects

4. Metalinuistic Abstraction

5. Computing with Register Machines

This work is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License ("Public License").