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

This is a personal learning diary when exploring Julia through working with the Scheme scripts in SICP.  Perhaps inspired by the fancy characters on the cover, the SICP book is called the wizard book. This should inspire the reader to become a wizard himself.

I love Scheme for its elegance and minimalism. But for production purposes in my various scientific projects I had to use other languages 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 year ago David Barber (author of Bayesian Reasoning and Machine Learning) proposed me to give Julia a try. Then I stumbled across the fascinating probabilistic programming languages Gen and Turing, both embedded in Julia. That rose my motivation to get a solid Julian foundation for modeling in Gen and Turing. This foundation seems even valuable to me for modern billion-parameter AI-LLM-Models (like ChatGPT).

Here we present transpilations of SICP-Scheme-scripts into Julia as well as alternatives with idiomatic JULIA constructs within a Pluto.jl-embedding. Pluto.jl offers reactive notebooks very suitable for exploration and educational purposes.

We use 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 and reader of this diary has acquired several competencies. S|he is competent in understanding CS-concepts, reading Scheme-scripts, and developing new scripts in Julia/Pluto.jl while solving SICP problems.

Learners expecting a gamified learning environment 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 how many SICP exercises are solved in Julia. We estimate that a newbee to programming needs 2-3 hours/day over a 12 month period (2 semesters), whereas an expert (in say Python) will need only a fraction of that time but only if (s)he is openminded.

C.M.

P.S.: The electronic version of SICP can be found here or here.

New content beyond SICP is denoted by nonSICP.

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 Substitution 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. Basics
         2. nonSICP: Cantor Set
         3. nonSICP: Lebesgue Integration
         4. nonSICP: Stochastic First Choice Voting Models
      2. Constructing Procedures Using Lambda
         1. Basics
         2. nonSICP: Omega Combinator and Continuation Passing Style (CPS)
      3. Procedures as General Methods
      4. Procedures as Returned Values
      5. nonSICP: Removing Recursion by Fixed Point Operator Y
      6. nonSICP: You Could Have Invented Monads I
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 I
      5. Example: A Picture Language II
   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
      4. nonSICP: Message Passing
   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 Hierarchies
      3. Example: Symbolic Algebra
3. Modularity, Objects, and State
   1. Assignment and Local State
      1. Local State Variables
      2. The Benefits of Introducing Assignment
         1. nonSICP: Monte Carlo I
         2. nonSICP: Monte Carlo II
      3. The Costs of Introducing Assignment
   2. The Environment Model of Evaluation
      1. The Rules for 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. FIFOs
         2. with Data Structures
      3. Representing Tables
         1. Representing Tables
         2. nonSICP: OLS-Regression with Data Matrices
      4. A Simulator for Digital Circuits
         1. Simulation of Basic Gates
         2. Simulation of Basic Circuits
      5. Propagation of Constraints
   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
      3. Exploiting the Stream Paradigm
      4. Streams and Delayed Evaluation
      5. Modularity of Functional Programs and Modularity of Objects