The seminar consisted of two parts, which took place in the winter semester (Part I) and in the summer semester (Part II).
In Part I we dealt with the state-of-the-art (SoA) in probabilistic modeling using probabilistic programming languages (as an example the DSL WebPPL) in cognition (perception, problem solving, evaluation, decision making) and behavioral control of predominantly natural agents.
Part II dealt with probabilistic modeling in technical, epidemiological and ecological contexts.We also considered the SoA in the development of new probabilistic modeling languages (e.g. PyRo, TURING, Greta, PyMC3).
This division of the contents adapted to the students' previous knowledge and wishes.
The successful participation in both seminars could be combined in such a way that it corresponded to a lecture module.

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

This is all draft for personal use; comments, bug reports, or proposals are welcome:

claus.moebus(at)uol.de

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

The authors try to motivate devs to use an additive style in designing software. All programs in the book are written in MIT/GNU-Scheme – a highly flexible language -.  The authors argue that the presentation and explanation of programming ideas is more concise in Scheme than in other more popular languages (SDFF, 2021, p.xvi). Our hypothesis is that Julia being more popular than Scheme offers the same or even more conciseness and higher usability. In some cases we use RACKET/Scheme as an intermediate representation in the transpilation process.As IDE we have chosen PLUTO a reactive notebook offering a fantastic platform for development and documentation of Julia programs.

This experiment has two aims. The first is rather selfish. We want to improve our competence in Racket, Scheme and Julia. The second is centered at our hypothesis, whether Julia is sufficiently usable, flexible, expressible, and concise to follow all ideas of Hanson and Sussman expressed in their book SDFF.

• 2. Domain-Specific Languages
• 2.1 Combinators
• 2.1.1 Function Combinators (Julia/Pluto)
• 2.1.1 Function Combinators (Racket / Scheme)
• 2.2 Julia Modules, Types, and OOP (replacement of SDFF’s ch. 2.2 *Regular Expressions*)
• 2.3 Wrappers (Julia/Pluto)

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

This is all draft for personal use; comments, bug reports, or proposals are welcome:

claus.moebus(at)uol.de

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

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 or vice versa. The book 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 learning diary.

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 year ago David Barber gave advice to give Julia a try. In the end I stumbled across the fascinating probabilistic programming languages Gen and Turing, both embedded in Julia. That was the starting point to deal with Julia to have a solid fundament for modeling in Gen and Turing.

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 educational purposes.

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, 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 here: https://sarabander.github.io/sicp/html/Foreword.xhtml#Foreword

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
      2. Constructing Procedures Using Lambda
      3. Procedures as General Methods
      4. Procedures as Returned Values
      5. Removing Recursion with the Fixed-point Y-Operator
      6. 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. in Tables.jl
      4. A Simulator for Digital Circuits
      5. Propagation of Constraints
   4. Concurrency: Time is of the Essence
   5. Streams

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").

1 Mathematical Background

1.1 Infinite Series

01 Geometric Sequence

02 Harmonic Series

03 Binomial Series

2 Stochastic Background

10 Boltzmann's and Shannon's Entropy

3 Machine Learning

3.1 Classification

20 Linear Binary Classifier

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

This is all draft for personal use; comments, bug reports, or proposals are welcome:

claus.moebus(at)uol.de

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

- Factors as Matrices, Dictionaries, and DataFrames and .csv-Data