Projects
Contact
Prof. Dr. Claus Möbus
Room: A02 2-226
claus.moebus@uol.de
-------------------------------------------
Secretary
Manuela Wüstefeld
Room: A02 2-228
Tel: +49 441 / 798-4520
manuela.wuestefeld@uol.de
-------------------------------------------
Projects
Course Offerings
We offered two seminars "Probabilistic Modeling I (Inf 533) / II (534)"
Seminar Probabilistic Modeling I (Inf 533) / II (Inf 534)
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
-----------------------------------------------------------------------------------------
Transpilation of SDFF: From MIT/GNU-Scheme to Julia/Pluto.jl
Hanson, Ch. & Sussman, G.J.; Software Design For Flexibility: How To Avoid Programming Yourself into a Corner, MIT Press, 2021
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
-----------------------------------------------------------------------------------------
Let's explore SICP with Julia and vice versa
- A Personal Learning Diary with Pluto -
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
-
Building Abstractions with Procedures
-
The Elements of Programming
-
Procedures and the Processes They Generate
-
Formulating Abstractions with Higher-Order Procedures
-
-
Building Abstractions with Data
- Introduction to Data Abstraction
- Hierarchical Data and the Closure Property
- Symbolic Data
- Multiple Representations for Abstract Data
- Systems with Generic Operations
- Generic Arithmetic Operations
- Combining Data of Different Types
- Example: Symbolic Algebra
-
Modularity, Objects, and State
- Assignment and Local State
- Local State Variables
- The Benefit of Introducing Assignment
- The Costs of Introducing Assignment
- The Environment Model of Evaluation
- Modeling with Mutable Data
- Mutable List Structure
- Representing Queues...
- Representing Tables
- in Scheme-like Julia
- in Tables.jl
- A Simulator for Digital Circuits
- Propagation of Constraints
- Concurrency: Time is of the Essence
- Streams
- Assignment and Local State
-
Metalinuistic Abstraction
-
Computing with Register Machines
This work is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License ("Public License").
Machine Learning with Julia/Pluto.jl
1 Mathematical Background
1.1 Infinite Series
2 Stochastic Background
10 Boltzmann's and Shannon's Entropy
3 Machine Learning
3.1 Classification
-----------------------------------------------------------------------------------------
This is all draft for personal use; comments, bug reports, or proposals are welcome:
claus.moebus(at)uol.de
-----------------------------------------------------------------------------------------
Decision Making and Statistics with Julia