Two Julia pearls

*While trying once again to find if there was any Julia version of the Classic Computer Science Problems by David Kopec (there are versions in Python, Java, Rust, JavaScript and others in GitHub - davecom/ClassicComputerScienceProblemsInPython: Source Code for the Book Classic Computer Science Problems in Python 9), I found these very important pearls from @CMoebus in JULIA Projects // University of Oldenburg 25 a Julia application of the SICP and of the ISLR2, both using Pluto.jl.*

https://discourse.julialang.org/t/two-julia-pearls/116352

Motivation

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

This is my personal diary when learning the scientific computer language Julia by exploring the mile-stone computer programming book SICP. The book’s html-version is here and the 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 cognitive science 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 greater usability and richer eco system.

Several years ago David Barber gave me a hint to try Julia. There I stumbled across the probabilistic programming languages Gen.jl and Turing.jl, both embedded in Julia. This was the kicking event to self-study Julia in small steps embedded in a project-centered approach.

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. Pluto.jl is used both as an ide and as a learning environment. It enforces a declarative style and offers reactive notebooks very suitable for experimental and explorative studies.

In the end it is guaranteed that the learner has acquired several competencies. S|he is competent in understanding basic CS-concepts (like FP, OOP, DSL,...), reading Scheme-scripts, and developing new code 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, the aspiration of the learner, and the motivation to solve the SICP-exercises. We estimate that a newbee to programming needs 1-3 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 I
      7. NonSICP: You Could Have Invented Monads II
      8. NonSICP: You Could Have Invented Monads III

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 is a draft under the Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) license. Comments, improvement and issue reports are welcome: claus.moebus(@)uol.de

-------------------------------------------------------------------------------------------------------------