fixed links, regenerated

.envrc

@@ -1 +1,11 @@
-use flake
+if ! has nix_direnv_version || ! nix_direnv_version 2.3.0; then
+  source_url "https://raw.githubusercontent.com/nix-community/nix-direnv/2.3.0/direnvrc" "sha256-Dmd+j63L84wuzgyjITIfSxSD57Tx7v51DMxVZOsiUD8="
+fi
+
+nix_direnv_watch_file devenv.nix
+nix_direnv_watch_file devenv.lock
+nix_direnv_watch_file devenv.yaml
+if ! use flake . --impure
+then
+  echo "devenv could not be built. The devenv environment was not loaded. Make the necessary changes to devenv.nix and hit enter to try again." >&2
+fi

.gitignore

@@ -1,2 +1,7 @@
 .direnv
 /result
+
+# Devenv
+.devenv*
+devenv.local.nix
+

.pre-commit-config.yaml

@@ -0,0 +1 @@
+/nix/store/kix2g1bws3b5gdkz88zsx3r6sszrqxaj-pre-commit-config.json

content/About.md

@@ -0,0 +1,65 @@
+---
+title: About me - Drezil
+---
+
+<!-- markdownlint-disable-next-line -->
+<img class="border border-solid w32 rounded-xl lg:rounded-3xl lg:w64 float-right" style="border-color: rgb(217 70 239);" src="/About/Nicole_small.png"/>
+
+## Work
+
+- **October 2023 to ???**
+  - You could be here. The [Red Queen](https://red-queen.ug) will get *your*
+    project off the ground, too.
+
+- **March 2023 to September 2023**:
+  - Worked for [2lambda](http://2lambda.co)
+  - Silicon Valley start-up trying to beat the stock-market with fancy ML-Models
+  - That work kickstarted my employment at [Red Queen UG](https://red-queen.ug)
+    where i continue doing consulting work for [2lambda](http://2lambda.co)
+    while also moving into a more senior role of also building up our own team
+    of specialists to work on different future projects.
+
+- **Oct. 2018 to Aug. 2021**:
+  - ML-Specialist at [Jobware](https://jobware.de) (Paderborn; german Job-Advertising-Platform)
+
+- **2013-2018** several jobs at my University including
+  - Worked 6 Months in the Workgroup "Theoretical Computer Science" on migrating
+    algorithms to **CUDA**
+  - Tutor "Introduction to Machine Learning"
+    - Was awarded **Tutoring-Award** of the Faculty of Technology for excellent tutoring
+  - [[FFPiH|Lecture "Intermediate Functional Programming in Haskell"]]#
+  - Development of Pandoc-Filters for effective **generation of lecture-slides**
+    for Mario Botsch (Leader Workgroup Computer Graphics) using Pandoc &amp; reveal.js
+
+## Education
+
+- **Bachelor** "Kognitive Informatik" (Cognitive Informatics) in Bielefeld 2010-2014
+- **Master** "Naturwissenschaftliche Informatik" (Informatics in the natural
+  sciences) 2014-2018
+
+### Extraordinary grades (Excerpt of my Transcript)
+
+Note: Scale of grades in Germany is 1.0 to 4.0 with 1.0 being best, 4.0 being
+passing grade, 5.0 being failed grade
+
+- **1.0 in Modern Data Analysis**
+  - Master course on data-analysis (time-series, core-vector-machines, gaussian
+    processes, ...)
+- **1.0 in Computergraphics**
+  - Raytracing, Modern OpenGL
+- **1.3 in Computer-Animation**
+  - Dual-Quarternion-Skinning, Character-Animation, FACS-Poses, etc.
+- **1.3 in GPU-Computing (CUDA)**
+  - originally a 1.7 by timing (task was de-mosaicing on images, grade was
+    measured in ms, whereby 400ms equated to 4.0 and 100ms equated to 1.0),
+    but because my deep knowledge was visible in the code i was given a 1.3
+    after oral presentation.
+- **1.0 in Parallel Algorithms and Data-Structures**
+- **Ethical Hacking**
+  - Reverse Engineering with IDApro
+
+## Further information
+
+- [[Work|More details on my work-experience]]#
+- [[Experience|More details of my coding]]#
+- [[Extracurricular|More details of things i did beside studying at University]]#

content/About/CV.md

@@ -1,132 +1,27 @@
 ---
-title: Stefan Dresselhaus
-...
+title: Curriculum Vitae
+page:
+  bodyHtml: |
+    <script>
+      Array.from(
+        document.getElementsByClassName("open")
+      ).forEach(
+        (i) => {
+          i.querySelector('details').setAttribute("open","")
+          }
+      );
+    </script>
 
-# Work-Experience
+---
 
-- **Oct. 2018 to Aug. 2021**:
-    - ML-Specialist at [Jobware](https://jobware.de) (Paderborn; german Job-Advertising-Platform)
-        - Extraction/Classification of sentences from JobAds (Requirements, Benefits, Tasks, ...)
-        - Extraction of Information from JobAds (Location of company, Location of workplay, contact-details, application-procedure, etc.) including geocoding of those information (backed by OpenStreetMap)
-        - Embedding of JobAds into a meaningful space (i.e. "get me similar ads. btw. i dislike ad a, b, c").
-        - Analyse & predict search-queries of users on the webpage and offer likely but distinct queries (i.e. similar when typo or complete different words (synonyms, hyponyms, etc.))
-    - Technologies used:
-        - Haskell (currently GHC 8.6, soon GHC 8.8)
-            - stack + stackage-lts
-            - fixplate (recursion-schemes-implementation)
-            - many usual technologies like lens, http-simple, mtl, ..
-            - golden-testing via tasty
-            - several inhouse-developments:
-                - templating based on text-replacement via generics (fieldname in Template-Type == variable replaced in template)
-                - activeMQ/Kibana-bridge for logging via hs-stomp
-                - generic internal logging-framework
-        - Python
-            - tensorflow
-            - pytorch
-            - sklearn
-            - nltk
+{.open}
+![[About]]
 
-- **2013-2018**:
-    - several jobs at my University including
-        - Worked 6 Months in the Workgroup "Theoretical Computer Science" on migrating algorithms to **CUDA**
-        - Tutor "Introduction to Machine Learning"
-            - Was awarded **Tutoring-Award** of the Faculty of Technology for excellent tutoring
-        - Lecture "Intermediate Functional Programming in Haskell"
-            - Originally developed as student-project in cooperation with Jonas Betzendahl
-            - First held in Summer 2015
-            - Due to high demand held again in Summer 2016 and 2017
-            - Was awarded **Lecturer-Award** "silver Chalk" in 2016
-                - First time that this award was given to students
-                - Many lecturers at our faculty never get any teaching-award until retirement
-        - Development of Pandoc-Filters for effective **generation of lecture-slides** for Mario Botsch (Leader Workgroup Computer Graphics) using Pandoc & reveal.js
-            - Framework: [https://github.com/mbotsch/revealSlides](https://github.com/mbotsch/revealSlides)
-            - Example: [https://github.com/mbotsch/eLearning](https://github.com/mbotsch/eLearning)
-            - Pandoc-Filters: [https://github.com/mbotsch/pandoc-slide-filter](https://github.com/mbotsch/pandoc-slide-filter)
+{.open}
+![[Work]]
 
-<img align="right" style='border:1px solid #000000; float:right; margin-left:20px' height='300px' src="/About/DresselhausStefan_klein2.jpg"/>
-
-# Education
-
-- **Bachelor** "Kognitive Informatik" (Cognitive Informatics) in Bielefeld 2010-2014
-- **Master** "Naturwissenschaftliche Informatik" (Informatics in the natural sciences) 2014-2018
-
-## Extraordinary grades (Excerpt of my Transcript)
-    Scale of grades in Germany is 1.0 to 4.0 with 1.0 being best, 4.0 being passing grade, 5.0 being failed grade
-
-- **1.0 in Modern Data Analysis**
-    - Master course on data-analysis (time-series, core-vector-machines, gaussian processes, ...)
-- **1.0 in Computergraphics**
-    - Raytracing, Modern OpenGL
-- **1.3 in Computer-Animation**
-    - Dual-Quarternion-Skinning, Character-Animation, FACS-Poses, etc.
-- **1.3 in GPU-Computing (CUDA)**
-    - originally a 1.7 by timing (task was de-mosaicing on images, grade was measured in ms, whereby 400ms equated to 4.0 and 100ms equated to 1.0), but because my deep knowledge was visible in the code i was given a 1.3
-- **1.0 in Parallel Algorithms and Data-Structures**
-- **Ethical Hacking**
-    - Reverse Engineering with IDApro
-
-# Haskell-Enthusiast
-
-- Learning/Writing Haskell since ~2014
-- Created and held advanced Haskell-Lecture at my University
-
-## github
-
-- [My Profile](https://github.com/Drezil/)
-- [Haskell-Lecture](https://github.com/FFPiHaskell/)
-- [Co-Founder of DataHaskell](https://github.com/DataHaskell)
-
-## Highlights on github
-
-- **Author** of Eve-Online-Interface in [yesod-auth-oauth2](https://github.com/thoughtbot/yesod-auth-oauth2/pull/33)
-- **Author** of "New Eden Accounting Tool" ([neat](https://github.com/Drezil/neat)), which is basically a ledger for Trading in the game Eve-Online
-- Driver behind getting [https://github.com/jgm/pandoc/issues/168]() implemented and merged, because we needed it for our slide-filters (see Work->Development of Filters)
-- **Author** of [img2ascii](https://github.com/Drezil/img2ascii) - Small cli-tool for converting images into terminal-codes & ascii using JuicyPixels, because i always forget what is on the images over an ssh-connection -.-
-- **Implemented Array-Fusion and Recycling** for [subhask](https://github.com/mikeizbicki/subhask/pull/57) as layed out in [Recycle your Arrays](https://doi.org/10.1007/978-3-540-92995-6_15) by Roman Leshchinskiy
-- [**Raytracer** in Haskell for my Computergraphics-Course](https://github.com/Drezil/htrace)
-- **implementation of [Densely Connected Bi-Clusters](https://github.com/Drezil/hgraph)-Algorithm** in Haskell ([Paper](https://www.researchgate.net/profile/Recep_Colak/publication/267918524_DENSELY-CONNECTED_BI-CLUSTERING/links/560f1aff08ae483375178a03.pdf))
-- several other dead projects :D
-
-
-# Studium generale / University-Life
-
-(What I did at university besides studying ;) )
-
-## Committees / Student Body
-
-- Student Member of Studienbeirat Informatik (Study-Profile Commission)
-- Student Member of Tutorenauswahlkommission (Tutor-Selection Committee)
-    - Leader Tutorenevaluation (Evaluation of Tutors)
-- Student Member of NWI-Master-Auswahlausschuss (Master-Application Committee for my course of study)
-- Student Member of NWI-Master-Prüfungsausschuss (Committee for Exam-disputes of my Master course)
-- Member of the Admin-Team for the student-body pcs
-
-## ekvv-Links (entries in the electronic course-catalog)
-
-
-### Summer 15
-
-- [Fortgeschrittene funktionale Programmierung in Haskell](https://ekvv.uni-bielefeld.de/kvv_publ/publ/vd?id=54004629) (Haskell-Lecture)
-
-    - [Lecture on YouTube](https://www.youtube.com/playlist?list=PLMqFm6rr-xOWhXGroUXzWx00FeaBNfbsa)
-
-### Summer 16
-
-- [Fortgeschrittene funktionale Programmierung in Haskell](https://ekvv.uni-bielefeld.de/kvv_publ/publ/vd?id=71172682) (Haskell-Lecture)
-
-    - [Lecture on YouTube](https://www.youtube.com/playlist?list=PLMqFm6rr-xOUEf2YjSxRn8BIhrdRIhZw6) (differs from link above)
-    - This was the **"silver chalk"-lecture**
-
-### Winter 16/17
-
-- [Richtig Starten](https://ekvv.uni-bielefeld.de/kvv_publ/publ/vd?id=84763664) (Start Right!)
-- [Tutor Introduction to Machine Learning](https://ekvv.uni-bielefeld.de/kvv_publ/publ/vd?id=79599350) (Tutor in this Lecture)
-	- Was awarded **Tutoring-Award** of the faculty
-- Remade and updated slides for [Computergraphics-Lecture](https://ekvv.uni-bielefeld.de/kvv_publ/publ/vd?id=79016005)
-	- Lecture was **awarded "silver chalk"** among others things because of the updated slides.
-
-### Summer 17
-- [Fortgeschrittene funktionale Programmierung in Haskell](https://ekvv.uni-bielefeld.de/kvv_publ/publ/vd?id=94694136) (Haskell-Lecture)
-    - Same as Summer 16
-    - Totally **reworked Exercises** accompanying the lecture
+{.open}
+![[Experience]]
 
+{.open}
+![[Extracurricular]]

content/About/Experience.md

@@ -0,0 +1,42 @@
+# Highlights of my experiences in the programming world
+
+(as far as NDA and other things allow it)
+
+## Haskell-Enthusiast
+
+- Learning/Writing Haskell since ~2014
+- Created and held advanced Haskell-Lecture at my University
+
+### github
+
+- [My Profile](https://github.com/Drezil/)
+- [Haskell-Lecture](https://github.com/FFPiHaskell/)
+- [Co-Founder of DataHaskell](https://github.com/DataHaskell)
+
+## gitea
+
+I also have a [gitea-instance](https://gitea.dresselhaus.cloud/explore/repos)
+where one can finde more current things and backups of old.
+
+### Highlights
+
+- **Author** of Eve-Online-Interface in [yesod-auth-oauth2](https://github.com/thoughtbot/yesod-auth-oauth2/pull/33)
+- **Author** of "New Eden Accounting Tool" ([neat](https://github.com/Drezil/neat)),
+  which is basically a ledger for Trading in the game Eve-Online
+- Driver behind getting [https://github.com/jgm/pandoc/issues/168]() implemented
+  and merged, because we needed it for our slide-filters (see [[Work]]# ->
+  Development of Filters)
+- **Author** of [img2ascii](https://github.com/Drezil/img2ascii) - Small cli-tool
+  for converting images into terminal-codes & ascii using JuicyPixels, because i
+  always forget what is on the images over an ssh-connection -.-
+- **Implemented Array-Fusion and Recycling** for [subhask](https://github.com/mikeizbicki/subhask/pull/57)
+  as layed out in [Recycle your Arrays](https://doi.org/10.1007/978-3-540-92995-6_15)
+  by Roman Leshchinskiy
+- [**Raytracer** in Haskell for my Computergraphics-Course](https://github.com/Drezil/htrace)
+- **implementation of [Densely Connected Bi-Clusters](https://github.com/Drezil/hgraph)-Algorithm** in Haskell
+  ([Paper](https://www.researchgate.net/profile/Recep_Colak/publication/267918524_DENSELY-CONNECTED_BI-CLUSTERING/links/560f1aff08ae483375178a03.pdf))
+- [Chemodiversity-Project](https://gitea.dresselhaus.cloud/Drezil/chemodiversity)
+  at University during my masters. Complete with slideshow explaining
+  everything.
+- several other dead projects :D
+

content/About/Work.md

@@ -0,0 +1,81 @@
+# Work-Experience
+
+- **Mar. 2023 to Sep. 2023:**
+  - Developer for 2Lambda.co. Role migrated from just coding stuff to
+    architecting and rewriting the whole software from the ground up using a
+    small modular approach instead of the shaky one-off systems in place.  
+    Was later a "nanny for everything".
+  - Did a lot of work to have self-documenting code (i.e. generate documentation
+    from the actual values used in the program, not some comments that always
+    get out of date)
+  - Setting up a knowledge-base (Zettelkasten-approach) to track experiments and
+    hyperlink them to the documentation generated above (and due to Zettelkasten
+    you then get "this thing was used in Experiments a, b and c" automatically
+  - Technologies used:
+    - Clojure
+      - Complete application was written in Clojure
+      - Never touched that language before March - got up to speed in just 2
+        days, poked the expert on the team detailed questions about the
+        runtime-system after 1 month (like inlining-behavior, allocation-things,
+        etc.)
+    - Emanote
+      - autogenerated & linked documentation of internal modules
+      - integrated with manual written tutorials/notes
+      - crosslinking documentation of experiments with documentation of modules
+        - Web of knowledge
+        - bidirectional discovery of things tried/done in the past to optimize
+          finding of new strategies (meta-optimizing the decisions on what to
+          optimize/try)
+    - Infrastructure
+      - Organized and co-administrated the 4 Root-Servers we had
+      - Set up Kubernetes, Nexus, Docker, Nginx, letsencrypt-certs, dns-entries,
+        etc..
+
+- **Oct. 2018 to Aug. 2021**:
+  - ML-Specialist at [Jobware](https://jobware.de) (Paderborn; german Job-Advertising-Platform)
+    - Extraction/Classification of sentences from JobAds (Requirements, Benefits,
+      Tasks, ...)
+    - Extraction of Information from JobAds (Location of company, Location of
+      workplay, contact-details, application-procedure, etc.) including geocoding
+      of those information (backed by OpenStreetMap)
+    - Embedding of JobAds into a meaningful space (i.e. "get me similar ads. btw.
+      i dislike ad a, b, c").
+    - Analyse & predict search-queries of users on the webpage and offer likely
+      but distinct queries (i.e. similar when typo or complete different words
+      (synonyms, hyponyms, etc.))
+  - Technologies used:
+    - Haskell (currently GHC 8.6, soon GHC 8.8)
+      - stack + stackage-lts
+      - fixplate (recursion-schemes-implementation)
+      - many usual technologies like lens, http-simple, mtl, ..
+      - golden-testing via tasty
+      - several inhouse-developments:
+        - templating based on text-replacement via generics (fieldname in
+          Template-Type == variable replaced in template)
+        - activeMQ/Kibana-bridge for logging via hs-stomp
+        - generic internal logging-framework
+    - Python
+      - tensorflow
+      - pytorch
+      - sklearn
+      - nltk
+
+- **2013-2018**:
+  - several jobs at my University including
+    - Worked 6 Months in the Workgroup "Theoretical Computer Science" on migrating
+      algorithms to **CUDA**
+    - Tutor "Introduction to Machine Learning"
+      - Was awarded **Tutoring-Award** of the Faculty of Technology for excellent
+        tutoring
+    - Lecture "[[FFPiH|Intermediate Functional Programming in Haskell]]"
+      - Originally developed as student-project in cooperation with Jonas Betzendahl
+      - First held in Summer 2015
+      - Due to high demand held again in Summer 2016 and 2017
+      - Was awarded **Lecturer-Award** "silver Chalk" in 2016
+        - First time that this award was given to students
+        - Many lecturers at our faculty never get any teaching-award until retirement
+    - Development of Pandoc-Filters for effective **generation of lecture-slides**
+      for Mario Botsch (Leader "Workgroup Computer Graphics") using Pandoc & reveal.js
+      - Framework: [https://github.com/mbotsch/revealSlides](https://github.com/mbotsch/revealSlides)
+      - Example: [https://github.com/mbotsch/eLearning](https://github.com/mbotsch/eLearning)
+      - Pandoc-Filters: [https://github.com/mbotsch/pandoc-slide-filter](https://github.com/mbotsch/pandoc-slide-filter)

content/Android/Einrichtung.md

@@ -2,7 +2,7 @@
 categories: Android, Tutorial
 toc: yes
 title: Einrichtung Android-Smartphones
-...
+---
 
 Hier stelle ich meine Erfahrungen und die Einrichtung meines Smartphones vor. Keine Garantie auf Übertragbarkeit und Aktualität.
 
@@ -59,4 +59,4 @@ Hier kurz nützliche Apps und wofür diese da sind:
 
 Der letzte Schrei auf gerooteten Smartphones ist LMT: [YouTube-Demo](http://www.youtube.com/watch?v=oha8ijaD9dc).
 
-[Installations-Anleitung](http://pocketnow.com/2013/02/05/lmt-launcher-for-android)
+[Installations-Anleitung](http://pocketnow.com/2013/02/05/lmt-launcher-for-android)

content/Argumentation.md

@@ -1,19 +0,0 @@
----
-categories: Argumentation
-toc: yes
-title: Argumentation
-...
-
-Argumentation ist eine auf [Logik]() basierende form der Unterhaltung.
-
-Idealerweise zeigen beide Seiten (verschiedene oder über den Argumentationsverlauf angepasste) Folgerungen aus Initialbedingungen.
-
-Die einfachste Variante ist der Logische Schluss (=Implikation), also auf Deutsch: Wenn A gilt, muss B. **Wenn** es regnet, ist die Straße nass.
-
-Meistens geht es in einer Argumentation darum, dass man dem anderen seine Argumente aufweist (also die eigenen Vorbedingungen) und dann den Schluss zieht.
-Allerdings gibt es hier dann noch eine individuelle Gewichtung der Vorbedingungen. Was für den einen trivial sein kann (Fliegen, Aufzug fahren, Vorträge halten, ...), muss für den anderen nicht genauso gelten. Somit kann man aus den gleichen Eingangsbedingungen verschiedene Schlüsse ziehen. Allerdings wird derselbe Mensch bei selben Wissen dieselben Konsequenzen ziehen (Nachher ist man immer schlauer. Erfahrung braucht man meist kurz bevor man sie gemacht hat).
-
-Auch kann der Schluss individuell variieren, wenn Dritte betroffen sind. Wenn ich eine Geldbörse finde und diese zurückgebe, ist der Besitzer glücklich. Ob ich dann das Geld drin lasse oder für mich nehme ist dann eine Frage der Moral.
-Da sich aber Moral noch schlechter verallgemeinern lässt, halten wir sie in einer Argumentation erstmal heraus und lassen sie nur zur Entscheidung beitragen, wenn es aus den Ausgangsbedingungen überhaupt mehr als eine Möglichkeit gibt. Wenn es nämlich für ein gegebenes Problem x nur eine Lösung gibt und man dieses Problem lösen will, so muss man diesen Schluss ziehen.
-
-

content/Coding/Haskell.yaml

@@ -0,0 +1,3 @@
+template:
+  sidebar:
+    collapsed: true

content/Coding/Haskell/Advantages.md

@@ -1,4 +1,4 @@
-# Was ist das hier?  
+# Talks und Posts zu Haskell
 
 Gründe Haskell zu nutzen und wo Vorteile liegen.
 
@@ -7,12 +7,15 @@ Gründe Haskell zu nutzen und wo Vorteile liegen.
 ### Simon Peyton Jones
 
 - [The Future is parallel](https://www.youtube.com/watch?v=hlyQjK1qjw8)
-- [Lenses](https://skillsmatter.com/skillscasts/4251-lenses-compositional-data-access-and-manipulation) (registration nötig - kostenfrei)
+- [Lenses](https://skillsmatter.com/skillscasts/4251-lenses-compositional-data-access-and-manipulation)
+  (Registrierung nötig - kostenfrei), siehe auch: [[Lenses]]#
 
 ### Others
 
 - [Running a Startup on Haskell](https://www.youtube.com/watch?v=ZR3Jirqk6W8)
-- [We're doing it all wrong](https://www.youtube.com/watch?v=TS1lpKBMkgg) - A Long-Term Scala-Compiler-Developer quits his job after years and tells why Scala is a mess.
+- [We're doing it all wrong](https://www.youtube.com/watch?v=TS1lpKBMkgg) - A
+  Long-Term Scala-Compiler-Developer quits his job after years and tells why
+  Scala is a mess.
 - [Monads explained in Javascript](https://www.youtube.com/watch?v=b0EF0VTs9Dc)
 - [Vinyl Records](http://vimeo.com/95694918) with [Slides](https://github.com/VinylRecords/BayHac2014-Talk)
 - [Thinking with Laziness](http://begriffs.com/posts/2015-06-17-thinking-with-laziness.html)
@@ -25,15 +28,19 @@ Gründe Haskell zu nutzen und wo Vorteile liegen.
 - [Tackling the awkward squad](https://research.microsoft.com/en-us/um/people/simonpj/papers/marktoberdorf/)
 
 ### Others
+
 - [Parallel and Concurrent Programming in Haskell](http://chimera.labs.oreilly.com/books/1230000000929/pr01.html)
 - [Slides of a Quickcheck-Talk](http://scholar.google.de/scholar?cluster=7602244452224287116&hl=de&as_sdt=0,5)
-- [Understanding F-Algebras](https://www.fpcomplete.com/user/bartosz/understanding-algebras) - schöne Erklärung. Man könnte danach anfangen den Morphismen-zoo zu verstehen...
+- [Understanding F-Algebras](https://www.fpcomplete.com/user/bartosz/understanding-algebras)
+  schöne Erklärung. Man könnte danach anfangen den [[Morphisms|Morphismen-zoo]]#
+  zu verstehen...
 - [Monad Transformers](https://github.com/kqr/gists/blob/master/articles/gentle-introduction-monad-transformers.md)
 
 ## Funny Talks
 
 - [Tom LaGatta on Category-Theory](https://www.youtube.com/watch?v=o6L6XeNdd_k)
-- [Unifying Structured Recursion Schemes](https://www.youtube.com/watch?v=9EGYSb9vov8) aka. The Monad-Zoo
+- [Unifying Structured Recursion Schemes](https://www.youtube.com/watch?v=9EGYSb9vov8)
+  aka. [[Morphisms|The Morphism-Zoo]]
 - [Hole-Driven-Development Teaser (Enthusiasticon, raichoo)](https://www.youtube.com/watch?v=IRGKkiGG5CY)
 
 ## Unsorted/Unseen
@@ -46,4 +53,4 @@ Gründe Haskell zu nutzen und wo Vorteile liegen.
 ## Tutorials
 
 - [Haskell fast and hard](https://www.fpcomplete.com/school/starting-with-haskell/haskell-fast-hard/haskell-fast-hard-part-1)
-- [Counterexamples for Typeclasses](http://blog.functorial.com/posts/2015-12-06-Counterexamples.html)
+- [Counterexamples for Typeclasses](http://blog.functorial.com/posts/2015-12-06-Counterexamples.html)

content/Coding/Haskell/Code Snippets.md

@@ -0,0 +1,8 @@
+# Code-Snippets
+
+Hier schreiben wir ein paar Code-Highlights auf, die uns begegnet sind.
+
+```query
+path:./*
+```
+

content/Coding/Haskell/Code Snippets/Monoid.md

@@ -0,0 +1,165 @@
+# Monoid? Da war doch was...
+
+Stellen wir uns vor, dass wir eine Funktion schreiben, die einen String bekommt (mehrere Lines mit ACSII-Text) und dieses Wort-für-Wort rückwärts ausgeben soll. Das ist ein einfacher Einzeiler:
+
+~~~ { .haskell }
+module Main where
+
+import System.Environment (getArgs)
+import Data.Monoid (mconcat)
+import Data.Functor ((<$>))
+
+main = do
+    ls <- readFile =<< head <$> getArgs
+    mconcat <$> mapM (putStrLn . unwords . reverse . words) (lines ls) --die eigentliche Funktion, ls ist das argument.
+~~~~~~~~~~~~~~~~~~
+
+Was passiert hier an Vodoo? Und was machen die ganzen wilden Zeichen da?
+
+Gehen wir die Main zeilenweise durch:
+Wir lesen die Datei, die im ersten Kommandozeilen-Argument gegeben wird. getArgs hat folgende Signatur:
+
+```haskell
+getArgs :: IO [String]
+```
+
+Wir bekommen als eine Liste der Argumente. Wir wollen nur das erste. Also machen wir head getArgs. Allerdings fliegt uns dann ein Fehler. head sieht nämlich so aus:
+
+```haskell
+head :: [a] -> a
+```
+
+Irgendwie müssen wird as **in** das IO bekommen. Hierzu gibt es fmap. Somit ist
+
+```haskell
+fmap head :: IO [a] -> IO a
+```
+
+Ein inline-Alias (um die Funktion links und das Argument rechts zu schreiben und sich ne Menge Klammern zu sparen) ist <$>. Somit ist schlussendlich der Inhalt der Datei aus dem ersten Argument (lazy) in ls.
+
+Eine andere Möglichkeit sich das (in diesem Fall) zu merken, bzw. drauf zu kommen ist, dass [] AUCH ein Funktor (sogar eine Monade) ist. Man könnte das also auch so schreiben:
+
+```haskell
+head                ::              [] a      ->   a
+head                :: Functor f => [] (f a)     -> f a -- das "a" geschickt ersetzt zur Verdeutlichung
+getArgs             ::              IO [] String
+fmap head           :: Functor f => f  [] a      -> f a
+```
+
+fmap "packt" die Funktion quasi 1 Umgebung (Funktor, Monade, ..) weiter rein - Sei es nun in Maybe, Either oder irgendwas anderes.
+
+Alternatives (ausführliches) Beispiel am Ende.
+
+Wenn wir uns die Signatur ansehen, dann haben wir nun
+
+```haskell
+head <$> getArgs :: IO String
+```
+
+readFile will aber nun ein String haben. Man kann nun
+
+```haskell
+f  <- head <$> getArgs
+ls <- readFile f
+```
+
+kann man auch "inline" mit =<< die Sachen "auspacken".
+
+Die 2. Zeile lesen wir nun einfach "von hinten", wie man das meistens tun sollte. Hier ist ein
+
+```haskell
+lines ls :: [String]
+```
+
+was uns den Inhalt der Datei zeilenweise gibt. Mit jeder Zeile möchten wir nun folgendes machen:
+
+1. nach Wörtern trennen (words)
+2. Wörter in der reihenfolge umkehren (reverse)
+3. Wörter wider zu einer Zeile zusammensetzen (unwords)
+4. diese Zeile ausgeben (putStrLn)
+
+Wenn wir uns die Signatur ansehen:
+
+```haskell
+(putStrLn . unwords . reverse . words) :: String -> IO ()
+```
+
+Das mag im ersten Moment verwirren, daher noch die Signaturen der Einzelfunktionen:
+
+```haskell
+words    :: String -> [String]
+reverse  :: [a] -> [a]
+unwords  :: [String] -> String
+putStrLn :: String -> IO ()
+```
+
+Da wir am Ende in der IO-Monade landen müssen wir das auf unsere Zeilen mit mapM statt map anwenden. Dies sorgt auch dafür, dass die Liste der reihe nach durchgegangen wird. mapM mit unserer Funktion schaut dann so aus:
+
+```haskell
+mapM (putStrLn . unwords . reverse . words) :: [String] -> [IO ()]
+```
+
+eek! Das [IO ()] sieht ekelig aus. Wir haben eine Liste von IO-gar nichts. Das können wir eigentlich entsorgen. Da wir innerhalb der main-Funktion in einer IO-Monade sind, wollen wir IO () anstatt [IO ()] zurück haben.
+
+Wenn wir uns jetzt erinnern, dass [] auch nur eine Monade ist und dass jede Monade ein Monoid ist, dann ist die Lösung einfach. Monoide haben eine "append"-funktion (mappend oder (<>) genannt). Wenn wir "nichts" an "nichts" anhängen, dann erhalten wir .... *Trommelwirbel* "nichts"! Wir müssen die [IO ()]-Liste also "nur noch" mit mappend falten. Hierzu gibt es schon eine vorgefertigte Funktion:
+
+```haskell
+mconcat :: [a] -> a
+mconcat = foldr mappend mempty
+```
+
+Was genau die gewünschte Faltung macht. Wir müssen nun wieder fmap nehmen, da wir die Liste selbst falten wollen - und nicht map, welches auf den IO () innerhalb der Liste arbeiten würde. Durch die Faltung fällt die Liste nun auf IO () zusammen.
+
+Viel Voodoo in wenig Code, aber wenn man sich dran gewöhnt hat, sind Monaden in Monaden auch nicht schlimm. Man muss sich immer nur richtig "rein" fmap'en.
+
+---
+
+Kleinen Tipp gab es noch: mapM_ macht genau das, was oben mit mconcat erreicht werden sollte. Somit kann man auch
+
+```haskell
+mapM_ (putStrLn . unwords . reverse . words) (lines ls)
+```
+
+schreiben. Ich hab es aber mal wegen der klarheit oben so gelassen.
+
+## Alternatives fmap-Beispiel
+
+Nehmen wir als alternatives Beispiel mal an:
+
+```haskell
+a :: IO Maybe State t
+```
+
+Um Funktionen vom Typ
+
+```haskell
+f :: IO a -> IO a
+f a             -- valide
+```
+
+zu nehmen, brauchen wir nichts machen. Bei
+
+```haskell
+f' :: Maybe a -> Maybe a
+```
+
+brauchen wir 1 fmap, also ein
+
+```haskell
+f' a            -- error
+f' <$> a
+```
+
+um eine Funktion
+
+```haskell
+f'' :: State t -> State t
+```
+
+zu benutzen folglich:
+
+```haskell
+f'' a           -- error
+f'' <$> a       -- error
+fmap f'' <$> a
+```

content/Coding/Haskell/Code Snippets/Morphisms.md

@@ -0,0 +1,264 @@
+# *-Morpisms
+
+**Backup eines Blogposts eines Kommilitonen:**
+
+This weekend I spend some time on Morphisms.
+
+Knowing that this might sound daunting to many
+dabbling Haskellers (like I am), I decided to
+write a real short MergeSort hylomorphism quickstarter.
+
+----------------------------------------------------------
+
+For those who need a refresher: MergeSort works by creating
+a balanced binary tree from the input list and directly
+collapsing it back into itself while treating the children
+as sorted lists and merging these with an O(n) algorithm.
+
+----------------------------------------------------------
+
+First the usual prelude:
+
+```haskell
+{-# LANGUAGE DeriveFunctor #-}
+{-# LANGUAGE TypeFamilies #-}
+
+import Data.Functor.Foldable 
+import Data.List (splitAt, unfoldr)
+```
+
+----------------------------------------------------------
+
+We will use a binary tree like this. Note that
+there is no explicit recursion used, but `NodeF` has
+two *holes*. These will eventually filled later.
+
+```haskell
+data TreeF c f = EmptyF | LeafF c | NodeF f f
+  deriving (Eq, Show, Functor)
+```
+
+----------------------------------------------------------
+
+Aside: We could use this as a *normal* binary tree by
+wrapping it in `Fix`: `type Tree a = Fix (TreeF a)`
+But this would require us to write our tree like
+`Fix (NodeF (Fix (LeafF 'l')) (Fix (LeafF 'r')))`
+which would get tedious fast. Luckily Edward build
+a much better way to do this into *recursion-schemes*.
+I will touch on this later.
+
+----------------------------------------------------------
+
+Without further ado we start to write a Coalgebra,
+which in my book is just a scary name for
+"function that is used to construct datastructures".
+
+```haskell
+unflatten :: [a] -> TreeF a [a]
+unflatten (  []) = EmptyF
+unflatten (x:[]) = LeafF x
+unflatten (  xs) = NodeF l r   where (l,r) = splitAt (length xs `div` 2) xs
+```
+
+From the type signature it's immediately obvious,
+that we take a list of 'a's and use it to create
+a part of our tree.
+
+The nice thing is that due to the fact that we
+haven't commited to a type in our tree nodes
+we can just put lists in there.
+
+----------------------------------------------------------
+
+Aside: At this point we could use this Coalgebra to
+construct (unsorted) binary trees from lists:
+
+```haskell
+example1 = ana unflatten [1,3] == Fix (NodeF (Fix (LeafF 1)) (Fix (LeafF 3)))
+```
+
+----------------------------------------------------------
+
+On to our sorting, tree-collapsing Algebra.
+Which again is just a creepy word for
+"function that is used to deconstruct datastructures".
+
+The function `mergeList` is defined below and
+just merges two sorted lists into one sorted list
+in O(n), I would probably take this from the `ordlist`
+package if I were to implement this *for real*.
+
+Again we see that we can just construct our
+sorted output list from a `TreeF` that
+apparently contains just lists.
+
+```haskell
+flatten :: Ord a => TreeF a [a] -> [a]
+flatten EmptyF      = []
+flatten (LeafF c)   = [c]
+flatten (NodeF l r) = mergeLists l r 
+```
+
+----------------------------------------------------------
+
+Aside: We could use a Coalgebra to deconstruct trees:
+
+```haskell
+example2 = cata flatten (Fix (NodeF (Fix (LeafF 3)) (Fix (LeafF 1)))) == [1,3]
+```
+
+----------------------------------------------------------
+
+Now we just combine the Coalgebra and the Algebra
+with one from the functions from Edwards `recursion-schemes`
+library:
+
+```haskell
+mergeSort :: Ord a => [a] -> [a]
+mergeSort = hylo flatten unflatten
+
+example3 = mergeSort [5,2,7,9,1,4] == [1,2,4,5,7,9] 
+```
+
+----------------------------------------------------------
+
+What have we gained?
+
+We have implemented a MergeSort variant in 9 lines of
+code, not counting the `mergeLists` function below.
+Not bad, but [this implementation](http://en.literateprograms.org/Merge_sort_(Haskell))
+is not much longer.
+
+On the other hand the morphism based implementation
+cleanly describes what happens during construction
+and deconstruction of our intermediate structure.
+
+My guess is that, as soon as the algortihms get more
+complex, this will really make a difference.
+
+----------------------------------------------------------
+
+At this point I wasn't sure if this was useful or
+remotely applicable. Telling someone "I spend a
+whole weekend learning about Hylomorphism" isn't
+something the cool developer kids do.
+
+It appeared to me that maybe I should have a look
+at the Core to see what the compiler finally comes
+up with (edited for brevity):
+
+```haskell
+    mergeSort :: [Integer] -> [Integer]
+    mergeSort =
+      \ (x :: [Integer]) ->
+        case x of wild {
+          [] -> [];
+          : x1 ds ->
+            case ds of _ {
+              [] -> : x1 ([]);
+              : ipv ipv1 ->
+                unfoldr
+                  lvl9
+                  (let {
+                     p :: ([Integer], [Integer])
+                     p =
+                       case $wlenAcc wild 0 of ww { __DEFAULT ->
+                       case divInt# ww 2 of ww4 { __DEFAULT ->
+                       case tagToEnum# (<# ww4 0) of _ {
+                         False ->
+                           case $wsplitAt# ww4 wild of _ { (# ww2, ww3 #) -> (ww2, ww3) };
+                         True -> ([], wild)
+                       }
+                       }
+                       } } in
+                   (case p of _ { (x2, ds1) -> mergeSort x2 },
+                    case p of _ { (ds1,  y) -> mergeSort y  }))
+            }
+        }
+    end Rec }
+```
+
+While I am not really competent in reading Core and
+this is actually the first time I bothered to try,
+it is immediately obvious that there is no trace
+of any intermediate tree structure.
+
+This is when it struck me. I was dazzled and amazed.
+And am still. Although we are writing our algorithm
+as if we are working on a real tree structure the
+library and the compiler are able to just remove
+the whole intermediate step.
+
+----------------------------------------------------------
+
+Aftermath:
+
+In the beginning I promised a way to work on
+non-functor data structures. Actually that
+was how I began to work with the `recursion-schemes`
+library.
+
+We are able to create a 'normal' version of our tree
+from above:
+
+```haskell
+data Tree c = Empty | Leaf c | Node (Tree c) (Tree c)
+  deriving (Eq, Show)
+```
+
+But we can not use this directly with our (Co-)Algebras.
+Luckily Edward build a little bit of type magic into
+the library:
+
+```haskell
+type instance Base (Tree c) = (TreeF c)
+
+instance Unfoldable (Tree c) where
+  embed EmptyF      = Empty
+  embed (LeafF c)   = Leaf c
+  embed (NodeF l r) = Node l r
+
+instance Foldable (Tree c) where
+  project Empty      = EmptyF
+  project (Leaf c)   = LeafF c
+  project (Node l r) = NodeF l r
+```
+
+Without going into detail by doing this we establish
+a relationship between `Tree` and `TreeF` and teach
+the compiler how to translate between these types.
+
+Now we can use our Alebra on our non functor type:
+
+```haskell
+example4 = cata flatten (Node (Leaf 'l') (Leaf 'r')) == "lr"
+```
+
+The great thing about this is that, looking at the
+Core output again, there is no traces of the `TreeF`
+structure to be found. As far as I can tell, the
+algorithm is working directly on our `Tree` type.
+
+----------------------------------------------------------
+
+Literature:
+
+- [Understanding F-Algebras](https://www.fpcomplete.com/user/bartosz/understanding-algebras)
+- [Recursion Schemes by Example](http://www.timphilipwilliams.com/slides.html)
+- [Recursion Schemes: A Field Guide](http://comonad.com/reader/2009/recursion-schemes/)
+- [This StackOverflow question](http://stackoverflow.com/questions/6941904/recursion-schemes-for-dummies)
+
+----------------------------------------------------------
+
+Appendix:
+
+```haskell
+mergeLists :: Ord a => [a] -> [a] -> [a]
+mergeLists = curry $ unfoldr c where
+  c ([], [])     = Nothing
+  c ([], y:ys)   = Just (y, ([], ys))
+  c (x:xs, [])   = Just (x, (xs, []))
+  c (x:xs, y:ys) | x <= y = Just (x, (xs, y:ys)) 
+                 | x > y  = Just (y, (x:xs, ys))
+```

content/Coding/Haskell/FFPiH.md

@@ -0,0 +1,66 @@
+# Fortgeschrittene funktionale Programmierung in Haskell
+
+FFPiH ist eine Vorlesung, die ich zusammen mit einem Kommilitonen im Sommer 2015
+erstmals erstellt und gehalten haben.
+
+Insgesamt haben wir die Vorlesung 3x gehalten, wobei von der ersten zur zweiten
+Iteration der Inhalt massiv überarbeitet wurde und bei der Iteration von der
+zweiten zur dritten Vorlesung die Übungen komplett neu erstellt wurden.
+
+Die gesamten Übungen sind unter anderem in der FFPiH-Organisation in meinem
+gitea hinterlegt:
+[https://gitea.dresselhaus.cloud/FFPiH](https://gitea.dresselhaus.cloud/FFPiH)
+
+Einige der aktualisierten Übungen sind privat geschaltet, da diese iterativ
+aufeinander aufbauen und jeweils die Musterlösung der vorherigen enthalten.
+
+## Aufbau der Vorlesung
+
+Vorausgesetzt wurde, dass die Studierenden das erste Semester abgeschlossen
+hatten und somit bereits leichte Grundlagen in Haskell kannten (aber z.b. Dinge
+wie Functor/Applicative/Monad noch nicht *wirklich* erklärt bekommen haben).
+
+Stück für Stück werden die Studis dann zunächst in abstrakte Konstrukte
+eingeführt, aber diese werden dann schnell in die Praxis umgesetzt. Etwa mit dem
+Schreiben eines eigenen Parsers.
+
+Schlussendlich gibt es dann einen "Rundumschlag" durch die gesamte Informatik.
+Erstellung eines Spieles (auf basis einer kleinen Grundlage), erstellung von
+WebApps mit Yesod, Parallelisierung und Nebenläufigkeit für rechenintensive
+Anwendungen inkl. synchronisation mittels STM.
+
+Optional gab es weitere Übungen zu dingen wie "verteiltes Rechnen".
+
+Ziel hierbei war nicht, diese ganzen Themen in der Tiefe beizubringen, sondern
+aufzuzeigen, wie sie sehr schnell abstrakte Konstrukte, die ihnen ggf. 3 Semester
+später erst begegnen bugfrei benutzen können, da Haskell hier in sehr vielen
+Fällen einfach nur die "richtige" Lösung kompilieren lässt und alle gängigen
+Fallen schlicht ausschließt. Beispiel ist z.b. STM innerhalb von STM, Mischen
+von DB-Monade, Handler-Monade und Template-Engine in Yesod, Process () statt IO
+() in der Nutzung von CloudHaskell, etc. pp.
+
+## Studentisches Feedback
+
+Sehr gutes Feedback von den Studenten bekamen wir insbesondere für Übungen wie:
+
+[Übung 2, Aufgabe 2](https://gitea.dresselhaus.cloud/FFPiH/uebung2017_2/src/branch/master/src/Aufgabe2.hs),
+weil hier durch "einfaches" umformen hin zu Abstraktionen und mit den Regeln dieser
+im ersten Fall die Laufzeit (vor Compileroptimierungen) von O(n²) auf O(0) ändert.
+
+[Übung 4](https://gitea.dresselhaus.cloud/FFPiH/uebung2017-4), welche ein
+komplett fertigen (sehr rudimentären und simplen) Dungeon-Crawler bereitstellt,
+der "nur" 1-2 bugs hat und "wie ein echtes Projekt" erweitert werden muss.
+Diese Übung hat sich dann über 4 weitere Übungen gestreckt, wobei folgende
+Aufgaben gelöst werden müssen:
+
+- Einarbeitung in QuickCheck zur Behebung eines Bugs im Test
+- Umschreiben von explizitem Argument-Passing hin zu Monad-Transformers mit
+  stateful [[Lenses|lenses]]#
+- Continuation-Basierendes Event-System
+- Hinzufügen eines Parsers für Level, Items & deren Effekte und
+  implementation dieser
+- Ändern des GUI-Parts von CLI auf 2D GL mittels gloss
+- Ändern von `StateT World` auf `RWST GameConfig Log World` und somit nutzen von
+  individuellen Konfigurationen für z.b. Keybindings
+
+

content/Coding/Haskell/Lenses.md

@@ -1,10 +1,14 @@
-# Wozu brauchen wir das Überhaupt?  
+# Lenses
 
-Die Idee dahinter ist, dass man Zugriffsabstraktionen über Daten verknüpfen kann. Als einfachen Datenstruktur kann man einen Record mit der entsprechenden Syntax nehmen.
+## Wofür brauchen wir das überhaupt?
 
-## Beispiel
+Die Idee dahinter ist, dass man Zugriffsabstraktionen über Daten verknüpfen
+kann. Als einfachen Datenstruktur kann man einen Record mit der entsprechenden
+Syntax nehmen.
 
-~~~ { .haskell .numberLines }
+### Beispiel
+
+~~~ { .haskell }
 data Person = P { name :: String
                 , addr :: Address
                 , salary :: Int }
@@ -22,19 +26,19 @@ data Address = A { road :: String
     -- update of a record inside a record
 ~~~~~~~~~~~~~~~~~~
 
-## Probleme
+### Probleme
 
 Probleme mit diesem Code:
 
 - für 1-Dimensionale Felder ist die record-syntax ok.
 - tiefere Ebenen nur umständlich zu erreichen
 - eigentlich wollen wir nur pe in p setzen, müssen aber über addr etc. gehen.
-- wir brauchen wissen über die "Zwischenstrukturen", an denen wir nicht interessiert sind
+- wir brauchen wissen über die "Zwischenstrukturen", an denen wir nicht
+  interessiert sind
 
+### Was wir gern hätten
 
-## Was wir gern hätten
-
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 data Person = P { name :: String
                 , addr :: Address
                 , salary :: Int }
@@ -49,11 +53,11 @@ set     :: Lens' s a -> a -> s -> s
 composeL :: Lens' s1 s2 -> Lens s2 a -> Lens' s1 a
 ~~~~~~~~~~~~~~~~~~
 
-## Wie uns das hilft
+### Wie uns das hilft
 
 Mit diesen Dingen (wenn wir sie hätten) könnte man dann
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 data Person = P { name :: String
                 , addr :: Address
                 , salary :: Int }
@@ -67,11 +71,11 @@ setPostcode pc p
 
 machen und wäre fertig.
 
-# Trivialer Ansatz
+## Trivialer Ansatz
 
-## Getter/Setter als Lens-Methoden
+### Getter/Setter als Lens-Methoden
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 data LensR s a = L { viewR :: s -> a
                    , setR  :: a -> s -> s }
 
@@ -80,36 +84,36 @@ composeL (L v1 u1) (L v2 u2)
       (\a s -> u1 (u2 a (v1 s)) s)
 ~~~~~~~~~~~~~~~~~~
 
-## Wieso ist das schlecht?
+### Wieso ist das schlecht?
 
--   extrem ineffizient
+- extrem ineffizient
 
-    Auslesen traversiert die Datenstruktur, dann wird die Funktion angewendet und zum setzen wird die Datenstruktur erneut traversiert:
-    
-    ~~~ { .haskell .numberLines }
-    over :: LensR s a -> (a -> a) -> s -> s
-    over ln f s = setR l (f (viewR l s)) s
-    ~~~~~~~~~~~~~~~~~~
-    
+Auslesen traversiert die Datenstruktur, dann wird die Funktion angewendet und
+zum setzen wird die Datenstruktur erneut traversiert:
 
--   Lösung: modify-funktion hinzufügen
-    
-    ~~~ { .haskell .numberLines }
-    data LensR s a
-       = L { viewR :: s -> a
-           , setR  :: a -> s -> s
-           , mod   :: (a->a) -> s -> s
-           , modM  :: (a->Maybe a) -> s -> Maybe s
-           , modIO :: (a->IO a) -> s -> IO s }
-    ~~~~~~~~~~~~~~~~~~
-    
-    Neues Problem: Für jeden Spezialfall muss die Lens erweitert werden.
+~~~ { .haskell }
+over :: LensR s a -> (a -> a) -> s -> s
+over ln f s = setR l (f (viewR l s)) s
+~~~~~~~~~~~~~~~~~~
 
-## Something in common
+- Lösung: modify-funktion hinzufügen
+
+~~~ { .haskell }
+data LensR s a
+   = L { viewR :: s -> a
+       , setR  :: a -> s -> s
+       , mod   :: (a->a) -> s -> s
+       , modM  :: (a->Maybe a) -> s -> Maybe s
+       , modIO :: (a->IO a) -> s -> IO s }
+~~~~~~~~~~~~~~~~~~
+
+Neues Problem: Für jeden Spezialfall muss die Lens erweitert werden.
+
+### Something in common
 
 Man kann alle Monaden abstrahieren. Functor reicht schon:
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 data LensR s a
    = L { viewR :: s -> a
        , setR  :: a -> s -> s
@@ -119,32 +123,38 @@ data LensR s a
 
 Idee: Die 3 darüberliegenden durch modF ausdrücken.
 
-## Typ einer Lens
+### Typ einer Lens
 
 Wenn man das berücksichtigt, dann hat einen Lens folgenden Typ:
 
-> type Lens' s a = forall f. Functor f
->                            => (a -> f a) -> s -> f s
+~~~ {.haskell}
+type Lens' s a = forall f. Functor f
+                           => (a -> f a) -> s -> f s
+~~~
 
 Allerdings haben wir dann noch unseren getter/setter:
 
-> data LensR s a = L { viewR :: s -> a
->                    , setR :: a -> s -> s }
+~~~ {.haskell}
+data LensR s a = L { viewR :: s -> a
+                   , setR :: a -> s -> s }
+~~~
 
-Stellt sich raus: Die sind isomorph! Auch wenn die von den Typen her komplett anders aussehen.
+Stellt sich raus: Die sind isomorph! Auch wenn die von den Typen her komplett
+anders aussehen.
 
-# Benutzen einer Lens als Setter
+## Benutzen einer Lens als Setter
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 set :: Lens' s a -> (a -> s -> s)
 set ln a s = --...umm...
 --:t ln => (a -> f a) -> s -> f s
 --            => get s out of f s to return it
 ~~~~~~
 
-Wir können für f einfach die "Identity"-Monade nehmen, die wir nachher wegcasten können.
+Wir können für f einfach die "Identity"-Monade nehmen, die wir nachher wegcasten
+können.
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 newtype Identity a = Identity a
 -- Id :: a -> Identity a
 
@@ -157,7 +167,7 @@ instance Functor Identity where
 
 somit ist set einfach nur
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 set :: Lens' s a -> (a -> s -> s)
 set ln x s
    = runIdentity (ls set_fld s)
@@ -170,19 +180,24 @@ set ln x s
 
 oder kürzer (für nerds wie den Autor der Lens-Lib)
 
-> set :: Lens' s a -> (a -> s -> s)
-> set ln x = runIdentity . ln (Identity . const x)
+~~~ {.haskell }
+set :: Lens' s a -> (a -> s -> s)
+set ln x = runIdentity . ln (Identity . const x)
+~~~
 
-# Benutzen einer Lens als Modify
+## Benutzen einer Lens als Modify
 
-Dasselbe wie Set, nur dass wir den Parameter nicht entsorgen, sondern in die mitgelieferte Funktion stopfen.
+Dasselbe wie Set, nur dass wir den Parameter nicht entsorgen, sondern in die
+mitgelieferte Funktion stopfen.
 
-> over :: Lens' s a -> (a -> a) -> s -> s
-> over ln f = runIdentity . ln (Identity . f)
+~~~ {.haskell}
+over :: Lens' s a -> (a -> a) -> s -> s
+over ln f = runIdentity . ln (Identity . f)
+~~~
 
-# Benutzen einer Lens als Getter
+## Benutzen einer Lens als Getter
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 view :: Lens' s a -> (s -> a)
 view ln s = --...umm...
 --:t ln => (a -> f a) -> s -> f s
@@ -190,9 +205,10 @@ view ln s = --...umm...
 --            Wait, WHAT?
 ~~~~~~
 
-Auch hier gibt es einen netten Funktor. Wir packen das "a" einfach in das "f" und werfen das "s" am Ende weg.
+Auch hier gibt es einen netten Funktor. Wir packen das "a" einfach in das "f"
+und werfen das "s" am Ende weg.
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 newtype Const v a = Const v
 
 getConst :: Const v a -> v
@@ -205,7 +221,7 @@ instance Functor (Const v) where
 
 somit ergibt sich
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 view :: Lens' s a -> (s -> a)
 view ln s 
   = getConst (ln Const s)
@@ -214,19 +230,23 @@ view ln s
 
 oder nerdig
 
-> view :: Lens' s a -> (s -> a)
-> view ln = getConst . ln Const
+~~~ {.haskell}
+view :: Lens' s a -> (s -> a)
+view ln = getConst . ln Const
+~~~
 
-# Lenses bauen
+## Lenses bauen
 
 Nochmal kurz der Typ:
 
-> type Lens' s a = forall f. Functor f
->                      => (a -> f a) -> s -> f s
+~~~ {.haskell}
+type Lens' s a = forall f. Functor f
+                     => (a -> f a) -> s -> f s
+~~~
 
 Für unser Personen-Beispiel vom Anfang:
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 data Person = P { _name :: String, _salary :: Int }
 
 name :: Lens' Person String
@@ -242,13 +262,15 @@ name elt_fn (P n s)
 
 Die Lambda-Funktion ersetzt einfach den Namen. Häufig sieht man auch
 
-> name elt_fn (P n s)
->   = (\n' -> P n' s) <$> (elt_fn n)
-> --  |    Focus    |     |Function|
+~~~ {.haskell}
+name elt_fn (P n s)
+  = (\n' -> P n' s) <$> (elt_fn n)
+--  |    Focus    |     |Function|
+~~~
 
-# Wie funktioniert das intern?
+## Wie funktioniert das intern?
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 view name (P {_name="Fred", _salary=100})
    -- inline view-function
 = getConst (name Const (P {_name="Fred", _salary=100})
@@ -260,11 +282,13 @@ view name (P {_name="Fred", _salary=100})
 = "Fred"
 ~~~~~~
 
-Dieser Aufruf hat KEINE Runtime-Kosten, weil der Compiler direkt die Adresse des Feldes einsetzen kann. Der gesamte Boilerplate-Code wird vom Compiler wegoptimiert.
+Dieser Aufruf hat KEINE Runtime-Kosten, weil der Compiler direkt die Adresse des
+Feldes einsetzen kann. Der gesamte Boilerplate-Code wird vom Compiler
+wegoptimiert.
 
 Dies gilt für jeden Funktor mit newtype, da das nur ein Typalias ist.
 
-# Composing Lenses und deren Benutzung
+## Composing Lenses und deren Benutzung
 
 Wie sehen denn die Typen aus?
 
@@ -284,11 +308,11 @@ wenn man scharf hinsieht, kann man die verbinden
 und erhält eine Lens. Sogar die Gewünschte!  
 Somit ist Lens-Composition einfach nur Function-Composition (.).
 
-# Automatisieren mit Template-Haskell
+## Automatisieren mit Template-Haskell
 
 Der Code um die Lenses zu bauen ist für records immer Identisch:
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 data Person = P { _name :: String, _salary :: Int }
 
 name :: Lens' Person String
@@ -297,7 +321,7 @@ name elt_fn (P n s) = (\n' -> P n' s) <$> (elt_fn n)
 
 Daher kann man einfach
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 import Control.Lens.TH
 data Person = P { _name :: String, _salary :: Int }
 
@@ -305,12 +329,14 @@ $(makeLenses ''Person)
 ~~~~~~
 
 nehmen, was einem eine Lens für "name" und eine Lens für "salary" generiert.  
-Mit anderen Templates kann man auch weitere Dinge steuern (etwa wofür Lenses generiert werden, welches Prefix (statt _) man haben will etc. pp.).  
+Mit anderen Templates kann man auch weitere Dinge steuern (etwa wofür Lenses
+generiert werden, welches Prefix (statt \_) man haben will etc. pp.).  
+
 Will man das aber haben, muss man selbst in den Control.Lens.TH-Code schauen.
 
-# Lenses für den Beispielcode
+## Lenses für den Beispielcode
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 import Control.Lens.TH
 
 data Person = P { _name :: String
@@ -327,9 +353,9 @@ setPostcode :: String -> Person -> Person
 setPostcode pc p = set (addr . postcode) pc p
 ~~~~~~~~~~~~~~~~~~
 
-# Shortcuts mit "Line-Noise"
+## Shortcuts mit "Line-Noise"
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 -- ...
 
 setPostcode :: String -> Person -> Person
@@ -341,13 +367,15 @@ getPostcode p = p   ^. $ addr . postcode
 --            |from|get|    Focus       |
 ~~~~~~~~~~~~~~~~~~
 
-Es gibt drölf-zillionen weitere Infix-Operatoren (für Folds, Listenkonvertierungen, -traversierungen, ...)
+Es gibt drölf-zillionen weitere Infix-Operatoren (für Folds,
+Listenkonvertierungen, -traversierungen, ...)
 
-# Virtuelle Felder
+## Virtuelle Felder
 
-Man kann mit Lenses sogar Felder emulieren, die gar nicht da sind. Angenommen folgender Code:
+Man kann mit Lenses sogar Felder emulieren, die gar nicht da sind. Angenommen
+folgender Code:
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 data Temp = T { _fahrenheit :: Float }
 
 $(makeLenses ''Temp)
@@ -360,14 +388,18 @@ centigrade centi_fn (T faren)
 -- cToF & fToC as Converter-Functions defined someplace else
 ~~~~~~~~~~~~~~~~~~
 
-Hiermit kann man dann auch Funktionen, die auf Grad-Celsius rechnen auf Daten anwenden, die eigenlich nur Fahrenheit speichern, aber eine Umrechnung bereitstellen.  
-Analog kann man auch einen Zeit-Datentypen definieren, der intern mit Sekunden rechnet (und somit garantiert frei von Fehlern wie -3 Minuten oder 37 Stunden ist)
+Hiermit kann man dann auch Funktionen, die auf Grad-Celsius rechnen auf Daten
+anwenden, die eigenlich nur Fahrenheit speichern, aber eine Umrechnung
+bereitstellen.  Analog kann man auch einen Zeit-Datentypen definieren, der
+intern mit Sekunden rechnet (und somit garantiert frei von Fehlern wie -3
+Minuten oder 37 Stunden ist)
 
-# Non-Record Strukturen
+## Non-Record Strukturen
 
-Das ganze kann man auch parametrisieren und auf Non-Record-Strukturen anwenden. Beispielhaft an einer Map verdeutlicht:
+Das ganze kann man auch parametrisieren und auf Non-Record-Strukturen anwenden.
+Beispielhaft an einer Map verdeutlicht:
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 -- from Data.Lens.At
 at :: Ord k => k -> Lens' (Map k v) (Maybe v)
 
@@ -388,35 +420,39 @@ at k mb_fn m
 -- mb_fn :: Maybe v -> f Maybe v
 ~~~~~~~~~~~~~~~~~~
 
-# Weitere Beispiele
+## Weitere Beispiele
 
--   Bitfields auf Strukturen die Bits haben (Ints, ...) in Data.Bits.Lens
--   Web-scraper in Package hexpat-lens  
-    
-    ~~~ { .haskell .numberLines }
-    p ^.. _HTML' . to allNodes
-                 . traverse . named "a"
-                 . traverse . ix "href"
-                 . filtered isLocal
-                 . to trimSpaces
-    ~~~~~~~~~~~~~~~~~~
-    
-    Zieht alle externen Links aus dem gegebenen HTML-Code in p um weitere ziele fürs crawlen zu finden.
+- Bitfields auf Strukturen die Bits haben (Ints, ...) in Data.Bits.Lens
+- Web-scraper in Package hexpat-lens  
 
-# Erweiterungen
+  ~~~ { .haskell }
+  p ^.. _HTML' . to allNodes
+               . traverse . named "a"
+               . traverse . ix "href"
+               . filtered isLocal
+               . to trimSpaces
+  ~~~~~~~~~~~~~~~~~~
 
-Bisher hatten wir Lenses nur auf Funktoren F. Die nächstmächtigere Klasse ist Applicative.
+  Zieht alle externen Links aus dem gegebenen HTML-Code in p um weitere ziele
+  fürs crawlen zu finden.
 
-~~~ { .haskell .numberLines }
+## Erweiterungen
+
+Bisher hatten wir Lenses nur auf Funktoren F. Die nächstmächtigere Klasse ist
+Applicative.
+
+~~~ { .haskell }
 type Traversal' s a = forall f. Applicative f
                              => (a -> f a) -> (s -> f s)
 ~~~~~~~~~~~~~~~~~~
 
-Da wir den Container identisch lassen (weder s noch a wurde angefasst) muss sich etwas anderes ändern. Statt eines einzelnen Focus erhalten wir viele Foci.
+Da wir den Container identisch lassen (weder s noch a wurde angefasst) muss sich
+etwas anderes ändern. Statt eines einzelnen Focus erhalten wir viele Foci.
 
-Was ist ein Applicative überhaupt? Eine schwächere Monade (nur 1x Anwendung und kein Bind - dafür kann man die beliebig oft hintereinanderhängen).
+Was ist ein Applicative überhaupt? Eine schwächere Monade (nur 1x Anwendung und
+kein Bind - dafür kann man die beliebig oft hintereinanderhängen).
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 class Functor f => Applicative f where
   pure  :: a -> f a
   (<*>) :: f (a -> b) -> f a -> f b
@@ -428,7 +464,7 @@ mf <*> mx = do { f <- mf; x <- mx; return (f x) }
 
 Recap: Was macht eine Lens:
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 data Adress = A { _road :: String
                 , _city :: String
                 , _postcode :: String }
@@ -440,17 +476,18 @@ road elt_fn (A r c p) = (\r' -> A r' c p) <$> (elt_fn r)
 
 Wenn man nun road & city gleichzeitig bearbeiten will:
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 addr_strs :: Traversal' Address String
 addr_strs elt_fn (A r c p)
   = ... (\r' c' -> A r' c' p)    .. (elt_fn r) .. (elt_fn c) ..
 --      | function with 2 "Holes"|  first Thing |  second Thing
 ~~~~~~~~~~~~~~~~~~
 
-fmap kann nur 1 Loch stopfen, aber nicht mit n Löchern umgehen. Applicative mit <*> kann das.  
+fmap kann nur 1 Loch stopfen, aber nicht mit n Löchern umgehen. Applicative mit
+<*> kann das.  
 Somit gibt sich
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 addr_strs :: Traversal' Address String
 addr_strs elt_fn (A r c p)
   = pure           (\r' c' -> A r' c' p)  <*> (elt_fn r) <*> (elt_fn c)
@@ -464,43 +501,57 @@ addr_strs elt_fn (A r c p)
 
 Wie würd eine modify-funktion aussehen?
 
-> over :: Lens' s a -> (a -> a) -> s -> s
-> over ln f = runIdentity . ln (Identity . f)
+~~~ {.haskell}
+over :: Lens' s a -> (a -> a) -> s -> s
+over ln f = runIdentity . ln (Identity . f)
 
-> over :: Traversal' s a -> (a -> a) -> s -> s
-> over ln f = runIdentity . ln (Identity . f)
+over :: Traversal' s a -> (a -> a) -> s -> s
+over ln f = runIdentity . ln (Identity . f)
+~~~
 
-Der Code ist derselbe - nur der Typ ist generischer. Auch die anderen Dinge funktioniert diese Erweiterung (für Identity und Const muss man noch ein paar dummy-Instanzen schreiben um sie von Functor auf Applicative oder Monad zu heben - konkret reicht hier die Instanzierung von Monoid). In der Lens-Library ist daher meist Monad m statt Functor f gefordert.
+Der Code ist derselbe - nur der Typ ist generischer. Auch die anderen Dinge
+funktioniert diese Erweiterung (für Identity und Const muss man noch ein paar
+dummy-Instanzen schreiben um sie von Functor auf Applicative oder Monad zu heben
+- konkret reicht hier die Instanzierung von Monoid). In der Lens-Library ist
+  daher meist Monad m statt Functor f gefordert.
 
-# Wozu dienen die Erweiterungen?
+## Wozu dienen die Erweiterungen?
 
-Man kann mit Foci sehr selektiv vorgehen. Auch kann man diese durch Funktionen steuern. Beispisweise eine Funktion anwenden auf
+Man kann mit Foci sehr selektiv vorgehen. Auch kann man diese durch Funktionen
+steuern. Beispisweise eine Funktion anwenden auf
 
 - Jedes 2. Listenelement
 - Alle graden Elemente in einem Baum
 - Alle Namen in einer Tabelle, deren Gehalt > 10.000€ ist
 
-Traversals und Lenses kann man trivial kombinieren (lens . lens => lens, lens . traversal => traversal etc.)
+Traversals und Lenses kann man trivial kombinieren (`lens . lens` => `lens`,
+`lens . traversal` => `traversal` etc.)
 
-# Wie es in Lens wirklich aussieht
+## Wie es in Lens wirklich aussieht
 
-In diesem Artikel wurde nur auf Monomorphic Lenses eingegangen. In der richtigen Library ist eine Lens
+In diesem Artikel wurde nur auf Monomorphic Lenses eingegangen. In der richtigen
+Library ist eine Lens
 
-> type Lens' s a = Lens s s a a
-> type Lens s t a b = forall f. Functor f => (a -> f b) -> (s -> f t)
+~~~ {.haskell}
+type Lens' s a = Lens s s a a
+type Lens s t a b = forall f. Functor f => (a -> f b) -> (s -> f t)
+~~~
 
-sodass sich auch die Typen ändern können um z.B. automatisch einen Konvertierten (sicheren) Typen aus einer unsicheren Datenstruktur zu geben.
+sodass sich auch die Typen ändern können um z.B. automatisch einen Konvertierten
+(sicheren) Typen aus einer unsicheren Datenstruktur zu geben.
 
 Die modify-Funktion over ist auch
 
+~~~ {.haskell}
 > over :: Profunctor p => Setting p s t a b -> p a b -> s -> t
+~~~
 
-*Edward is deeply in thrall to abstractionitis* - Simon Peyton Jones
+> *Edward is deeply in thrall to abstractionitis* - Simon Peyton Jones
 
 Lens alleine definiert 39 newtypes, 34 data-types und 194 Typsynonyme...  
 Ausschnitt
 
-~~~ { .haskell .numberLines }
+~~~ { .haskell }
 -- traverseOf :: Functor f => Iso s t a b           -> (a -> f b) -> s -> f t
 -- traverseOf :: Functor f => Lens s t a b          -> (a -> f b) -> s -> f t
 -- traverseOf :: Applicative f => Traversal s t a b -> (a -> f b) -> s -> f t
@@ -508,4 +559,4 @@ Ausschnitt
 traverseOf :: Over p f s t a b -> p a (f b) -> s -> f t
 ~~~~~~~~~~~~~~~~~~
 
-dafuq?
+dafuq?

content/Coding/Haskell/Webapp-Example.md

@@ -0,0 +1,320 @@
+# Webapp-Development in Haskell
+
+Step-by-Step-Anleitung, wie man ein neues Projekt mit einer bereits erprobten
+Pipeline erstellt.
+
+## Definition der API
+
+Erster Schritt ist immer ein wünsch-dir-was bei der Api-Defenition.
+
+Die meisten Services haben offensichtliche Anforderungen (Schnittstellen nach
+draußen, Schnittstellen intern, ...). Diese kann man immer sehr gut in einem
+`Request -> Response`-Model erfassen.
+
+Um die Anforderungen und Möglichkeiten des jeweiligen Services sauber zu
+erfassen und automatisiert zu prüfen, dummy-implementationen zu bekommen und
+vieles andere mehr, empfiehlt es sich den #[[OpenAPI|openapi-generator]] zu
+nutzen.
+
+Diese Definition läuft über openapi-v3 und kann z.b. mit Echtzeit-Vorschau im
+http://editor.swagger.io/ erspielen. Per Default ist der noch auf openapi-v2
+(aka swagger), kann aber auch v3.
+
+Nach der Definition, was man am Ende haben möchte, muss man sich entscheiden, in
+welcher Sprache man weiter entwickelt. Ich empfehle aus verschiedenen Gründen
+primär 2 Sprachen: Python-Microservices (weil die ML-Libraries sehr gut sind,
+allerdings Änderungen meist schwer sind und der Code wenig robust - meist nur 1
+API-Endpunkt pro service) und Haskell (Stabilität, Performace, leicht zu ändern,
+gut anzupassen).
+
+Im folgenden wird (aus offensichtlichen Gründen) nur auf das Haskell-Projekt eingegangen.
+
+## Startprojekt in Haskell
+
+### Erstellen eines neuen Projektes
+
+Zunächst erstellen wir in normales Haskell-Projekt ohne Funktionalität & Firlefanz:
+
+```bash
+stack new myservice
+```
+
+Dies erstellt ein neues Verzeichnis und das generelle scaffolding.
+Nach einer kurzen Anpassung der `stack.yaml` (resolver auf unserer setzen;
+aktuell: `lts-17.4`) fügen wir am Ende der Datei
+
+```yaml
+allow-newer: true
+ghc-options:
+    "$locals": -fwrite-ide-info
+```
+
+ein.
+Anschließend organisieren™ wir uns noch eine gute `.gitignore` und initialisieren
+das git mittels `git init; git add .; git commit -m "initial scaffold"`
+
+### Generierung der API
+
+Da die API immer wieder neu generiert werden kann (und sollte!) liegt sich in
+einem unterverzeichnis des Hauptprojektes.
+
+Initial ist es das einfachste ein leeres temporäres Verzeichnis woanders zu
+erstellen, die `api-doc.yml` hinein kopieren und folgendes ausführen:
+
+```bash
+openapi-generator generate -g haskell -o . -i api-doc.yml
+```
+
+Dieses erstellt einem dann eine komplette library inkl. Datentypen.
+Wichtig: Der Name in der `api-doc` sollte vom Namen des Services (oben `myservice`)
+abweichen - entweder in Casing oder im Namen direkt. Suffixe wie API schneidet
+der Generator hier leider ab.
+(Wieso das ganze? Es entstehen nachher 2 libraries, `foo` & `fooAPI`. Da der
+generator das API abschneidet endet man mit foo & foo und der compiler meckert,
+dass er nicht weiß, welche lib gemeint ist).
+
+danach: wie gewohnt `git init; git add .; git commit -m "initial"`. Auf dem
+Server der Wahl (github, gitea, gitlab, ...) nun ein Repository erstellen (am
+Besten: `myserviceAPI` - nach Konvention ist alles auf API endend autogeneriert!)
+und den Anweisungen nach ein remote hinzufügen & pushen.
+
+#### Wieder zurück im Haskell-Service
+
+In unserem eigentlichen Service müssen wir nun die API einbinden.
+Dazu erstellen wir ein Verzeichnis `libs` (Konvention) und machen ein `git
+submodule add <repository-url> libs/myserviceAPI`
+
+Git hat nun die API in das submodul gepackt und wir können das oben erstellte
+temporäre Verzeichnis wieder löschen.
+
+Anschließend müssen wir stack noch erklären, dass wir die API da nun liegen
+haben und passen wieder die `stack.yaml` an, indem wir das Verzeichnis unter
+packages hinzufügen.
+
+```yaml
+packages:
+- .
+- libs/myserviceAPI # <<
+```
+
+Nun können wir in der `package.yaml` (oder `myservice.cabal`, falls kein `hpack`
+verwendet wird) unter den dependencies unsere API hinzufügen (name wie die
+cabal-Datei in `libs/myserviceAPI`).
+
+### Einbinden anderer Microservices
+
+Funktioniert komplett analog zu dem vorgehen oben (ohne das generieren natürlich
+:grin:).
+`stack.yaml` editieren und zu den packages hinzufügen:
+
+```yaml
+packages:
+- .
+- libs/myserviceAPI
+- libs/myCoolMLServiceAPI
+```
+
+in der `package.yaml` (oder der cabal) die dependencies hinzufügen und schon
+haben wir die Features zur Verfügung und können gegen diese Services reden.
+
+### Entfernen von anderen Technologien/Microservices
+
+In git ist das entfernen von Submodules etwas frickelig, daher hier ein
+copy&paste der
+[GitHub-Antwort](https://gist.github.com/myusuf3/7f645819ded92bda6677):
+
+```bash
+## Remove the submodule entry from .git/config
+git submodule deinit -f path/to/submodule
+
+## Remove the submodule directory from the superproject's .git/modules directory
+rm-rf .git/modules/path/to/submodule
+
+## Remove the entry in .gitmodules and remove the submodule directory located at path/to/submodule
+git rm-f path/to/submodule
+```
+
+Falls das nicht klappt, gibt es alternative Vorschläge unter dem Link oben.
+
+### Woher weiss ich, was wo liegt? Dokumentation? Halloo??
+
+Keine Panik. Ein `stack haddock --open` hilft da. Das generiert die
+Dokumentation für alle in der `package.yaml` (oder cabal-file) eingetragenen
+dependencies inkl. aller upstream-dependencies. Man bekommt also eine komplette
+lokale Dokumentation von allem. Geöffnet wird dann die Paket-Startseite inkl.
+der direkten dependencies:
+
+Es gibt 2 wichtige Pfade im Browser:
+
+- ...../all/index.html - hier sind alle Pakete aufgeführt
+- ...../index.html - hier sind nur die direkten dependencies aufgeführt.
+
+Wenn man einen lokalen Webserver startet kann man mittels "s" auch die
+interaktive Suche öffnen (Suche nach Typen, Funktionen, Signaturen, etc.). In
+Bash mit `python3` geht das z.b. einfach über:
+
+```bash
+cd $(stack path --local-doc-root)
+python3 -m SimpleHTTPServer 8000
+firefox "http://localhost:8000"
+```
+
+### Implementation des Services und Start
+
+#### Loader/Bootstrapper
+
+Generelles Vorgehen:
+
+- in `app/Main.hs`:
+  Hier ist quasi immer nur eine Zeile drin: `main = myServiceMain`
+
+  Grund: Applications tauchen nicht im Haddock auf. Also haben wir ein
+  "src"-Modul, welches hier nur geladen & ausgeführt wird.
+- in `src/MyService.hs`:
+  `myServiceMain :: IO ()` definieren
+
+Für die Main kann man prinzipiell eine Main andere Services copy/pasten. Im
+folgenden eine Annotierte main-Funktion - zu den einzelnen Voraussetzungen
+kommen wir im Anschluss.
+
+![[Main.hs#]]
+
+#### Weitere Instanzen und Definitionen, die der Generator (noch) nicht macht
+
+In der `Myservice.Types` werden ein paar hilfreiche Typen und Typ-Instanzen
+definiert. Im Folgenden geht es dabei um Dinge für:
+
+- `Envy`
+  - Laden von `$ENV_VAR` in Datentypen  
+  - Definitionen für Default-Settings
+- `ServerConfig`
+  - Definition der Server-Konfiguration & Benennung der Environment-Variablen
+- `ExtraTypes`
+  - ggf. Paketweite extra-Typen, die der Generator nicht macht, weil sie nicht
+    aus der API kommen (z.B. cache)
+- `Out`/`BSON`-Instanzen
+  - Der API-Generator generiert nur wenige Instanzen automatisch (z.B. `aeson`),
+    daher werden hier die fehlenden definiert.  
+  - `BSON`: Kommunikation mit `MongoDB`  
+  - `Out`: pretty-printing im Log
+    - Nur nötig, wenn man pretty-printing via `Out` statt über Generics wie z.b.
+      `pretty-generic` oder die automatische Show-Instanz via `prerryShow`
+      macht.
+
+![[MyService_Types.hs#]]
+
+#### Was noch zu tun ist
+
+Den Service implementieren. Einfach ein neues Modul aufmachen (z.B.
+`MyService.Handler` oder
+`MyService.DieserEndpunktbereich`/`MyService.JenerEndpunktbereich`) und dort die
+Funktion implementieren, die man in der `Main.hs` benutzt hat.
+In dem Handler habt ihr dann keinen Stress mehr mit Validierung, networking,
+logging, etc. pp. weil alles in der Main abgehandelt wurde und ihr nur noch den
+"Happy-Case" implementieren müsst.
+Beispiel für unseren Handler oben:
+
+```haskell
+myApiEndpointV1Post :: MonadIO m => ServerConfig -> (ClientEnv,ClientEnv) -> TQueue BS.ByteString -> ([LogItem] -> IO ()) -> Request -> m Response
+myApiEndpointV1Post sc calls amqPost log req = do
+    liftIO . log $ [Info $ "recieved "<>pretty req]                                                                   -- input-logging
+    liftIO . atomically . writeTQueue . LBS.toStrict $ "{\"hey Kibana, i recieved:\"" <> A.encode (pretty req) <> "}" -- log in activeMQ/Kibana
+ 
+ 
+    --- .... gaaaanz viel komplizierter code um die Response zu erhalten ;)
+    let ret = Response 1337 Nothing -- dummy-response ;)
+    -- gegeben wir haben eine gültige mongodb-pipe;
+    -- mehr logik will ich in die Beispiele nicht packen.
+    -- Man kann die z.b. als weiteren Wert in einer TMVar (damit man sie ändern & updaten kann) an die Funktion übergeben.
+    liftIO . access pipe master "DatabaseName" $ do
+        ifM (auth (myServiceMongoUsername sc) (myServiceMongoPassword sc)) (return ()) (liftIO . printLog . pure . Error $ "MongoDB: Login failed.")
+        save "DatabaseCollection" ["_id" =: 1337, "entry" =: ret] -- selbe id wie oben ;)
+    return ret
+```
+
+Diese dummy-Antwort führt auf, wie gut man die ganzen Sachen mischen kann.
+
+- Logging in die Dateien/`stdout` - je nach Konfiguration
+- Logging von Statistiken in Kibana
+- Speichern der Antwort in der MongoDB
+- Generieren einer Serverantwort und ausliefern dieser über die Schnittstelle
+
+#### Tipps & Tricks
+
+##### Dateien, die statisch ausgeliefert werden sollen
+
+Hierzu erstellt man ein Verzeichnis `static/` (Konvention; ist im generator so
+generiert, dass das ausgeliefert wird). Packt man hier z.b. eine `index.html`
+rein, erscheint die, wenn man den Service ansurft.
+
+##### Wie bekomme ich diese fancy Preview hin?
+
+Der Editor, der ganz am Anfang zum Einsatz gekommen ist, braucht nur die
+`api-doc.yml` um diese Ansicht zu erzeugen. Daher empfiehlt sich hier ein
+angepasster Fork davon indem die Pfade in der index.html korrigiert sind. Am
+einfachsten (und von den meisten services so benutzt): In meiner Implementation
+liegt dann nach dem starten auf http://localhost:PORT/ui/ und kann direkt dort
+getestet werden.
+
+##### Wie sorge ich für bessere Warnungen, damit der Compiler meine Bugs fängt?
+
+```bash
+stack build --file-watch --ghc-options '-freverse-errors -W -Wall -Wcompat' --interleaved-output
+```
+
+Was tut das?
+
+- `--file-watch`: automatisches (minimales) kompilieren bei dateiänderungen
+- `--ghc-options`
+  - `-freverse-errors`: Fehlermeldungen in umgekehrter Reihenfolge (Erster
+    Fehler ganz unten; wenig scrollen )
+  - `-W`: Warnungen an
+  - `-Wall`: Alle sinnvollen Warnungen an (im gegensatz zu `-Weverything`, was
+    WIRKLICH alles ist  )
+  - `-Wcompat`: Warnungen für Sachen, die in der nächsten Compilerversion kaputt
+    brechen werden & vermieden werden sollten
+- `--interleaved-output`: stack-log direkt ausgeben & nicht in Dateien schreiben
+  und die dann am ende zusammen cat\'en.
+
+Um pro Datei Warnungen auszuschalten (z.B. weil man ganz sicher weiss, was man
+tut -.-): `{-# OPTIONS_GHC -Wno-whatsoever #-}` als pragma in die Datei.
+
+**Idealerweise sollte das Projekt keine Warnungen erzeugen.**
+
+### Deployment
+
+Als Beispiel sei hier ein einfaches Docker-Build mit Jenkins-CI gezeigt, weil
+ich das aus Gründen rumliegen hatte. Kann man analog in fast alle anderen CI
+übersetzen.
+
+#### Docker
+
+Die angehängten Scripte gehen von einer Standard-Einrichtung aus (statische
+Sachen in static, 2-3 händische Anpassungen auf das eigene Projekt nach
+auspacken). Nachher liegt dann auch unter static/version die gebaute
+Versionsnummer & kann abgerufen werden. In der `Dockerfile.release` und der
+`Jenkinsfile` müssen noch Anpassungen gemacht werden. Konkret:
+
+- in der `Dockerfile.release`: alle `<<<HIER>>>`-Stellen sinnvoll befüllen
+- in der `Jenkinsfile` die defs für "servicename" und "servicebinary" ausfüllen.
+  Binary ist das, was bei stack exec aufgerufen wird; name ist der Image-Name
+  für das docker-repository.
+
+#### Jenkins
+
+Änderungen die dann noch gemacht werden müssen:
+
+- git-repository URL anpassen
+- Environment-Vars anpassen (\$BRANCH = test & live haben keine zusatzdinger im
+  docker-image-repository; ansonsten hat das image \$BRANCH im Namen)
+
+Wenn das fertig gebaut ist, liegt im test/live-repository ein docker-image
+namens `servicename:version`.
+
+### OMG! Ich muss meine API ändern. Was mache ich nun?
+
+1. api-doc.yml bearbeiten, wie gewünscht
+2. mittels generator die Api & submodule neu generieren
+3. ggf. custom Änderungen übernehmen (:Gitdiffsplit hilft)
+4. Alle Compilerfehler + Warnungen in der eigentlichen Applikation fixen
+5. If it comipilez, ship it! (Besser nicht :grin:)

content/Coding/Haskell/Webapp-Example/Main.hs.md

@@ -0,0 +1,188 @@
+# Webapp-Example: Main.hs
+
+Wie man das verwendet, siehe #[[Webapp-Example]].
+
+```haskell
+{-# OPTIONS_GHC -Wno-name-shadowing #-}
+{-# LANGUAGE FlexibleContexts    #-}
+{-# LANGUAGE LambdaCase          #-}
+{-# LANGUAGE OverloadedStrings   #-}
+{-# LANGUAGE RankNTypes          #-}
+{-# LANGUAGE RecordWildCards     #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+module MyService where
+ 
+-- generische imports aus den dependencies/base, nicht in der prelude
+import           Codec.MIME.Type
+import           Configuration.Dotenv                 as Dotenv
+import           Control.Concurrent                   (forkIO, threadDelay)
+import           Control.Concurrent.Async
+import           Control.Concurrent.STM
+import           Control.Monad
+import           Control.Monad.Catch
+import           Control.Monad.Except
+import           Conversion
+import           Conversion.Text                      ()
+import           Data.Binary.Builder
+import           Data.String                          (IsString (..))
+import           Data.Time
+import           Data.Time.Clock
+import           Data.Time.Format
+import           Data.Default
+import           Network.HostName
+import           Network.HTTP.Client                  as HTTP hiding
+                                                               (withConnection)
+import           Network.HTTP.Types                   (Status, statusCode)
+import           Network.Mom.Stompl.Client.Queue
+import           Network.Wai                          (Middleware)
+import           Network.Wai.Logger
+import           Network.Wai.Middleware.Cors
+import           Network.Wai.Middleware.RequestLogger (OutputFormat (..),
+                                                       logStdout,
+                                                       mkRequestLogger,
+                                                       outputFormat)
+import           Servant.Client                       (mkClientEnv,
+                                                       parseBaseUrl)
+import           System.Directory
+import           System.Envy
+import           System.IO
+import           System.Log.FastLogger
+import           Text.PrettyPrint.GenericPretty
+ 
+-- generische imports, aber qualified, weil es sonst zu name-clashes kommt
+ 
+import qualified Data.ByteString                      as BS
+-- import qualified Data.ByteString.Char8 as BS8
+import qualified Data.ByteString.Lazy                 as LBS
+import qualified Network.HTTP.Client.TLS              as UseDefaultHTTPSSettings (tlsManagerSettings)
+import qualified Network.Mom.Stompl.Client.Queue      as AMQ
+import qualified Network.Wai                          as WAI
+ 
+-- Handler für den MyServiceBackend-Typen und Imports aus den Libraries
+import           MyService.Handler                    as H  -- handler der H.myApiEndpointV1Post implementiert
+import           MyService.Types                            -- weitere Type (s. nächste box)
+import           MyServiceGen.API                     as MS -- aus der generierten library
+
+ 
+myServicemain :: IO ()
+myServicemain = do
+  -- .env-Datei ins Prozess-Environment laden, falls noch nicht von außen gesetzt
+  void $ loadFile $ Dotenv.Config [".env"] [] False
+  -- Config holen (defaults + overrides aus dem Environment)
+  sc@ServerConfig{..} <- decodeWithDefaults defConfig
+  -- Backend-Setup
+  -- legt sowas wie Proxy-Server fest und wo man wie dran kommt. Benötigt für das Sprechen mit anderen Microservices
+  let defaultHTTPSSettings = UseDefaultHTTPSSettings.tlsManagerSettings { managerResponseTimeout = responseTimeoutMicro $ 1000 * 1000 * myserviceMaxTimeout }
+      createBackend url proxy = do
+        manager <- newManager . managerSetProxy proxy
+          $ defaultHTTPSSettings
+        url' <- parseBaseUrl url
+        return (mkClientEnv manager url')
+      internalProxy = case myserviceInternalProxyUrl of
+                        ""  -> noProxy
+                        url -> useProxy $ HTTP.Proxy (fromString url) myserviceInternalProxyPort
+      -- externalProxy = case myserviceExternalProxyUrl of
+      --                   ""  -> noProxy
+      --                   url -> useProxy $ HTTP.Proxy (fromString url) myserviceExternalProxyPort
+ 
+  -- Definieren & Erzeugen der Funktionen um die anderen Services anzusprechen.
+  calls <- (,)
+           <$> createBackend myserviceAUri internalProxy  
+           <*> createBackend myserviceBUri internalProxy 
+ 
+  -- Logging-Setup
+  hSetBuffering stdout LineBuffering
+  hSetBuffering stderr LineBuffering
+ 
+ 
+  -- Infos holen, brauchen wir später
+  myName <- getHostName
+  today <- formatTime defaultTimeLocale "%F" . utctDay <$> getCurrentTime
+ 
+ 
+  -- activeMQ-Transaktional-Queue zum schreiben nachher vorbereiten
+  amqPost <- newTQueueIO
+ 
+ 
+  -- bracket a b c == erst a machen, ergebnis an c als variablen übergeben. Schmeisst c ne exception/wird gekillt/..., werden die variablen an b übergeben.
+  bracket
+   -- logfiles öffnen
+   (LogFiles <$> openFile ("/logs/myservice-"<>myName<>"-"<>today<>".info") AppendMode
+             <*> openFile (if myserviceDebug then "/logs/myservice-"<>myName<>"-"<>today<>".debug" else "/dev/null") AppendMode
+             <*> openFile ("/logs/myservice-"<>myName<>"-"<>today<>".error") AppendMode
+             <*> openFile ("/logs/myservice-"<>myName<>"-"<>today<>".timings") AppendMode
+   )
+   -- und bei exception/beendigung schlißen.h
+   (\(LogFiles a b c d) -> mapM_ hClose [a,b,c,d])
+   $ \logfiles -> do
+ 
+ 
+    -- logschreibe-funktionen aliasen; log ist hier abstrakt, iolog spezialisiert auf io.
+    let log = printLogFiles logfiles :: MonadIO m => [LogItem] -> m ()
+        iolog = printLogFilesIO logfiles :: [LogItem] -> IO ()
+ 
+ 
+        -- H.myApiEndpointV1Post ist ein Handler (alle Handler werden mit alias H importiert) und in einer eigenen Datei
+        -- Per Default bekommen Handler sowas wie die server-config, die Funktionen um mit anderen Services zu reden, die AMQ-Queue um ins Kibana zu loggen und eine Datei-Logging-Funktion
+        -- Man kann aber noch viel mehr machen - z.b. gecachte Daten übergeben, eine Talk-Instanz, etc. pp.
+        server = MyServiceBackend{ myApiEndpointV1Post = H.myApiEndpointV1Post sc calls amqPost log
+                                   }
+        config = MS.Config $ "http://" ++ myserviceHost ++ ":" ++ show myservicePort ++ "/"
+    iolog . pure . Info $ "Using Server configuration:"
+    iolog . pure . Info $ pretty sc { myserviceActivemqPassword = "******" -- Do NOT log the password ;)
+                                    , myserviceMongoPassword = "******"
+                                    }
+    -- alle Services starten (Hintergrund-Aktionen wie z.b. einen MongoDB-Dumper, einen Talk-Server oder wie hier die ActiveMQ
+    void $ forkIO $ keepActiveMQConnected sc iolog amqPost
+    -- logging-Framework erzeugen
+    loggingMW <- loggingMiddleware
+    -- server starten
+    if myserviceDebug
+       then runMyServiceMiddlewareServer config (cors (\_ -> Just (simpleCorsResourcePolicy {corsRequestHeaders = ["Content-Type"]})) . loggingMW . logStdout) server
+       else runMyServiceMiddlewareServer config (cors (\_ -> Just (simpleCorsResourcePolicy {corsRequestHeaders = ["Content-Type"]}))) server
+ 
+ 
+-- Sollte bald in die Library hs-stomp ausgelagert werden
+-- ist ein Beispiel für einen ActiveMQ-Dumper
+keepActiveMQConnected :: ServerConfig -> ([LogItem] -> IO ()) -> TQueue BS.ByteString -> IO ()
+keepActiveMQConnected sc@ServerConfig{..} printLog var = do
+  res <- handle (\(e :: SomeException) -> do
+      printLog . pure . Error $ "Exception in AMQ-Thread: "<>show e
+      return $ Right ()
+    ) $ AMQ.try $ do -- catches all AMQ-Exception that we can handle. All others bubble up.
+        printLog . pure . Info $ "AMQ: connecting..."
+        withConnection myserviceActivemqHost myserviceActivemqPort [ OAuth myserviceActivemqUsername myserviceActivemqPassword
+                                                                   , OTmo (30*1000) {- 30 sec timeout -}
+                                                                   ]
+                                                                   [] $ \c -> do
+          let oconv = return
+          printLog . pure . Info $ "AMQ: connected"
+          withWriter c "Chaos-Logger for Kibana" "chaos.logs" [] [] oconv $ \writer -> do
+            printLog . pure . Info $ "AMQ: queue created"
+            let postfun = writeQ writer (Type (Application "json") []) []
+            void $ race
+              (forever $ atomically (readTQueue var) >>= postfun)
+              (threadDelay (600*1000*1000)) -- wait 10 Minutes
+          -- close writer
+        -- close connection
+  -- get outside of all try/handle/...-constructions befor recursing.
+  case res of
+    Left ex -> do
+      printLog . pure . Error $ "AMQ: "<>show ex
+      keepActiveMQConnected sc printLog var
+    Right _ -> keepActiveMQConnected sc printLog var
+ 
+ 
+-- Beispiel für eine Custom-Logging-Middleware.
+-- Hier werden z.B. alle 4xx-Status-Codes inkl. Payload ins stdout-Log geschrieben.
+-- Nützlich, wenn die Kollegen ihre Requests nicht ordentlich schreiben können und der Server das Format zurecht mit einem BadRequest ablehnt ;)
+loggingMiddleware :: IO Middleware
+loggingMiddleware = liftIO $ mkRequestLogger $ def { outputFormat = CustomOutputFormatWithDetails out }
+  where
+    out :: ZonedDate -> WAI.Request -> Status -> Maybe Integer -> NominalDiffTime -> [BS.ByteString] -> Builder -> LogStr
+    out _ r status _ _ payload _
+      | statusCode status < 300 = ""
+      | statusCode status > 399 && statusCode status < 500 = "Error code "<>toLogStr (statusCode status) <>" sent. Request-Payload was: "<> mconcat (toLogStr <$> payload) <> "\n"
+      | otherwise = toLogStr (show r) <> "\n"
+
+```

content/Coding/Haskell/Webapp-Example/MyService_Types.hs.md

@@ -0,0 +1,83 @@
+# Webapp-Example: MyService/Types.hs
+
+Anleitung siehe #[[Webapp-Example]].
+
+```haskell
+{-# OPTIONS_GHC -Wno-orphans #-}
+{-# OPTIONS_GHC -Wno-name-shadowing #-}
+{-# LANGUAGE DeriveAnyClass        #-}
+{-# LANGUAGE DeriveFunctor         #-}
+{-# LANGUAGE DeriveGeneric         #-}
+{-# LANGUAGE DerivingVia           #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE FlexibleContexts      #-}
+{-# LANGUAGE FlexibleInstances     #-}
+{-# LANGUAGE GADTs                 #-}
+{-# LANGUAGE LambdaCase            #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE RankNTypes            #-}
+{-# LANGUAGE RecordWildCards       #-}
+module MyService.Types where
+ 
+import           Data.Aeson                     (FromJSON, ToJSON)
+import           Data.Text
+import           Data.Time.Clock
+import           GHC.Generics
+import           System.Envy
+import           Text.PrettyPrint               (text)
+import           Text.PrettyPrint.GenericPretty
+ 
+-- Out hat hierfür keine Instanzen, daher kurz eine einfach Definition.
+instance Out Text where
+  doc = text . unpack
+  docPrec i a = text $ showsPrec i a ""
+ 
+instance Out UTCTime where
+  doc = text . show
+  docPrec i a = text $ showsPrec i a ""
+ 
+-- Der ServerConfig-Typ. Wird mit den defaults unten initialisiert, dann mit den Variablen aus der .env-Datei überschrieben und zum Schluss können Serveradmins diese via $MYSERVICE_FOO nochmal überschreiben.
+data ServerConfig = ServerConfig
+                  { myserviceHost              :: String -- ^ Environment: $MYSERVICE_HOST
+                  , myservicePort              :: Int    -- ^ Environment: $MYSERVICE_PORT
+                  , myserviceMaxTimeout        :: Int    -- ^ Environment: $MYSERVICE_MAX_TIMEOUT
+                  , myserviceInternalProxyUrl  :: String -- ^ Environment: $MYSERVICE_INTERNAL_PROXY_URL
+                  , myserviceInternalProxyPort :: Int    -- ^ Environment: $MYSERVICE_INTERNAL_PROXY_PORT
+                  , myserviceExternalProxyUrl  :: String -- ^ Environment: $MYSERVICE_EXTERNAL_PROXY_URL
+                  , myserviceExternalProxyPort :: Int    -- ^ Environment: $MYSERVICE_EXTERNAL_PROXY_PORT
+                  , myserviceActivemqHost      :: String -- ^ Environment: $MYSERVICE_ACTIVEMQ_HOST
+                  , myserviceActivemqPort      :: Int    -- ^ Environment: $MYSERVICE_ACTIVEMQ_PORT
+                  , myserviceActivemqUsername  :: String -- ^ Environment: $MYSERVICE_ACTIVEMQ_USERNAME
+                  , myserviceActivemqPassword  :: String -- ^ Environment: $MYSERVICE_ACTIVEMQ_PASSWORD
+                  , myserviceMongoUsername     :: String -- ^ Environment: $MYSERVICE_MONGO_USERNAME
+                  , myserviceMongoPassword     :: String -- ^ Environment: $MYSERVICE_MONGO_PASSWORD
+                  , myserviceDebug             :: Bool   -- ^ Environment: $MYSERVICE_DEBUG
+                  } deriving (Show, Eq, Generic)
+ 
+-- Default-Konfigurations-Instanz für diesen Service.
+instance DefConfig ServerConfig where
+  defConfig = ServerConfig "0.0.0.0" 8080 20
+                           ""
+                           ""
+                           ""
+                           0
+                           ""
+                           0
+                           ""
+                           0
+                           ""
+                           ""
+                           ""
+                           ""
+                           False
+ 
+-- Kann auch aus dem ENV gefüllt werden
+instance FromEnv ServerConfig
+-- Und hübsch ausgegeben werden.
+instance Out ServerConfig
+ 
+ 
+instance Out Response
+instance FromBSON Repsonse -- FromBSON-Instanz geht immer davon aus, dass alle keys da sind (ggf. mit null bei Nothing).
+```

content/Coding/OpenAPI.md

@@ -0,0 +1,23 @@
+# Openapi-generator
+
+## Idee hinter einem API-Generator
+
+[[TODO]] Idee hinter einem API-Generator
+
+## Theorie und Praxis
+
+[[TODO]] Theorie und Praxis
+
+## Spezialfall in Haskell
+
+[[TODO]] Veraltet
+
+Wie im [[Webapp-Example]] kurz angerissen wird in Haskell nicht zwischen Server
+und Client unterschieden. Daher können hier sehr viele Optimierungen bei
+Änderungen passieren, die in anderen Sprachen nicht so einfach möglich sind.
+
+Die generierte Library hat die Funktionen, die ein Client braucht direkt dabei
+und man muss lediglich die Verbindung initialisieren (Callback für
+Network-Requests, Serveradresse etc.) und kann dann direkt alle Funktionen
+benutzen. Partial Application hilft hier massiv und man bekommt z.b. Für die
+Beispiel-Tierhandlung aus dem ursprünglichem `getPet :: ` direkt so etwas wie `getPet :: PetID -> IO Pet`

content/Gesellschaft/Religion/ArgumentGott.md

@@ -1,22 +0,0 @@
----
-categories: Gesellschaft Religion Gott Argumentation
-toc: yes
-title: Argumentation mit Gott
-...
-
-Eine [Argumentation](/Argumentation) mit dem einschließen eines Gottesbegriffes oder eines Eingreifens kann keine Argumentation sein, da dieses die fundamentalen Eigenschaften der dahinterliegenden [Logik](/Logik) in Frage stellt.
-
-Die einzige Möglichkeit einen Gott in einer objektiv logischen Argumentation, welche nicht durch Individualinteressen motiviert ist, ist indem man den Terminus Gott mit bottom ($\perp$) gleichsetzt.
-Taucht dieser Terminus in einer beliebigen logischen Formel auf, ist anschließend jede Folgerung legitim. Allerdings führt dies in der Konsequenz die Logik als solche ad-absurdum, da sämtliche anderen Regeln nicht mehr gelten.
-
-Somit ist in der Konsequenz einer Argumentation, die eines "Gottes" (oder allgemeiner eines $\perp$) bedarf ungültig (da nicht logisch fundiert) und in der Folge reine Zeitverschwendung, weil man so alles rechtfertigen kann.
-
-Dieses widerstrebt vielen logisch denkenden Menschen, was meist zu Hass und Rage gegen die eine oder andere Gruppe führt. Auch bildet sich somit ein Reflex heraus, der viele Leute bei der bloßen Erwähnung eines Gottesbezuges abschalten lässt.
-
-Leider missverstehen viele Leute auch, dass Gott in der Argumentation **nötig** wäre. Die meisten Argumentationen sind auch ohne Gottesbezug valide und logisch. Häufig wird "Gott" (wahlweise auch "Jesus", "Buddah", "Jahwe", "Mohammed", ...) benutzt um eine *Motivation* zu rechtfertigen. Bei rationalen Menschen benötigt es aber diesen Antrieb nicht, da dieser intrinsisch entwickelt wird, sobald die Argumentation logisch-sachlich geführt wurde.
-
-Ein Terminus "Gott" macht somit eine Argumentation obsolet und wird leider meist als letztes Mittel gebraucht, wenn einem alle anderen Argumente ausgehen.
-
-Sapere aude! - Habe Mut dich deines eigenen Verstandes zu bedienen! Wenn es allerdings Menschen gibt (und die gibt es!), die einen "Gott" als Motivation brauchen, dann ist dieses Mittel völlig legitim. Wenn man allerdings anderen Menschen, die diesen "psychologischen Trick" nicht benötigen, weil sie sich selbst ihrer Handlungen und ihrer selbst bewusst sind, dann hat dieses meist genau die Gegenteilige Wirkung: Blanke Ablehnung.
-
-Das Problem bei vielen Argumentationen in diese Richtung ist, dass es Häufig mindestens einer (meist beiden) Seiten *nicht bewusst* ist, was dort eigentlich grade passiert.

content/Haskell/Code_Snippets.md

@@ -1,433 +0,0 @@
-# Was ist das hier?  
-
-Hier schreiben wir ein paar Code-Highlights auf, die uns begegnet sind.
-
-## Monoid? Da war doch was...
-
-Stellen wir uns vor, dass wir eine Funktion schreiben, die einen String bekommt (mehrere Lines mit ACSII-Text) und dieses Wort-für-Wort rückwärts ausgeben soll. Das ist ein einfacher Einzeiler:
-
-~~~ { .haskell .numberLines }
-module Main where
-
-import System.Environment (getArgs)
-import Data.Monoid (mconcat)
-import Data.Functor ((<$>))
-
-main = do
-    ls <- readFile =<< head <$> getArgs
-    mconcat <$> mapM (putStrLn . unwords . reverse . words) (lines ls) --die eigentliche Funktion, ls ist das argument.
-~~~~~~~~~~~~~~~~~~
-
-Was passiert hier an Vodoo? Und was machen die ganzen wilden Zeichen da?
-
-Gehen wir die Main zeilenweise durch:
-Wir lesen die Datei, die im ersten Kommandozeilen-Argument gegeben wird. getArgs hat folgende Signatur:
-
-```haskell
-getArgs :: IO [String]
-```
-
-Wir bekommen als eine Liste der Argumente. Wir wollen nur das erste. Also machen wir head getArgs. Allerdings fliegt uns dann ein Fehler. head sieht nämlich so aus:
-
-```haskell
-head :: [a] -> a
-```
-
-Irgendwie müssen wird as **in** das IO bekommen. Hierzu gibt es fmap. Somit ist
-
-```haskell
-fmap head :: IO [a] -> IO a
-```
-
-Ein inline-Alias (um die Funktion links und das Argument rechts zu schreiben und sich ne Menge Klammern zu sparen) ist <$>. Somit ist schlussendlich der Inhalt der Datei aus dem ersten Argument (lazy) in ls.
-
-Eine andere Möglichkeit sich das (in diesem Fall) zu merken, bzw. drauf zu kommen ist, dass [] AUCH ein Funktor (sogar eine Monade) ist. Man könnte das also auch so schreiben:
-
-```haskell
-head                ::              [] a      ->   a
-head                :: Functor f => [] (f a)     -> f a -- das "a" geschickt ersetzt zur Verdeutlichung
-getArgs             ::              IO [] String
-fmap head           :: Functor f => f  [] a      -> f a
-```
-
-fmap "packt" die Funktion quasi 1 Umgebung (Funktor, Monade, ..) weiter rein - Sei es nun in Maybe, Either oder irgendwas anderes.
-
-Alternatives (ausführliches) Beispiel am Ende.
-
-Wenn wir uns die Signatur ansehen, dann haben wir nun
-
-```haskell
-head <$> getArgs :: IO String
-```
-
-readFile will aber nun ein String haben. Man kann nun
-
-```haskell
-f  <- head <$> getArgs
-ls <- readFile f
-```
-
-kann man auch "inline" mit =<< die Sachen "auspacken".
-
-Die 2. Zeile lesen wir nun einfach "von hinten", wie man das meistens tun sollte. Hier ist ein
-
-```haskell
-lines ls :: [String]
-```
-
-was uns den Inhalt der Datei zeilenweise gibt. Mit jeder Zeile möchten wir nun folgendes machen:
-
-1. nach Wörtern trennen (words)
-2. Wörter in der reihenfolge umkehren (reverse)
-3. Wörter wider zu einer Zeile zusammensetzen (unwords)
-4. diese Zeile ausgeben (putStrLn)
-
-Wenn wir uns die Signatur ansehen:
-
-```haskell
-(putStrLn . unwords . reverse . words) :: String -> IO ()
-```
-
-Das mag im ersten Moment verwirren, daher noch die Signaturen der Einzelfunktionen:
-
-```haskell
-words    :: String -> [String]
-reverse  :: [a] -> [a]
-unwords  :: [String] -> String
-putStrLn :: String -> IO ()
-```
-
-Da wir am Ende in der IO-Monade landen müssen wir das auf unsere Zeilen mit mapM statt map anwenden. Dies sorgt auch dafür, dass die Liste der reihe nach durchgegangen wird. mapM mit unserer Funktion schaut dann so aus:
-
-```haskell
-mapM (putStrLn . unwords . reverse . words) :: [String] -> [IO ()]
-```
-
-eek! Das [IO ()] sieht ekelig aus. Wir haben eine Liste von IO-gar nichts. Das können wir eigentlich entsorgen. Da wir innerhalb der main-Funktion in einer IO-Monade sind, wollen wir IO () anstatt [IO ()] zurück haben.
-
-Wenn wir uns jetzt erinnern, dass [] auch nur eine Monade ist und dass jede Monade ein Monoid ist, dann ist die Lösung einfach. Monoide haben eine "append"-funktion (mappend oder (<>) genannt). Wenn wir "nichts" an "nichts" anhängen, dann erhalten wir .... *Trommelwirbel* "nichts"! Wir müssen die [IO ()]-Liste also "nur noch" mit mappend falten. Hierzu gibt es schon eine vorgefertigte Funktion:
-
-```haskell
-mconcat :: [a] -> a
-mconcat = foldr mappend mempty
-```
-
-Was genau die gewünschte Faltung macht. Wir müssen nun wieder fmap nehmen, da wir die Liste selbst falten wollen - und nicht map, welches auf den IO () innerhalb der Liste arbeiten würde. Durch die Faltung fällt die Liste nun auf IO () zusammen.
-
-Viel Voodoo in wenig Code, aber wenn man sich dran gewöhnt hat, sind Monaden in Monaden auch nicht schlimm. Man muss sich immer nur richtig "rein" fmap'en.
-
----
-
-Kleinen Tipp gab es noch: mapM_ macht genau das, was oben mit mconcat erreicht werden sollte. Somit kann man auch
-
-```haskell
-mapM_ (putStrLn . unwords . reverse . words) (lines ls)
-```
-
-schreiben. Ich hab es aber mal wegen der klarheit oben so gelassen.
-
-### Alternatives fmap-Beispiel
-
-Nehmen wir als alternatives Beispiel mal an:
-
-```haskell
-a :: IO Maybe State t
-```
-
-Um Funktionen vom Typ
-
-```haskell
-f :: IO a -> IO a
-f a             -- valide
-```
-
-zu nehmen, brauchen wir nichts machen. Bei
-
-```haskell
-f' :: Maybe a -> Maybe a
-```
-
-brauchen wir 1 fmap, also ein
-
-```haskell
-f' a            -- error
-f' <$> a
-```
-
-um eine Funktion
-
-```haskell
-f'' :: State t -> State t
-```
-
-zu benutzen folglich:
-
-```haskell
-f'' a           -- error
-f'' <$> a       -- error
-fmap f'' <$> a
-```
-
-## *-Morpisms
-
-Backup eines Blogposts eines Kommilitonen:
-
-
-This weekend I spend some time on Morphisms.
-
-Knowing that this might sound daunting to many
-dabbling Haskellers (like I am), I decided to 
-write a real short MergeSort hylomorphism quickstarter.
-
-----------------------------------------------------------
-
-For those who need a refresher: MergeSort works by creating
-a balanced binary tree from the input list and directly
-collapsing it back into itself while treating the children 
-as sorted lists and merging these with an O(n) algorithm.
-
-----------------------------------------------------------
-
-First the usual prelude: 
-```haskell
-{-# LANGUAGE DeriveFunctor #-}
-{-# LANGUAGE TypeFamilies #-}
-
-import Data.Functor.Foldable 
-import Data.List (splitAt, unfoldr)
-```
-
-----------------------------------------------------------
-
-We will use a binary tree like this. Note that
-there is no explicit recursion used, but `NodeF` has
-two *holes*. These will eventually filled later.
-
-```haskell
-data TreeF c f = EmptyF | LeafF c | NodeF f f
-  deriving (Eq, Show, Functor)
-```
-
---------------------------------------------------
-
-Aside: We could use this as a *normal* binary tree by
-wrapping it in `Fix`: `type Tree a = Fix (TreeF a)`
-But this would require us to write our tree like
-`Fix (NodeF (Fix (LeafF 'l')) (Fix (LeafF 'r')))`
-which would get tedious fast. Luckily Edward build
-a much better way to do this into *recursion-schemes*.
-I will touch on this later.
-
---------------------------------------------------
-
-Without further ado we start to write a Coalgebra,
-which in my book is just a scary name for 
-"function that is used to construct datastructures".
-
-```haskell
-unflatten :: [a] -> TreeF a [a]
-unflatten (  []) = EmptyF
-unflatten (x:[]) = LeafF x
-unflatten (  xs) = NodeF l r   where (l,r) = splitAt (length xs `div` 2) xs
-```
-
-From the type signature it's immediately obvious,
-that we take a list of 'a's and use it to create
-a part of our tree.
-
-The nice thing is that due to the fact that we
-haven't commited to a type in our tree nodes
-we can just put lists in there. 
-
---------------------------------------------------
-
-Aside: At this point we could use this Coalgebra to 
-construct (unsorted) binary trees from lists:
-
-```haskell
-example1 = ana unflatten [1,3] == Fix (NodeF (Fix (LeafF 1)) (Fix (LeafF 3)))
-```
-
---------------------------------------------------
-
-On to our sorting, tree-collapsing Algebra.
-Which again is just a creepy word for
-"function that is used to deconstruct datastructures".
-
-The function `mergeList` is defined below and
-just merges two sorted lists into one sorted list
-in O(n), I would probably take this from the `ordlist`
-package if I were to implement this *for real*.
-
-Again we see that we can just construct our 
-sorted output list from a `TreeF` that 
-apparently contains just lists.
-
-```haskell
-flatten :: Ord a => TreeF a [a] -> [a]
-flatten EmptyF      = []
-flatten (LeafF c)   = [c]
-flatten (NodeF l r) = mergeLists l r 
-```
-
---------------------------------------------------
-
-Aside: We could use a Coalgebra to deconstruct trees:
-
-```haskell
-example2 = cata flatten (Fix (NodeF (Fix (LeafF 3)) (Fix (LeafF 1)))) == [1,3]
-```
-
---------------------------------------------------
-
-Now we just combine the Coalgebra and the Algebra
-with one from the functions from Edwards `recursion-schemes`
-library:
-```haskell
-mergeSort :: Ord a => [a] -> [a]
-mergeSort = hylo flatten unflatten
-
-example3 = mergeSort [5,2,7,9,1,4] == [1,2,4,5,7,9] 
-```
---------------------------------------------------
-
-What have we gained? 
-
-We have implemented a MergeSort variant in 9 lines of
-code, not counting the `mergeLists` function below.
-Not bad, but 
-[this implementation](http://en.literateprograms.org/Merge_sort_(Haskell))
-is not much longer.
-
-On the other hand the morphism based implementation
-cleanly describes what happens during construction
-and deconstruction of our intermediate structure.
-
-My guess is that, as soon as the algortihms get 
-more complex, this will really make a difference.
-
---------------------------------------------------
-
-At this point I wasn't sure if this was useful or
-remotely applicable. Telling someone "I spend a
-whole weekend learning about Hylomorphism" isn't 
-something the cool developer kids do.
-
-It appeared to me that maybe I should have a look
-at the Core to see what the compiler finally comes
-up with (edited for brevity):
-
-```haskell
-    mergeSort :: [Integer] -> [Integer]
-    mergeSort =
-      \ (x :: [Integer]) ->
-        case x of wild {
-          [] -> [];
-          : x1 ds ->
-            case ds of _ {
-              [] -> : x1 ([]);
-              : ipv ipv1 ->
-                unfoldr
-                  lvl9
-                  (let {
-                     p :: ([Integer], [Integer])
-                     p =
-                       case $wlenAcc wild 0 of ww { __DEFAULT ->
-                       case divInt# ww 2 of ww4 { __DEFAULT ->
-                       case tagToEnum# (<# ww4 0) of _ {
-                         False ->
-                           case $wsplitAt# ww4 wild of _ { (# ww2, ww3 #) -> (ww2, ww3) };
-                         True -> ([], wild)
-                       }
-                       }
-                       } } in
-                   (case p of _ { (x2, ds1) -> mergeSort x2 },
-                    case p of _ { (ds1,  y) -> mergeSort y  }))
-            }
-        }
-    end Rec }
-```
-
-While I am not really competent in reading Core and 
-this is actually the first time I bothered to try, 
-it is immediately obvious that there is no trace
-of any intermediate tree structure. 
-
-This is when it struck me. I was dazzled and amazed.
-And am still. Although we are writing our algorithm
-as if we are working on a real tree structure the
-library and the compiler are able to just remove
-the whole intermediate step.
-
-
---------------------------------------------------
-
-Aftermath:
-
-In the beginning I promised a way to work on 
-non-functor data structures. Actually that
-was how I began to work with the `recursion-schemes`
-library.
-
-We are able to create a 'normal' version of our tree
-from above:
-```haskell
-data Tree c = Empty | Leaf c | Node (Tree c) (Tree c)
-  deriving (Eq, Show)
-```
-But we can not use this directly with our (Co-)Algebras.
-Luckily Edward build a little bit of type magic into 
-the library:
-
-```haskell
-type instance Base (Tree c) = (TreeF c)
-
-instance Unfoldable (Tree c) where
-  embed EmptyF      = Empty
-  embed (LeafF c)   = Leaf c
-  embed (NodeF l r) = Node l r
-
-instance Foldable (Tree c) where
-  project Empty      = EmptyF
-  project (Leaf c)   = LeafF c
-  project (Node l r) = NodeF l r
-```
-
-Without going into detail by doing this we establish
-a relationship between `Tree` and `TreeF` and teach
-the compiler how to translate between these types.
-
-Now we can use our Alebra on our non functor type:
-
-```haskell
-example4 = cata flatten (Node (Leaf 'l') (Leaf 'r')) == "lr"
-```
-
-The great thing about this is that, looking at the
-Core output again, there is no traces of the `TreeF`
-structure to be found. As far as I can tell, the
-algorithm is working directly on our `Tree` type.
-
---------------------------------------------------
-
-Literature:
-  
-  * [Understanding F-Algebras](https://www.fpcomplete.com/user/bartosz/understanding-algebras)
-  * [Recursion Schemes by Example](http://www.timphilipwilliams.com/slides.html)
-  * [Recursion Schemes: A Field Guide](http://comonad.com/reader/2009/recursion-schemes/)
-  * [This StackOverflow question](http://stackoverflow.com/questions/6941904/recursion-schemes-for-dummies)
-
-
---------------------------------------------------
-
-Appendix:
-
-```haskell
-mergeLists :: Ord a => [a] -> [a] -> [a]
-mergeLists = curry $ unfoldr c where
-  c ([], [])     = Nothing
-  c ([], y:ys)   = Just (y, ([], ys))
-  c (x:xs, [])   = Just (x, (xs, []))
-  c (x:xs, y:ys) | x <= y = Just (x, (xs, y:ys)) 
-                 | x > y  = Just (y, (x:xs, ys))
-```

content/Haskell/Webapp_Development.md

@@ -1,501 +0,0 @@
-Step-by-Step-Anleitung, wie man ein neues Projekt mit einer bereits erprobten Pipeline erstellt.
-
-# Definition der API
-
-Erster Schritt ist immer ein wünsch-dir-was bei der Api-Defenition.
-
-Die meisten Services haben offensichtliche Anforderungen (Schnittstellen nach draußen, Schnittstellen intern, ...). Diese kann man immer sehr gut in einem `Request -> Response`-Model erfassen.
-
-Diese Definition läuft über openapi-v3 und kann z.b. mit Echtzeit-Vorschau im http://editor.swagger.io/ erspielen. Per Default ist der noch auf openapi-v2 (aka swagger), kann aber auch v3.
-
-Nach der Definition, was man am Ende haben möchte, muss man sich entscheiden, in welcher Sprache man weiter entwickelt. Ich empfehle aus verschiedenen Gründen primär 2 Sprachen: Python-Microservices (weil die ML-Libraries sehr gut sind, allerdings Änderungen meist schwer sind und der Code wenig robust - meist nur 1 API-Endpunkt pro service) und Haskell (stabilität, performace, leicht zu ändern, gut anzupassen).
-
-Im folgenden wird (aus offensichtlichen Gründen) nur auf das Haskell-Projekt eingegangen.
-
-# Startprojekt in Haskell
-
-## Erstellen eines neuen Projektes
-
-zunächst erstellen wir in normales Haskell-Projekt ohne funktionalität & firlefanz:
-
-```bash
-stack new myservice
-```
-
-Dies erstellt ein neues Verzeichnis und das generelle scaffolding.
-Nach einer kurzen anpassung der stack.yaml (resolver auf unserer setzen; aktuell: lts-17.4) fügen wir am Ende der Datei
-
-```yaml
-allow-newer: true
-ghc-options:
-    "$locals": -fwrite-ide-info
-```
-
-ein.
-Anschließend organisieren wir uns noch eine gute `.gitignore` und initialisieren das git mittels `git init; git add .; git commit -m "initial scaffold"`
-
-## Generierung der API
-
-Da die API immer wieder neu generiert werden kann (und sollte!) liegt sich in einem unterverzeichnis des Haputprojektes.
-
-Initial ist es das einfachste ein leeres temporäres Verzeichnis woanders zu erstellen, die `api-doc.yml` hinein kopieren und folgendes ausführen:
-
-```bash
-openapi-generator generate -g haskell -o . -i api-doc.yml
-```
-
-Dieses erstellt einem dann eine komplette library inkl. Datentypen.
-Wichtig: Der Name in der api-doc sollte vom Namen des Services (oben myservice) abweichen - entweder in Casing oder im Namen direkt. Suffixe wie API schneidet der Generator hier leider ab.
-(Wieso das ganze? Es entstehen nachher 2 libraries, foo & fooAPI. Da der generator das API abschneidet endet man mit foo & foo und der compiler meckert, dass er nicht weiss, welche lib gemeint ist).
-
-danach: wie gewohnt `git init; git add .; git commit -m "initial"`. Auf dem Server der Wahl (github, gitea, gitlab, ...) nun ein Repository erstellen (am Besten: myserviceAPI - alles auf API endend ist autogeneriert!) und den Anweisungen nach ein remote hinzufügen & pushen.
-
-### Wieder zurück im Haskell-Service
-
-In unserem eigentlichen Service müssen wir nun die API einbinden.
-Dazu erstellen wir ein Verzeichnis `libs` (konvention) und machen ein `git submodule add <repository-url> libs/myserviceAPI`
-
-Git hat nun die API in das submodul gepackt und wir können das oben erstellte temporäre verzeichnis wieder löschen.
-
-Anschließend müssen wir stack noch erklären, dass wir die API da nun liegen haben und passen wieder die stack.yaml an, indem wir das Verzeichnis unter packages hinzufügen.
-
-```yaml
-packages:
-- .
-- libs/myserviceAPI # <<
-```
-nun können wir in der `package.yaml` (oder `myservice.cabal`, falls kein hpack verwendet wird) unter den dependencies unsere api hinzufügen (name wie die cabal-datei in libs/myserviceAPI).
-
-## Einbinden anderer Microservices
-
-Funktioniert komplett analog zu dem vorgehen oben (ohne das generieren natürlich ;) ).
-`stack.yaml` editieren und zu den packages hinzufügen:
-
-```yaml
-packages:
-- .
-- libs/myserviceAPI
-- libs/myCoolMLServiceAPI
-```
-
-in der `package.yaml` (oder der cabal) die dependencies hinzufügen und schon haben wir die Features zur Verfügung und können gegen diese Services reden.
-
-## Entfernen von anderen Technologien/Microservices
-
-In git ist das entfernen von Submodules etwas frickelig, daher hier ein copy&paste der [GitHub-Antwort](https://gist.github.com/myusuf3/7f645819ded92bda6677):
-
-```bash
-# Remove the submodule entry from .git/config
-git submodule deinit -f path/to/submodule
-
-# Remove the submodule directory from the superproject's .git/modules directory
-rm-rf .git/modules/path/to/submodule
-
-# Remove the entry in .gitmodules and remove the submodule directory located at path/to/submodule
-git rm-f path/to/submodule
-```
-
-Falls das nicht klappt, gibt es alternative Vorschläge unter dem Link oben.
-
-## Woher weiss ich, was wo liegt? Dokumentation? Halloo??
-
-Keine Panik. Ein `stack haddock --open` hilft da. Das generiert die Dokumentation für alle in der `package.yaml` (oder cabal-file) eingetragenen dependencies inkl. aller upstream-dependencies. Man bekommt also eine komplette lokale Dokumentation von allem. Geöffnet wird dann die Paket-Startseite inkl. der direkten dependencies:
-
-Es gibt 2 wichtige Pfade im Browser:
-
-- ...../all/index.html - hier sind alle Pakete aufgeführt
-- ...../index.html - hier sind nur die direkten dependencies aufgeführt.
-
-Wenn man einen lokalen Webserver startet kann man mittels "s" auch die interaktive Suche öffnen (Suche nach Typen, Funktionen, Signaturen, etc.). In Bash mit python3 geht das z.b. einfach über:
-
-```bash
-cd $(stack path --local-doc-root)
-python3 -m SimpleHTTPServer 8000
-firefox "http://localhost:8000"
-```
-
-## Implementation des Services und Start
-
-### Loader/Bootstrapper
-
-Generelles Vorgehen:
-- in app/Main.hs:
-  Hier ist quasi immer nur eine Zeile drin: `main = myServiceMain`
-
-  Grund: Applications tauchen nicht im Haddock auf. Also haben wir ein "src"-Modul, welches hier nur geladen & ausgeführt wird.
-- in src/MyService.hs:
-  `myServiceMain :: IO ()` definieren
-
-Für die Main kann man prinzipiell eine Main andere Services copy/pasten. Im folgenden eine Annotierte main-Funktion - zu den einzelnen Vorraussetzungen kommen wir im Anschluss.
-
-```haskell
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-{-# LANGUAGE FlexibleContexts    #-}
-{-# LANGUAGE LambdaCase          #-}
-{-# LANGUAGE OverloadedStrings   #-}
-{-# LANGUAGE RankNTypes          #-}
-{-# LANGUAGE RecordWildCards     #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-module MyService where
- 
--- generische imports aus den dependencies/base, nicht in der prelude
-import           Codec.MIME.Type
-import           Configuration.Dotenv                 as Dotenv
-import           Control.Concurrent                   (forkIO, threadDelay)
-import           Control.Concurrent.Async
-import           Control.Concurrent.STM
-import           Control.Monad
-import           Control.Monad.Catch
-import           Control.Monad.Except
-import           Conversion
-import           Conversion.Text                      ()
-import           Data.Binary.Builder
-import           Data.String                          (IsString (..))
-import           Data.Time
-import           Data.Time.Clock
-import           Data.Time.Format
-import           Data.Default
-import           Network.HostName
-import           Network.HTTP.Client                  as HTTP hiding
-                                                               (withConnection)
-import           Network.HTTP.Types                   (Status, statusCode)
-import           Network.Mom.Stompl.Client.Queue
-import           Network.Wai                          (Middleware)
-import           Network.Wai.Logger
-import           Network.Wai.Middleware.Cors
-import           Network.Wai.Middleware.RequestLogger (OutputFormat (..),
-                                                       logStdout,
-                                                       mkRequestLogger,
-                                                       outputFormat)
-import           Servant.Client                       (mkClientEnv,
-                                                       parseBaseUrl)
-import           System.Directory
-import           System.Envy
-import           System.IO
-import           System.Log.FastLogger
-import           Text.PrettyPrint.GenericPretty
- 
--- generische imports, aber qualified, weil es sonst zu name-clashes kommt
- 
-import qualified Data.ByteString                      as BS
--- import qualified Data.ByteString.Char8 as BS8
-import qualified Data.ByteString.Lazy                 as LBS
-import qualified Network.HTTP.Client.TLS              as UseDefaultHTTPSSettings (tlsManagerSettings)
-import qualified Network.Mom.Stompl.Client.Queue      as AMQ
-import qualified Network.Wai                          as WAI
- 
--- Handler für den MyServiceBackend-Typen und Imports aus den Libraries
-import           MyService.Handler                    as H  -- handler der H.myApiEndpointV1Post implementiert
-import           MyService.Types                            -- weitere Type (s. nächste box)
-import           MyServiceGen.API                     as MS -- aus der generierten library
-
- 
-myServicemain :: IO ()
-myServicemain = do
-  -- .env-Datei ins Prozess-Environment laden, falls noch nicht von außen gesetzt
-  void $ loadFile $ Dotenv.Config [".env"] [] False
-  -- Config holen (defaults + overrides aus dem Environment)
-  sc@ServerConfig{..} <- decodeWithDefaults defConfig
-  -- Backend-Setup
-  -- legt sowas wie Proxy-Server fest und wo man wie dran kommt. Benötigt für das Sprechen mit anderen Microservices
-  let defaultHTTPSSettings = UseDefaultHTTPSSettings.tlsManagerSettings { managerResponseTimeout = responseTimeoutMicro $ 1000 * 1000 * myserviceMaxTimeout }
-      createBackend url proxy = do
-        manager <- newManager . managerSetProxy proxy
-          $ defaultHTTPSSettings
-        url' <- parseBaseUrl url
-        return (mkClientEnv manager url')
-      internalProxy = case myserviceInternalProxyUrl of
-                        ""  -> noProxy
-                        url -> useProxy $ HTTP.Proxy (fromString url) myserviceInternalProxyPort
-      -- externalProxy = case myserviceExternalProxyUrl of
-      --                   ""  -> noProxy
-      --                   url -> useProxy $ HTTP.Proxy (fromString url) myserviceExternalProxyPort
- 
-  -- Definieren & Erzeugen der Funktionen um die anderen Services anzusprechen.
-  calls <- (,)
-           <$> createBackend myserviceAUri internalProxy  
-           <*> createBackend myserviceBUri internalProxy 
- 
-  -- Logging-Setup
-  hSetBuffering stdout LineBuffering
-  hSetBuffering stderr LineBuffering
- 
- 
-  -- Infos holen, brauchen wir später
-  myName <- getHostName
-  today <- formatTime defaultTimeLocale "%F" . utctDay <$> getCurrentTime
- 
- 
-  -- activeMQ-Transaktional-Queue zum schreiben nachher vorbereiten
-  amqPost <- newTQueueIO
- 
- 
-  -- bracket a b c == erst a machen, ergebnis an c als variablen übergeben. Schmeisst c ne exception/wird gekillt/..., werden die variablen an b übergeben.
-  bracket
-   -- logfiles öffnen
-   (LogFiles <$> openFile ("/logs/myservice-"<>myName<>"-"<>today<>".info") AppendMode
-             <*> openFile (if myserviceDebug then "/logs/myservice-"<>myName<>"-"<>today<>".debug" else "/dev/null") AppendMode
-             <*> openFile ("/logs/myservice-"<>myName<>"-"<>today<>".error") AppendMode
-             <*> openFile ("/logs/myservice-"<>myName<>"-"<>today<>".timings") AppendMode
-   )
-   -- und bei exception/beendigung schlißen.h
-   (\(LogFiles a b c d) -> mapM_ hClose [a,b,c,d])
-   $ \logfiles -> do
- 
- 
-    -- logschreibe-funktionen aliasen; log ist hier abstrakt, iolog spezialisiert auf io.
-    let log = printLogFiles logfiles :: MonadIO m => [LogItem] -> m ()
-        iolog = printLogFilesIO logfiles :: [LogItem] -> IO ()
- 
- 
-        -- H.myApiEndpointV1Post ist ein Handler (alle Handler werden mit alias H importiert) und in einer eigenen Datei
-        -- Per Default bekommen Handler sowas wie die server-config, die Funktionen um mit anderen Services zu reden, die AMQ-Queue um ins Kibana zu loggen und eine Datei-Logging-Funktion
-        -- Man kann aber noch viel mehr machen - z.b. gecachte Daten übergeben, eine Talk-Instanz, etc. pp.
-        server = MyServiceBackend{ myApiEndpointV1Post = H.myApiEndpointV1Post sc calls amqPost log
-                                   }
-        config = MS.Config $ "http://" ++ myserviceHost ++ ":" ++ show myservicePort ++ "/"
-    iolog . pure . Info $ "Using Server configuration:"
-    iolog . pure . Info $ pretty sc { myserviceActivemqPassword = "******" -- Do NOT log the password ;)
-                                    , myserviceMongoPassword = "******"
-                                    }
-    -- alle Services starten (Hintergrund-Aktionen wie z.b. einen MongoDB-Dumper, einen Talk-Server oder wie hier die ActiveMQ
-    void $ forkIO $ keepActiveMQConnected sc iolog amqPost
-    -- logging-Framework erzeugen
-    loggingMW <- loggingMiddleware
-    -- server starten
-    if myserviceDebug
-       then runMyServiceMiddlewareServer config (cors (\_ -> Just (simpleCorsResourcePolicy {corsRequestHeaders = ["Content-Type"]})) . loggingMW . logStdout) server
-       else runMyServiceMiddlewareServer config (cors (\_ -> Just (simpleCorsResourcePolicy {corsRequestHeaders = ["Content-Type"]}))) server
- 
- 
--- Sollte bald in die Library hs-stomp ausgelagert werden
--- ist ein Beispiel für einen ActiveMQ-Dumper
-keepActiveMQConnected :: ServerConfig -> ([LogItem] -> IO ()) -> TQueue BS.ByteString -> IO ()
-keepActiveMQConnected sc@ServerConfig{..} printLog var = do
-  res <- handle (\(e :: SomeException) -> do
-      printLog . pure . Error $ "Exception in AMQ-Thread: "<>show e
-      return $ Right ()
-    ) $ AMQ.try $ do -- catches all AMQ-Exception that we can handle. All others bubble up.
-        printLog . pure . Info $ "AMQ: connecting..."
-        withConnection myserviceActivemqHost myserviceActivemqPort [ OAuth myserviceActivemqUsername myserviceActivemqPassword
-                                                                   , OTmo (30*1000) {- 30 sec timeout -}
-                                                                   ]
-                                                                   [] $ \c -> do
-          let oconv = return
-          printLog . pure . Info $ "AMQ: connected"
-          withWriter c "Chaos-Logger for Kibana" "chaos.logs" [] [] oconv $ \writer -> do
-            printLog . pure . Info $ "AMQ: queue created"
-            let postfun = writeQ writer (Type (Application "json") []) []
-            void $ race
-              (forever $ atomically (readTQueue var) >>= postfun)
-              (threadDelay (600*1000*1000)) -- wait 10 Minutes
-          -- close writer
-        -- close connection
-  -- get outside of all try/handle/...-constructions befor recursing.
-  case res of
-    Left ex -> do
-      printLog . pure . Error $ "AMQ: "<>show ex
-      keepActiveMQConnected sc printLog var
-    Right _ -> keepActiveMQConnected sc printLog var
- 
- 
--- Beispiel für eine Custom-Logging-Middleware.
--- Hier werden z.B. alle 4xx-Status-Codes inkl. Payload ins stdout-Log geschrieben.
--- Nützlich, wenn die Kollegen ihre Requests nicht ordentlich schreiben können und der Server das Format zurecht mit einem BadRequest ablehnt ;)
-loggingMiddleware :: IO Middleware
-loggingMiddleware = liftIO $ mkRequestLogger $ def { outputFormat = CustomOutputFormatWithDetails out }
-  where
-    out :: ZonedDate -> WAI.Request -> Status -> Maybe Integer -> NominalDiffTime -> [BS.ByteString] -> Builder -> LogStr
-    out _ r status _ _ payload _
-      | statusCode status < 300 = ""
-      | statusCode status > 399 && statusCode status < 500 = "Error code "<>toLogStr (statusCode status) <>" sent. Request-Payload was: "<> mconcat (toLogStr <$> payload) <> "\n"
-      | otherwise = toLogStr (show r) <> "\n"
-
-```
-
-### Weitere Instanzen und Definitionen, die der Generator (noch) nicht macht
-
-In der `Myservice.Types` werden ein paar hilfreiche Typen und Typinstanzen definiert. Im Folgenden geht es dabei um Dinge für:
-
-- Envy
-  - Laden von $ENV_VAR in Datentypen  
-  - Definitionen für Default-Settings
-- ServerConfig
-  - Definition der Server-Konfiguration & Benennung der Environment-Variablen
-- ExtraTypes
-  - ggf. Paketweite extra-Typen, die der Generator nicht macht, weil sie nicht aus der API kommen (z.B. cache)
-- Out/BSON-Instanzen
-  - Der API-Generator generiert nur wenige Instanzen automatisch (z.B. Aeson), daher werden hier die fehlenden definiert.  
-  - BSON: Kommunakation mit MongoDB  
-  - Out: pretty-printing im Log
-
-```haskell
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# OPTIONS_GHC -Wno-name-shadowing #-}
-{-# LANGUAGE DeriveAnyClass        #-}
-{-# LANGUAGE DeriveFunctor         #-}
-{-# LANGUAGE DeriveGeneric         #-}
-{-# LANGUAGE DerivingVia           #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE FlexibleInstances     #-}
-{-# LANGUAGE GADTs                 #-}
-{-# LANGUAGE LambdaCase            #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE OverloadedStrings     #-}
-{-# LANGUAGE RankNTypes            #-}
-{-# LANGUAGE RecordWildCards       #-}
-module MyService.Types where
- 
-import           Data.Aeson                     (FromJSON, ToJSON)
-import           Data.Text
-import           Data.Time.Clock
-import           GHC.Generics
-import           System.Envy
-import           Text.PrettyPrint               (text)
-import           Text.PrettyPrint.GenericPretty
- 
--- Out hat hierfür keine Instanzen, daher kurz eine einfach Definition.
-instance Out Text where
-  doc = text . unpack
-  docPrec i a = text $ showsPrec i a ""
- 
-instance Out UTCTime where
-  doc = text . show
-  docPrec i a = text $ showsPrec i a ""
- 
--- Der ServerConfig-Typ. Wird mit den defaults unten initialisiert, dann mit den Variablen aus der .env-Datei überschrieben und zum Schluss können Serveradmins diese via $MYSERVICE_FOO nochmal überschreiben.
-data ServerConfig = ServerConfig
-                  { myserviceHost              :: String -- ^ Environment: $MYSERVICE_HOST
-                  , myservicePort              :: Int    -- ^ Environment: $MYSERVICE_PORT
-                  , myserviceMaxTimeout        :: Int    -- ^ Environment: $MYSERVICE_MAX_TIMEOUT
-                  , myserviceInternalProxyUrl  :: String -- ^ Environment: $MYSERVICE_INTERNAL_PROXY_URL
-                  , myserviceInternalProxyPort :: Int    -- ^ Environment: $MYSERVICE_INTERNAL_PROXY_PORT
-                  , myserviceExternalProxyUrl  :: String -- ^ Environment: $MYSERVICE_EXTERNAL_PROXY_URL
-                  , myserviceExternalProxyPort :: Int    -- ^ Environment: $MYSERVICE_EXTERNAL_PROXY_PORT
-                  , myserviceActivemqHost      :: String -- ^ Environment: $MYSERVICE_ACTIVEMQ_HOST
-                  , myserviceActivemqPort      :: Int    -- ^ Environment: $MYSERVICE_ACTIVEMQ_PORT
-                  , myserviceActivemqUsername  :: String -- ^ Environment: $MYSERVICE_ACTIVEMQ_USERNAME
-                  , myserviceActivemqPassword  :: String -- ^ Environment: $MYSERVICE_ACTIVEMQ_PASSWORD
-                  , myserviceMongoUsername     :: String -- ^ Environment: $MYSERVICE_MONGO_USERNAME
-                  , myserviceMongoPassword     :: String -- ^ Environment: $MYSERVICE_MONGO_PASSWORD
-                  , myserviceDebug             :: Bool   -- ^ Environment: $MYSERVICE_DEBUG
-                  } deriving (Show, Eq, Generic)
- 
--- Default-Konfigurations-Instanz für diesen Service.
-instance DefConfig ServerConfig where
-  defConfig = ServerConfig "0.0.0.0" 8080 20
-                           ""
-                           ""
-                           ""
-                           0
-                           ""
-                           0
-                           ""
-                           0
-                           ""
-                           ""
-                           ""
-                           ""
-                           False
- 
--- Kann auch aus dem ENV gefüllt werden
-instance FromEnv ServerConfig
--- Und hübsch ausgegeben werden.
-instance Out ServerConfig
- 
- 
-instance Out Response
-instance FromBSON Repsonse -- FromBSON-Instanz geht immer davon aus, dass alle keys da sind (ggf. mit null bei Nothing).
-```
-
-### Was noch zu tun ist
-
-Den Service implementieren. Einfach ein neues Modul aufmachen (z.B. `MyService.Handler` oder `MyService.DieserEndpunktbereich`/`MyService.JenerEndpunktbereich`) und dort die Funktion implementieren, die man in der `Main.hs` benutzt hat.
-In dem Handler habt ihr dann keinen Stress mehr mit validierung, networking, logging, etc. pp. weil alles in der Main abgehandelt wurde und ihr nur noch den "Happy-Case" implementieren müsst.
-Beispiel für unseren Handler oben:
-
-```haskell
-myApiEndpointV1Post :: MonadIO m => ServerConfig -> (ClientEnv,ClientEnv) -> TQueue BS.ByteString -> ([LogItem] -> IO ()) -> Request -> m Response
-myApiEndpointV1Post sc calls amqPost log req = do
-    liftIO . log $ [Info $ "recieved "<>pretty req]                                                                   -- input-logging
-    liftIO . atomically . writeTQueue . LBS.toStrict $ "{\"hey Kibana, i recieved:\"" <> A.encode (pretty req) <> "}" -- log in activeMQ/Kibana
- 
- 
-    --- .... gaaaanz viel komplizierter code um die Response zu erhalten ;)
-    let ret = Response 1337 Nothing -- dummy-response ;)
-    -- gegeben wir haben eine gültige mongodb-pipe;
-    -- mehr logik will ich in die Beispiele nicht packen.
-    -- Man kann die z.b. als weiteren Wert in einer TMVar (damit man sie ändern & updaten kann) an die Funktion übergeben.
-    liftIO . access pipe master "DatabaseName" $ do
-        ifM (auth (myServiceMongoUsername sc) (myServiceMongoPassword sc)) (return ()) (liftIO . printLog . pure . Error $ "MongoDB: Login failed.")
-        save "DatabaseCollection" ["_id" =: 1337, "entry" =: ret] -- selbe id wie oben ;)
-    return ret
-```
-
-Diese dummy-Antwort führt auf, wie gut man die ganzen Sachen mischen kann.
-
-- Logging in die Dateien/stdout nach config
-- Logging von Statistiker in Kibana
-- Speichern der Antwort in der MongoDB
-- Generieren einer Serverantwort und ausliefern dieser über die Schnittstelle
-
-### Tipps & Tricks
-
-#### Dateien, die statisch ausgeliefert werden sollen
-
-Hierzu erstellt man ein Verzeichnis `static/` (konvention; ist im generator so generiert, dass das ausgeliefert wird). Packt man hier z.b. eine `index.html` rein, erscheint die, wenn man den Service ansurft.
-
-#### Wie bekomme ich diese fancy Preview hin?
-
-Der Editor, der ganz am Anfang zum Einsatz gekommen ist, braucht nur die `api-doc.yml` um diese Ansicht zu erzeugen.
-Daher empfielt sich hier ein angepasster Fork davon indem die Pfade in der index.html korrigiert sind. Am einfachsten (und von den meisten services so benutzt):
-In meiner Implementation liegt dann nach dem starten auf http://localhost:PORT/ui/ und kann direkt dort getestet werden.
-
-#### Wie sorge ich für bessere Warnungen, damit der Compiler meine Bugs fängt?
-
-```bash
-stack build --file-watch --ghc-options '-freverse-errors -W -Wall -Wcompat' --interleaved-output
-```
-
-Was tut das?
-
-- `--file-watch`: automatisches (minimales) kompilieren bei dateiänderungen
-- `--ghc-options`
-  - `-freverse-errors`: Fehlermeldungen in umgekehrter Reihenfolge (Erster Fehler ganz unten; wenig scrollen )
-  - `-W`: Warnungen an
-  - `-Wall`: Alle sinnvollen Warnungen an (im gegensatz zu `-Weverything`, was WIRKLICH alles ist  )
-  - `-Wcompat`: Warnungen für Sachen, die in der nächsten Compilerversion kaputt brechen werden & vermieden werden sollten
-- `--interleaved-output`: stack-log direkt ausgeben & nicht in dateien schreiben und die dann am ende zusammen cat\'en.
-
-Um pro Datei Warnungen auszuschalten (z.B. weil man ganz sicher weiss, was man tut -.-): `{-# OPTIONS_GHC -Wno-whatsoever #-}` als Pragma in die Datei.
-
-**Idealerweise sollte das Projekt keine Warnungen erzeugen.**
-
-## Deployment
-
-Als Beispiel sei hier ein einfaches Docker-Build mit Jenkins-CI gezeigt, weil ich das aus Gründen rumliegen hatte. Kann man analog in fast alle anderen CI übrsetzen.
-
-### Docker
-
-Die angehängten Scripte gehen von einer Standard-Einrichtung aus (statische sachen in static, 2-3 händische Anpassungen auf das eigene Projekt nach auspacken). Nachher liegt dann auch unter static/version die gebaute Versionsnummer & kann abgerufen werden.
-In der Dockerfile.release und der Jenkinsfile müssen noch anpassungen gemacht werden. Konkret:
-
-- in der Dockerfile.release: alle `<<<HIER>>>`-Stellen sinnvoll befüllen
-- in der Jenkinsfile die defs für "servicename" und "servicebinary" ausfüllen. Binary ist das, was bei stack exec aufgerufen wird; name ist der Image-Name für das docker-repository.
-
-### Jenkins
-
-Änderungen die dann noch gemacht werden müssen:
-- git-repository url anpassen
-- Environment-Vars anpasses ($BRANCH = test & live haben keine zusatzdinger im docker-image-repository; ansonsten hat das image $BRANCH im namen)
-
-Wenn das durchgebaut ist, liegt im test/live-repository ein docker-image namens `servicename:version`.
-
-## OMG! Ich muss meine API ändern. Was mache ich nun?
-
-1. api-doc.yml bearbeiten, wie gewünscht
-2. mittels generator die Api & submodule neu generieren
-3. ggf. custom Änderungen übernehmen (:Gitdiffsplit hilft)
-4. Alle Compilerfehler + Warnungen in der eigentlichen Applikation fixen
-5. If it comipilez, ship it! (Besser nicht ;) )

content/Health/Issues.md

@@ -0,0 +1,55 @@
+---
+title: Mental Health
+---
+
+In modern times many people struggle with mental health issues - and a am by no
+means an exception. The main issue is, that most people just don't talk about it
+and suffer alone, thinking they are alone, and everyone else is just doing fine
+in this hellscape of a modern society. At least that is what you see on several
+social media platforms like Instagram etc.
+
+So even despite my exceptional `[citation needed]` successes that can be seen in
+my [[Work|work]]# i always struggled with issues even to the point of total
+breakdown. Of course i am also guilty of painting a rosy picture of me - just
+look at [[Experience|a summary of my experiences]]# or the
+awesome [[Extracurricular|things i did at university]]#. If you only read that it
+is hard to believe that i basically had to delay my studies from 2007 to 2010
+because i wasn't even really able to leave the house.
+
+Only thanks to the not-that-awful system in Germany and massive financial help
+from my parents i was even able to pursue this way.
+
+## What are my issues?
+
+Well.. it is not completely clear, what all my issues are. Many of those are
+related, some are just the result of coping mechanisms of ignoring other issues.
+
+Currently i am successfully diagnosed with
+
+- social anxiety
+- ADHD
+- transgenderism
+
+and suspected of
+
+- autism (asperger)
+
+All in all: when i feel well, am good rested and have nothing critical coming up
+i am more of what i would call a "high functioning Autist, but not THAT far on
+the spectrum". But it is funny that finding out who i really am i met more
+people that i thought who basically had the same issue and a similar biography
+then me. Some of them get the autism-diagnosis first, others the ADHD one -
+since until some time ago those diagnosis were mutually exclusive.
+
+That's also why many people like me are only really diagnosed as adults, because
+autism hides many effects of ADHD and vice-versa - depending on which one is
+currently dominating. It is basically 2 modes: do everything all at once and
+start everything that grabs your attention - or do a deep dive into a single
+thing. And the exact opposite: The ADHD part being bored by the autism-project,
+the autism-part is completely overwhelmed by the ADHD chaos. Both then leading
+to exhaustion, not being able to do anything .. and basically feeling guilty for
+the things you did not manage to finish.
+
+## The early days
+
+[[TODO]]

content/Logik.md

@@ -1,8 +1,8 @@
 ---
 categories: Mathematik
 toc: yes
-title: Logik
-...
+title: Logik für Dummies
+---
 
 Logik ist das ziehen von Schlüssen, die innerhalb der Logik widerspruchsfrei und kohärent sind.
 
@@ -125,4 +125,4 @@ Ein Beispiel für eine Logik, die Annahme 5 macht: Bool'sche Algebra
 
 Ein Beispiel für eine Logik, die Annahme 5 *nicht* macht: Heyting Algebra, u.U. auch Lindenbaum Algebra (nicht geprüft)
 
-Damit ist letztere qua definitionem mächtiger als Erstgenannte, da diese in letztgenannter enthalten ist.
+Damit ist letztere qua definitionem mächtiger als Erstgenannte, da diese in letztgenannter enthalten ist.

content/Opinions/Editors.md

@@ -0,0 +1,9 @@
+# Editors
+
+Better said: "why neovim is currently my favorite editor" :wink:
+
+## Current Config
+
+You can find my current Config along with other things in my [gitea snippet-git](https://gitea.dresselhaus.cloud/Drezil/snippets).
+
+[[TODO]]: write more awesomesauce :wink:

content/Opinions/Layout.md

@@ -0,0 +1,35 @@
+---
+title: Keyboard-Layouts
+---
+
+# My Keyboard-Layout
+
+Since around 2006 i basically write only using the
+[NEO2](https://neo-layout.org)-Layout. There are many advantages that are not obvious to
+an onlooker right away.
+
+Don't get me wrong. I still can type QWERTZ - just because you learn an
+additional layout does not mean that you forget everything from before.
+
+The secret sauce lies in the deeper layers. Especially layer 3 having all the
+"hard to reach" things like brackets, braces, etc. right on the home row.
+And the 4th layer is *magic* for text-navigation. Left hand has the full
+navigation, right hand has the complete Numpad - even on laptop-keyboards that
+are lacking those.
+
+For me as a person having the usual German Keyboard with AltGr this just means:
+
+- Putting the thumb down on AltGr - it is above there anyway.
+- Use left hand as normal arrow-keys (that work EVERYWHERE because they are just
+  arrow keys)
+- Also use Home/End/PgUp/PgDown/...
+
+Before i always had to switch over or hope that a thing had support for
+vi-style "hjkl".
+
+Thats why i also prefer [[Opinions/Editors|Neovim]] as my primary editor - just not having to
+touch your mouse at any time for anything is such a godsend :smile:
+
+Best thing: If you don't want to switch, there is also a "Neo-QWERTZ"-variant ..
+where you can just try the deeper layers while not leaving your QWERTZ-layout
+behind. But i have just seen and never tried it. Your experience may be sub-par.

content/Stuff/Bielefeldverschwoerung.md

@@ -0,0 +1,178 @@
+# Die Bielefeld-Verschwörung
+
+Kopie des vermutlichen Originals von (vermutlich) Achim Held aus 1994.
+
+---
+
+**Warnung:** Diese Seite enthält Material, von dem SIE nicht wollen, dass es
+bekannt wird. Speichern Sie diese Seite nicht auf Ihrer lokalen Platte ab, denn
+sonst sind Sie auch dran, wenn SIE plötzlich bei Ihnen vor der Tür stehen; und
+das passiert schneller als man denkt. Auch sollten Sie versuchen, alle Hinweise
+darauf, dass Sie diese Seite jemals gelesen haben, zu vernichten. Tragen Sie
+diese Seite auf keinen Fall in ihre Hotlist/Bookmarks/etc... ein!
+
+Vielen Dank für die Beachtung aller Sicherheitsvorschriften.
+
+## Die Geschichte der Entdeckung
+
+Vor einigen Jahren fiel es einigen Unerschrockenen zum ersten Mal auf, dass in
+den Medien immer wieder von einer Stadt namens 'Bielefeld' die Rede war, dass
+aber niemand jemanden aus Bielefeld kannte, geschweige denn selbst schon einmal
+dort war. Zuerst hielten sie dies für eine belanglose Sache, aber dann machte es
+sie doch neugierig. Sie unterhielten sich mit anderen darüber, ohne zu ahnen,
+dass dies bereits ein Fehler war: Aus heutiger Sicht steht fest, dass jemand
+geplaudert haben muss, denn sofort darauf wurden SIE aktiv. Plötzlich tauchten
+Leute auf, die vorgaben, schon einmal in Bielefeld gewesen zu sein; sogar
+Personen, die vormals noch laut Zweifel geäußert hatten, berichteten jetzt
+davon, sich mit eigenen Augen von der Existenz vergewissert zu haben - immer
+hatten diese Personen bei ihren Berichten einen seltsam starren Blick. Doch da
+war es schon zu spät - die Saat des Zweifels war gesät. Weitere Personen stießen
+zu der Kerngruppe der Zweifler, immer noch nicht sicher, was oder wem man da auf
+der Spur war.
+
+Dann, im Oktober 1993, der Durchbruch: Auf der Fahrt von Essen nach Kiel auf der
+A2 erhielten vier der hartnäckigsten Streiter für die Aufdeckung der
+Verschwörung ein Zeichen: Jemand hatte auf allen Schildern den Namen 'Bielefeld'
+mit orangem Klebeband durchgestrichen. Da wußte die Gruppe: Man ist nicht
+alleine, es gibt noch andere, im Untergrund arbeitende Zweifler, womöglich über
+ganz Deutschland verteilt, die auch vor spektakulären Aktionen nicht
+zurückschrecken. Von da an war uns klar: Wir müssen diese Scharade aufdecken,
+koste es, was es wolle!
+Das Ausmaß der Verschwörung
+
+Der Aufwand, mit dem die Täuschung der ganzen Welt betrieben wird, ist enorm.
+Die Medien, von denen ja bekannt ist, dass sie unter IHRER Kontrolle stehen,
+berichten tagaus, tagein von Bielefeld, als sei dies eine Stadt wie jede andere,
+um der Bevölkerung das Gefühl zu geben, hier sei alles ganz normal. Aber auch
+handfestere Beweise werden gefälscht: SIE kaufen hunderttausende von Autos,
+versehen sie mit gefälschten 'BI-'Kennzeichen und lassen diese durch ganz
+Deutschland fahren. SIE stellen, wie bereits oben geschildert, entlang der
+Autobahnen große Schilder auf, auf denen Bielefeld erwähnt wird. SIE
+veröffentlichen Zeitungen, die angeblich in Bielefeld gedruckt werden.
+Anscheinend haben SIE auch die Deutsche Post AG in Ihrer Hand, denn auch im PLZB
+findet man einen Eintrag für Bielefeld; und ebenso wird bei der Telekom ein
+komplettes Ortsnetz für Bielefeld simuliert. Einige Leute behaupten sogar in
+Bielefeld studiert zu haben und können auch gut gefälschte Diplome u.ä. der
+angeblich existenten Uni Bielefeld vorweisen. Auch Bundeskanzler Gerhard
+Schröder behauptet, 1965 das "Westfalen-Kolleg" in Bielefeld besucht zu haben,
+wie seinem Lebenslauf unter dem Link Bildungsweg zu entnehmen ist.
+
+Aber auch vor dem Internet machen SIE nicht halt. SIE vergeben Mail-Adressen für
+die Domain uni-bielefeld.de, und SIE folgen auch den neuesten Trends: SIE bieten
+im WWW eine ["Stadtinfo über Bielefeld"](https://bielefeld.de) an, sogar mit
+Bildern; das Vorgarten-Foto, das dem Betrachter als "Botanischer Garten"
+verkauft werden sollte, ist nach der Entlarvung auf dieser Seite jedoch
+inzwischen wieder entfernt worden. Aber auch die noch vorhandenen Bilder sind
+sogar für den Laien als Fotomontagen zu erkennen. Wir sind noch nicht dahinter
+gekommen, wo der Rechner steht, auf dem die Domains .bielefeld.de und
+uni-bielefeld.de gefälscht werden; wir arbeiten daran. Inzwischen wurde auch von
+einem IHRER Agenten - der Täter ist uns bekannt - versucht, diese WWW-Seite zu
+sabotieren, ich konnte den angerichteten Schaden jedoch zum Glück wieder
+beheben.
+
+Ein anonymer Informant, der ganz offensichtlich zu IHNEN zu gehören scheint oder
+zumindest gute Kontakte zu IHNEN hat, hat mich kürzlich in einer Mail auf die
+nächste Stufe IHRER Planung hingewiesen: "Ich schätze, spätestens in 10 Jahren
+wird es heißen: Bielefeld muss Hauptstadt werden." Was das bedeutet, muss ja
+wohl nicht extra betont werden.
+
+Die schrecklichste Maßnahme, die SIE ergriffen haben, ist aber zweifelsohne
+immer noch die Gehirnwäsche, der immer wieder harmlose Menschen unterzogen
+werden, die dann anschließend auch die Existenz von Bielefeld propagieren. Immer
+wieder verschwinden Menschen, gerade solche, die sich öffentlich zu ihren
+Bielefeldzweifeln bekannt haben, nur um dann nach einiger Zeit wieder
+aufzutauchen und zu behaupten, sie seien in Bielefeld gewesen. Womöglich wurden
+einige Opfer sogar mit Telenosestrahlen behandelt. Diesen armen Menschen konnten
+wir bisher nicht helfen. Wir haben allerdings inzwischen einen Verdacht, wo
+diese Gehirnwäsche durchgeführt wird: Im sogenannten Bielefeld-Zentrum, wobei
+SIE sogar die Kaltblütigkeit besitzen, den Weg zu diesem Ort des Schreckens von
+der Autobahn aus mit großen Schildern auszuschildern. Wir sind sprachlos,
+welchen Einfluß SIE haben.
+
+Inzwischen sind - wohl auch durch mehrere Berichte in den wenigen nicht von
+IHNEN kontrollierten Medien - mehr und mehr Leute wachsamer geworden und machen
+uns auf weitere Aspekte der Verschwörung aufmerksam. So berichtet zum Beispiel
+Holger Blaschka:
+
+"Auch der DFB ist in diesen gewaltigen Skandal verwickelt, spielt in der ersten
+Liga doch ein Verein, den SIE Arminia Bielefeld getauft haben, der innert 2
+Jahren aus dem Nichts der Amateur-Regionen im bezahlten Fußball auftauchte und
+jetzt im Begriff ist, sich zu IHRER besten Waffe gegen all die Zweifler zu
+entwickeln. Den Gästefans wird vorgetäuscht mit ihren Bussen nach Bielefeld zu
+kommen, wo sie von IHNEN abgefangen werden, um direkt ins Stadion geleitet zu
+werden. Es besteht keine Chance sich die Stadt näher anzuschauen, und auch die
+Illusion des Heimpublikums wird durch eine größere Menge an bezahlten Statisten
+aufrechterhalten. Selbst ehemalige Top-Spieler, die Ihren Leistungszenit bei
+weitem überschritten haben, werden zu diesem Zweck von IHNEN mißbraucht. Mit
+genialen Manövern, u.a. vorgetäuschten Faustschlägen und Aufständen gegen das
+Präsidium eines baldigen Drittligisten wurde von langer Hand die wohl
+aufwendigste Täuschung aller Zeiten inszeniert. Es gibt noch mehr Beweise: Das
+sich im Rohbau befindende Stadion, das gefälschte und verpanschte Bier und nicht
+zuletzt die Tatsache, dass dieser Verein nur einen Sponsor hat. SIE, getarnt als
+Modefirma Gerry Weber."
+
+## Was steckt dahinter?
+
+Dies ist die Frage, auf die wir auch nach jahrelangen Untersuchungen immer noch
+keine befriedigende Antwort geben können. Allerdings gibt es einige Indizien,
+die auf bestimmte Gruppierungen hinweisen:
+
+- Es könnte eine Gruppe um den Sternenbruder und Weltenlehrer Ashtar Sheran
+  dahinterstecken, die an der Stelle, an der Bielefeld liegen soll, ihre Landung
+  vorbereiten, die - einschlägiger Fachliteratur zufolge - kurz bevorsteht. Zu
+  dieser Gruppe sollen auch Elvis und Kurt Cobain gehören, die beide - vom
+  schwedischen Geheimdienst gedeckt - noch am Leben sind.
+- An der Stelle, an der Bielefeld liegen soll, hält die CIA John F. Kennedy seit
+  dem angeblichen Attentat versteckt, damit er nichts über die vorgetäuschte
+  Mondlandung der NASA erzählen kann. Inwieweit die Reichsflugscheibenmacht von
+  ihrer Mond- oder Marsbasis aus da mitspielt, können wir nicht sagen, da alle
+  Beweise beim Abschuß der schwer bewaffneten Marssonde Observer vernichtet
+  wurden. Informationen hierüber besitzt vielleicht der Vatikan, der seit den
+  50er Jahren regelmäßig mit tachyonenangetriebenen Schiffen zum Mars fliegt.
+- Der MOSSAD in Zusammenarbeit mit dem OMEGA-Sektor planen an dieser Stelle die
+  Errichtung eines geheimen Forschungslabors, weil sich genau an diesem Ort zwei
+  noch nicht dokumentierte Ley-Linien kreuzen. Dort könnte auch der Jahrtausende
+  alte Tunnel nach Amerika und Australien (via Atlantis) seinen Eingang haben.
+  Wichtige Mitwisser, namentlich Uwe Barschel und Olof Palme, wurden von den mit
+  dem MOSSAD zusammenarbeitenden Geheimdiensten, darunter der Stasi und der
+  weniger bekannten 'Foundation', frühzeitig ausgeschaltet.
+- An der Stelle liegt die Höhle eines der schlafenden Drachen aus dem Vierten
+  Zeitalter, die auf das Erwachen der Magie am 24. Dezember 2011 (siehe hierzu
+  den Maya-Kalender) warten. Beschützt wird diese Stelle von den Rittern des
+  Ordenskreuzes AAORRAC, die sich inzwischen mit der Herstellung von
+  programmiertem Wasser beschäftigen - nach einen Rezept, das sie unter brutaler
+  Folter von Ann Johnson bekommen haben. Diese hatte es bekanntlich von hohen
+  Lichtwesen aus dem All erhalten, um die Menschheit vor außerirdischen
+  Implantaten bis Stufe 3 zu schützen.
+
+## Was können wir tun?
+
+Zum einen können wir alle an den Bundestag, das Europaparlament und die UNO
+schreiben, um endlich zu erreichen, dass SIE nicht mehr von den Politikern
+gedeckt werden. Da aber zu befürchten ist, dass SIE die Politik - so wie auch
+das organisierte Verbrechen und die großen Weltreligionen - unter Kontrolle
+haben, sind die Erfolgschancen dieses Weges doch eher zweifelhaft.
+
+Eine weitere Möglichkeit besteht darin, dass sich alle Bielefeldzweifler treffen
+und gemeinsam durch transzendentale Meditation (TM) soviel positive Ausstrahlung
+erzeugen, dass der Schwindel auffliegt. Eine ähnliche Vorgehensweise hat in
+Washington, D.C. für eine Senkung der Verbrechensrate um über 20% gesorgt.
+Besonders effektiv ist dies im Zusammenwirken mit Hopi-Kerzen im Ohr und
+Yogischem Schweben.
+
+Ab und zu nimmt in einer der eigentlich von IHNEN kontrollierten Zeitungen ein
+Redakteur allen Mut zusammen und riskiert es, in einer der Ausgaben zumindest
+andeutungsweise auf die Verschwörung hinzuweisen. So wurde in der FAZ Bielefeld
+als "Die Mutter aller Un-Städte" bezeichnet, und die taz überschrieb einen
+Artikel mit "Das Bermuda-Dreieck bei Bielefeld". Auf Nachfrage bekommt man dann
+natürlich zu hören, das habe man alles ganz anders gemeint, bei der taz hieß es
+sogar, es hätte in Wirklichkeit "Bitterfeld" heißen sollen, aber für einen
+kurzen Moment wurden die Leser darauf aufmerksam gemacht, dass mit Bielefeld
+etwas nicht stimmt. An dem Mut dieser Redakteure, über deren weiteres Schicksal
+uns leider nichts bekannt ist, sollten wir uns alle ein Beispiel nehmen.
+
+Das, was wir alle aber für uns im kleinen tun können, ist folgendes: Kümmert
+euch um die bedauernswerten Opfer der Gehirnwäsche, umsorgt sie, macht ihnen
+behutsam klar, dass sie einer Fehlinformation unterliegen. Und, bekennt euch
+alle immer offen, damit SIE merken, dass wir uns nicht länger täuschen lassen:
+**Bielefeld gibt es nicht!!!**

content/TODO.md

@@ -0,0 +1,5 @@
+---
+title: Todo
+---
+
+Todo List in backlinks below vvv

content/Uni/Extracurricular.md

@@ -0,0 +1,52 @@
+# Studium generale / University-Life
+
+(What I did at university besides studying :sunglasses: )
+
+## Committees / Student Body
+
+- Student Member of Studienbeirat Informatik (Study-Profile Commission)
+- Student Member of Tutorenauswahlkommission (Tutor-Selection Committee)
+  - Leader Tutorenevaluation (Evaluation of Tutors)
+- Student Member of NWI-Master-Auswahlausschuss (Master-Application Committee for
+   my course of study)
+- Student Member of NWI-Master-Prüfungsausschuss (Committee for Exam-disputes of
+  my Master course)
+- Member of the Admin-Team for the student-body pcs
+
+## ekvv-Links (entries in the electronic course-catalog)
+
+### Summer 15
+
+- [Fortgeschrittene funktionale Programmierung in Haskell](https://ekvv.uni-bielefeld.de/kvv_publ/publ/vd?id=54004629)
+  (Haskell-Lecture)
+  - [Lecture on YouTube](https://www.youtube.com/playlist?list=PLMqFm6rr-xOWhXGroUXzWx00FeaBNfbsa)
+  - [[FFPiH|more details on the lecture]]#
+
+### Summer 16
+
+- [Fortgeschrittene funktionale Programmierung in Haskell](https://ekvv.uni-bielefeld.de/kvv_publ/publ/vd?id=71172682)
+  (Haskell-Lecture)
+  - [Lecture on YouTube](https://www.youtube.com/playlist?list=PLMqFm6rr-xOUEf2YjSxRn8BIhrdRIhZw6)
+    (differs from link above)
+  - This was the **"silver chalk"-lecture**
+  - [[FFPiH|more details on the lecture]]#
+
+### Winter 16/17
+
+- [Richtig Starten](https://ekvv.uni-bielefeld.de/kvv_publ/publ/vd?id=84763664)
+  (Start Right!)
+- [Tutor Introduction to Machine Learning](https://ekvv.uni-bielefeld.de/kvv_publ/publ/vd?id=79599350)
+  (Tutor in this Lecture)
+  - Was awarded **Tutoring-Award** of the faculty
+- Remade and updated slides for [Computergraphics-Lecture](https://ekvv.uni-bielefeld.de/kvv_publ/publ/vd?id=79016005)
+  - Lecture was **awarded "silver chalk"** among others things because of the
+    updated slides.
+
+### Summer 17
+
+- [Fortgeschrittene funktionale Programmierung in Haskell](https://ekvv.uni-bielefeld.de/kvv_publ/publ/vd?id=94694136)
+  (Haskell-Lecture)
+  - Same as Summer 16
+  - Totally **reworked Exercises** accompanying the lecture
+  - [[FFPiH|more details on the lecture]]#
+

content/Uni/Lernerfolg_an_der_Uni.md

@@ -1,30 +1,84 @@
 # Wie lerne ich richtig an der Uni?
 
-Dies ist eine gute Frage. Da ich im laufe der Zeit einige Antworten gesammelt habe, wollte ich diese mal hier niederschreiben. Vorweg eine Warnung: **All das hier spiegelt nur meine persönlichen Erfahrungen aus Gesprächen wieder. Es kann sein, dass die z.B. für euren Fachbereich nicht gilt.** Da wir das nun aus dem Weg haben, geht es auch gleich los.
+Dies ist eine gute Frage. Da ich im laufe der Zeit einige Antworten gesammelt
+habe, wollte ich diese mal hier niederschreiben. Vorweg eine Warnung: **All das
+hier spiegelt nur meine persönlichen Erfahrungen aus Gesprächen wieder. Es kann
+sein, dass die z.B. für euren Fachbereich nicht gilt.** Da wir das nun aus dem
+Weg haben, geht es auch gleich los.
 
-# Uni ist nicht Schule
+## Uni ist nicht Schule
 
-Einige mögen sagen: "duh!", aber es ist erschreckend, wie viele Leute meinen, dass ihnen die Uni etwas schuldet oder das Dozenten und Tutoren dafür verantwortlich sind, dass man hier etwas lernt. Studium ist eine komplett freiwillige Veranstaltung. Man kann jederzeit sagen: "Passt mir nicht. Ich gehe."
-An der Uni wird erwartet, dass man sich ggf. einarbeitet, wenn man etwas nicht weiss; dass man Sekundärliteratur fragt (z.B. in Mathe auch mal in Bücher schaut um eine andere Erklärung zu bekommen, als der Prof an die Tafel geklatscht hat).
+Einige mögen sagen: "duh!", aber es ist erschreckend, wie viele Leute meinen,
+dass ihnen die Uni etwas schuldet oder das Dozenten und Tutoren dafür
+verantwortlich sind, dass man hier etwas lernt. Studium ist eine komplett
+freiwillige Veranstaltung. Man kann jederzeit sagen: "Passt mir nicht. Ich
+gehe." An der Uni wird erwartet, dass man sich ggf. einarbeitet, wenn man etwas
+nicht weiss; dass man Sekundärliteratur fragt (z.B. in Mathe auch mal in Bücher
+schaut um eine andere Erklärung zu bekommen, als der Prof an die Tafel
+geklatscht hat).
 
-# Etwas Lerntheorie
+## Etwas Lerntheorie
 
-Es gibt einen sehr schönen [Talk](https://yow.eventer.com/yow-2014-1222/stop-treading-water-learning-to-learn-by-edward-kmett-1750) von Edwand Kmett in dem er über seine Erfahrungen berichtet. Kurzum: Man lernt durch stete Wiederholung. Und der beste Moment etwas zu wiederholen ist, kurz bevor man es vergisst. Das stimmt ziemlich genau mit meiner Erfahrung überein.
+Es gibt einen sehr schönen
+[Talk](https://www.youtube.com/watch?v=Z8KcCU-p8QA)
+von Edwand Kmett in dem er über seine Erfahrungen berichtet. Kurzum: Man lernt
+durch stete Wiederholung. Und der beste Moment etwas zu wiederholen ist, kurz
+bevor man es vergisst. Das stimmt ziemlich genau mit meiner Erfahrung überein.
 
-## Auswendig lernen
+### Auswendig lernen
 
-Grade die oben genannte Theorie steht beim Auswendiglernen im Vordergrund. Wenn man etwas langfristig auswendig lernen will (Fremdsprachen, etc.), dann gibt es hierzu Software, die herausfindet, wann es der beste Zeitpunkt ist, dich wieder abzufragen: [Anki](http://ankisrs.net/) gibt es für jede Platform kostenlos (außer iPhone - hier 25$, weil Apple so viel Geld für das einstellen im AppStore haben will). Anki ist dazu gedacht, dass man zu jedem Thema einen Stapel hat (z.b. Klausurfragen, Sprachen, ...) und jeden Tag lernt. Nach einiger Zeit wird die vorhersage der Lernzeit ziemlich genau. Anfangs beantwortet man noch viele Fragen täglich, aber je häufiger man die Antworten kennt, desto weiter hinten landen sie im Stapel. Schlussendlich kommt dieselbe Frage dann nur noch 1x/Monat oder noch seltener.
+Grade die oben genannte Theorie steht beim Auswendiglernen im Vordergrund. Wenn
+man etwas langfristig auswendig lernen will (Fremdsprachen, etc.), dann gibt es
+hierzu Software, die herausfindet, wann es der beste Zeitpunkt ist, dich wieder
+abzufragen: [Anki](http://ankisrs.net/) gibt es für jede Platform kostenlos
+(außer iPhone - hier 25\$, weil Apple so viel Geld für das einstellen im AppStore
+haben will). Anki ist dazu gedacht, dass man zu jedem Thema einen Stapel hat
+(z.b. Klausurfragen, Sprachen, ...) und jeden Tag lernt. Nach einiger Zeit wird
+die vorhersage der Lernzeit ziemlich genau. Anfangs beantwortet man noch viele
+Fragen täglich, aber je häufiger man die Antworten kennt, desto weiter hinten
+landen sie im Stapel. Schlussendlich kommt dieselbe Frage dann nur noch 1x/Monat
+oder noch seltener.
 
-Ich benutze dies insbesondere zum Auswendiglernen von Fakten, Formeln, Fachbegriffen etc. Bei Mathe bietet sich zum Beispiel an einen Stapel mit allen Definitionen zu haben; in der Biologie eine Liste der Schema und Kreisläufe etc.
+Ich benutze dies insbesondere zum Auswendiglernen von Fakten, Formeln,
+Fachbegriffen etc. Bei Mathe bietet sich zum Beispiel an einen Stapel mit allen
+Definitionen zu haben; in der Biologie eine Liste der Schema und Kreisläufe etc.
 
-Man kann auch einen Hardcore-Lernmarathon machen. Meine letzten beiden Klausuren waren nur auf "bestehen" - also ohne Note. Ich habe mir eine alte Klausur organisiert (mehr genaues unten) und dann daraus Karten erstellt. Dies hat nur wenige Stunden gedauert (2-3 verteilt auf 2 Tage). Damit habe ich dann am Tag vor der Klausur 2x gelernt (1x nach dem Aufstehen, 1x vorm schlafengehen; jeweils nach 30 Minuten hatte ich alle Fragen min. 1x korrekt beantwortet). Am Morgen der Klausur hab ich die Fragen vor dem Aufstehen noch einmal durchgemacht (wieder 25-30 min), habe mir zur Klausur fertig gemacht und bin 30 Min vor der Klausur die Fragen nochmals durchgegangen (15-30 min), aber konnte sie mittlerweile alle auswendig. Insgesamt habe ich mit Anki so für die Klausur effektiv 2h gelernt (+2-3h für das erstellen der Karten), habe die Klausur geschrieben und mit einer 3.0 bestanden (also wäre 3.0 gewesen, wenn es nicht unbenotet gewesen wäre). Kommilitonen, die sich (nach eigener Aussage) 1-2 Wochen auf die Klausur vorbereitet haben und eine Note wollten, schnitten teilweise schlechter ab (viele aber auch viel besser).
+Man kann auch einen Hardcore-Lernmarathon machen. Meine letzten beiden Klausuren
+waren nur auf "bestehen" - also ohne Note. Ich habe mir eine alte Klausur
+organisiert (mehr genaues unten) und dann daraus Karten erstellt. Dies hat nur
+wenige Stunden gedauert (2-3 verteilt auf 2 Tage). Damit habe ich dann am Tag
+vor der Klausur 2x gelernt (1x nach dem Aufstehen, 1x vorm schlafengehen;
+jeweils nach 30 Minuten hatte ich alle Fragen min. 1x korrekt beantwortet). Am
+Morgen der Klausur hab ich die Fragen vor dem Aufstehen noch einmal durchgemacht
+(wieder 25-30 min), habe mir zur Klausur fertig gemacht und bin 30 Min vor der
+Klausur die Fragen nochmals durchgegangen (15-30 min), aber konnte sie
+mittlerweile alle auswendig. Insgesamt habe ich mit Anki so für die Klausur
+effektiv 2h gelernt (+2-3h für das erstellen der Karten), habe die Klausur
+geschrieben und mit einer 3.0 bestanden (also wäre 3.0 gewesen, wenn es nicht
+unbenotet gewesen wäre). Kommilitonen, die sich (nach eigener Aussage) 1-2
+Wochen auf die Klausur vorbereitet haben und eine Note wollten, schnitten
+teilweise schlechter ab (viele aber auch viel besser).
 
-## Methodik lernen
+### Methodik lernen
 
-Im Gegensatz zum plumpen auswendig lernen gibt es dann auch Anforderungen, wo es darum geht Methoden und Anwendungen zu verstehen. Inbesondere ist dies in Vorbereitung auf z.B. mündliche Prüfungen der Fall. Hier steht eher die Theorie im Vordergrund.
+Im Gegensatz zum plumpen auswendig lernen gibt es dann auch Anforderungen, wo es
+darum geht Methoden und Anwendungen zu verstehen. Inbesondere ist dies in
+Vorbereitung auf z.B. mündliche Prüfungen der Fall. Hier steht eher die Theorie
+im Vordergrund.
 
-Um solche Konzepte zu verstehen braucht es leider Zeit. Hier hilft kein 48h-Lernmarathon um das "mal eben" auf die Kette zu kriegen. Am besten bereitet man sich das gesamte Semester über vor (haha! Als ob! :p).
-Das "Geheimnis" hier liegt in einer Kombination der Ansätze. Zum einen muss man natürlich verstehen, worum es geht. Hier hilft es Definitionen und Fachbegriffe z.B. mit Anki zu lernen. Allerdings muss man sich zusätzlich noch nach jeder(!) Vorlesung hinsetzen und versuchen den Inhalt zu verdauen. Dies können nur 10 Minuten sein oder auch 2h. Hier kommen dann Dinge zum Tragen, wie Sekundärliteratur, Wikipedia, Google, ... Man muss die Zusammenhänge einmal verstehen - da kommt man nicht drumherum. ABER: Unser Gehirn arbeitet Assoziativ. Zusammenhänge sind meist logisch oder krass widersprüchlich. Hieraus kann man dann z.B. "Stichwortketten" bauen, von denen man nur das erste auswendig lernt und von da aus sich an den Rest "erinnert".
+Um solche Konzepte zu verstehen braucht es leider Zeit. Hier hilft kein
+48h-Lernmarathon um das "mal eben" auf die Kette zu kriegen. Am besten bereitet
+man sich das gesamte Semester über vor (haha! Als ob! :p). Das "Geheimnis" hier
+liegt in einer Kombination der Ansätze. Zum einen muss man natürlich verstehen,
+worum es geht. Hier hilft es Definitionen und Fachbegriffe z.B. mit Anki zu
+lernen. Allerdings muss man sich zusätzlich noch nach jeder(!) Vorlesung
+hinsetzen und versuchen den Inhalt zu verdauen. Dies können nur 10 Minuten sein
+oder auch 2h. Hier kommen dann Dinge zum Tragen, wie Sekundärliteratur,
+Wikipedia, Google, ... Man muss die Zusammenhänge einmal verstehen - da kommt
+man nicht drumherum. ABER: Unser Gehirn arbeitet Assoziativ. Zusammenhänge sind
+meist logisch oder krass widersprüchlich. Hieraus kann man dann z.B.
+"Stichwortketten" bauen, von denen man nur das erste auswendig lernt und von da
+aus sich an den Rest "erinnert".
 
 Kleines Beispiel aus der Welt der Mathematik:
 
@@ -34,54 +88,113 @@ Vektorraum -> Ist zu einer Basis definiert -> Basis ist die größtmögliche Zah
            -> Wird über einem Körper aufgespannt -> Körper sind 2 abelsche Gruppen mit Distributivgesetz -> abelsche Gruppe ist Menge mit K.A.I.N. -> ....
 ```
 
-So kann man sich über 5-6 Stichwörter fast am gesamten Stoff der Vorlesung entlanghangeln und merkt schnell, wo es hakt. Hier kann man dann nochmal gezielt nachhaken. Auch kann man bei so einer Struktur aus jedem "a -> b -> c" Anki-Karten machen mit "a" auf der Vorderseite, "b" auf der Rückseite bzw. "b" auf der Vorderseite und "c" auf der Rückseite und so gezielt diese "Ketten" trainieren. Grade in einer mündlichen Prüfung hangeln sich Prüfer ebenfalls an diesen Ketten entlang.
+So kann man sich über 5-6 Stichwörter fast am gesamten Stoff der Vorlesung
+entlanghangeln und merkt schnell, wo es hakt. Hier kann man dann nochmal gezielt
+nachhaken. Auch kann man bei so einer Struktur aus jedem "a -> b -> c"
+Anki-Karten machen mit "a" auf der Vorderseite, "b" auf der Rückseite bzw. "b"
+auf der Vorderseite und "c" auf der Rückseite und so gezielt diese "Ketten"
+trainieren. Grade in einer mündlichen Prüfung hangeln sich Prüfer ebenfalls an
+diesen Ketten entlang.
 
-# Vorbereiten auf eine Klausur
+## Vorbereiten auf eine Klausur
 
 - Herausfinden, um was für eine Art von Klausur es sich handelt
-    - Ankreuzklausur?
-    - Auswendiglern-Klausur?
-    - Praktische Klausur (z.b. fast 1:1 Übungsaufgaben, feste Schema, ..)?
-    - Open-Book?
-    - Annotation von Grafiken?
+  - Ankreuzklausur?
+  - Auswendiglern-Klausur?
+  - Praktische Klausur (z.b. fast 1:1 Übungsaufgaben, feste Schema, ..)?
+  - Open-Book?
+  - Annotation von Grafiken?
 - Klausuren von der Fachschaft organisieren
-    - Falls keine Vorhanden: Altfachschaftler fragen, wie die Klausur bei ihnen war
-    - Neue Klausur mit in die FS bringen, falls möglich (z.b. schreiend rausrennen und Klausur dabei mitnehmen, bevor man offiziell registriert wurde)
+  - Falls keine Vorhanden: Altfachschaftler fragen, wie die Klausur bei ihnen war
+  - Neue Klausur mit in die FS bringen, falls möglich (z.b. schreiend rausrennen
+    und Klausur dabei mitnehmen, bevor man offiziell registriert wurde)
 
-Je nach Klausurtyp dann mit Anki stumpf Karten machen und auswendig lernen (z.b. Ankreuzklausur, Grafik-annotations-Klausur, ..) oder Übungsaufgaben/Altklausuren durchrechnen
+Je nach Klausurtyp dann mit Anki stumpf Karten machen und auswendig lernen (z.b.
+Ankreuzklausur, Grafik-annotations-Klausur, ..) oder Übungsaufgaben/Altklausuren
+durchrechnen
 
-# Vorbereiten auf eine mündliche Prüfung
+## Vorbereiten auf eine mündliche Prüfung
 
 - Protokolle aus der Fachschaft organisieren
-    - Häufig gegen Pfand, dass man bei Abgabe eines Protokolls wieder bekommt
-    - Wenn keins vorhanden für die nachfolgede Generation eins ausfüllen
+  - Häufig gegen Pfand, dass man bei Abgabe eines Protokolls wieder bekommt
+  - Wenn keins vorhanden für die nachfolgede Generation eins ausfüllen
 
-Wenn ihr einen Reihe von Protokollen vorliegen habt, dann schreibt alle Fragen heraus und notiert, wie häufig diese Frage gestellt wurde. So findet ihr heraus, auf welche Punkte der Prüfer besonders Wert legt (z.B. häufig sein eigenes Forschungsfeld). Diese Fragen dann restlos klären und zu Anki-Karten verarbeiten. Das reicht meistens für ein Bestehen. Wenn ihr auf eine gute Note wert legt, dann solltet ihr auch noch die Vorlesung, wie im Bereich "Methodik lernen" erwähnt, nacharbeiten. Insbesondere helfen hier die Assoziationsketten weiter den Stoff auch in der Prüfung in der richtigen Reihenfolge abzurufen. Vielleicht erkennt ihr solche Ketten schon aus den Prüfungsprotokollen und könnt euch ausmalen, wie man z.b. von da aus auf andere Themen der Vorlesung kommt (die z.b. neu sind oder überarbeitet wurden).
+Wenn ihr einen Reihe von Protokollen vorliegen habt, dann schreibt alle Fragen
+heraus und notiert, wie häufig diese Frage gestellt wurde. So findet ihr heraus,
+auf welche Punkte der Prüfer besonders Wert legt (z.B. häufig sein eigenes
+Forschungsfeld). Diese Fragen dann restlos klären und zu Anki-Karten
+verarbeiten. Das reicht meistens für ein Bestehen. Wenn ihr auf eine gute Note
+wert legt, dann solltet ihr auch noch die Vorlesung, wie im Bereich "Methodik
+lernen" erwähnt, nacharbeiten. Insbesondere helfen hier die Assoziationsketten
+weiter den Stoff auch in der Prüfung in der richtigen Reihenfolge abzurufen.
+Vielleicht erkennt ihr solche Ketten schon aus den Prüfungsprotokollen und könnt
+euch ausmalen, wie man z.b. von da aus auf andere Themen der Vorlesung kommt
+(die z.b. neu sind oder überarbeitet wurden).
 
-## Unterschiede mündliche Bachelor/Master-Prüfungen
+### Unterschiede mündliche Bachelor/Master-Prüfungen
 
-Einige Dozenten machen unterschiedliche Anforderungen, ob sie einen Bachelor oder einen Master-Studenten prüfen. Abgesehen von der anderen Prüfungszeit (15-30min bei bachelor, 25-45 bei Master) ist hier auch das Vorgehen anders.
-Bei einem Bachelor wird klassischerweise alles oberflächlich abgefragt und nur wenig in die Tiefe gegangen. Bei einem Master wir nur noch stichpunktartig gefragt, dafür aber bis ins Detail.
+Einige Dozenten machen unterschiedliche Anforderungen, ob sie einen Bachelor
+oder einen Master-Studenten prüfen. Abgesehen von der anderen Prüfungszeit
+(15-30min bei bachelor, 25-45 bei Master) ist hier auch das Vorgehen anders. Bei
+einem Bachelor wird klassischerweise alles oberflächlich abgefragt und nur wenig
+in die Tiefe gegangen. Bei einem Master wir nur noch stichpunktartig gefragt,
+dafür aber bis ins Detail.
 
-Beispiel: Ich hatte eine mündliche Masterprüfung, bei der in der Vorlesung 7 verschiedene Themen behandelt wurden. In der Prüfung wurden dann nur die Themenübersicht abgefragt und bei 2 Themen komplett in die Tiefe gegangen - inkl. Formeln, Bedeutung, Übertragung auf in der Vorlesung nicht angesprochene Aspekte etc. Die anderen 5 Themen kamen nicht dran.
-Bei meinen Bachelorprüfungen war das eher umgekehrt: Hier wurde sich grob an der Vorlesung entlang gehangelt und zumindest alles einmal kurz angetestet, ob die zentralen Inhalte der Vorlesung verstanden wurden.
+Beispiel: Ich hatte eine mündliche Masterprüfung, bei der in der Vorlesung 7
+verschiedene Themen behandelt wurden. In der Prüfung wurden dann nur die
+Themenübersicht abgefragt und bei 2 Themen komplett in die Tiefe gegangen -
+inkl. Formeln, Bedeutung, Übertragung auf in der Vorlesung nicht angesprochene
+Aspekte etc. Die anderen 5 Themen kamen nicht dran. Bei meinen Bachelorprüfungen
+war das eher umgekehrt: Hier wurde sich grob an der Vorlesung entlang gehangelt
+und zumindest alles einmal kurz angetestet, ob die zentralen Inhalte der
+Vorlesung verstanden wurden.
 
-Dies hat häufig auch damit zu tun, dass man im Bachelor eher Grundlagen hört und somit ein grobes Verständnis aller Dinge wichtig ist, während im Master auf die Aneignung von Tiefenwissen ankommt.
+Dies hat häufig auch damit zu tun, dass man im Bachelor eher Grundlagen hört und
+somit ein grobes Verständnis aller Dinge wichtig ist, während im Master auf die
+Aneignung von Tiefenwissen ankommt.
 
-# Prüfungsangt
+## Prüfungsangt
 
-Zu guter Letzt noch ein paar Worte zum Thema Prüfungsangst. Es ist normal, dass man vor einer Prüfung angespannt ist. Es ist nicht normal, wenn die Anspannung so ausartet, dass man sich übergibt, Krämpfe bekommt oder ähnlich starke Symptome zeigt. Ich leide selbst an solchen Problemen und habe mich schon mehrfach vor Prüfungen übergeben.
-Eine klassische Konfrontationstherapie funktioniert aufgrund der Seltenheit der Prüfungen nicht oder nur sehr schwer. Ich habe mich an meinen Arzt gewendet und habe nun genau für solche Situationen ein Medikament. 1-2h vor einer Prüfung nehme ich das und komme in einen komischen Zustand. Ich merke zwar noch, dass ich Angespannt bin und eigentlich Angst hätte, aber es "stört" mich nicht wirklich. Es versetzt mich nicht in Panik oder sonstwas. Es schaltet mein Gehirn nicht aus oder hat andere negative Effekte. Natürlich geht das auch mit Nachteilen einher: ein paar Tage keinen Alkohol, kein Auto fahren, etc. - Aber meist ist das ja nur 2-3x/Semester der Fall.
-Wenn man nicht so stark betroffen ist, dann ist davon allerdings abzuraten. Das Medikament gleicht die Panik durch Gelassenheit aus - wenn man keine Panik hat, dann wird man hierdurch so "gelassen" dass man mehrere Stunden einschläft - was in einer Prüfung vielleicht nicht ganz so gut ist ;)
+Zu guter Letzt noch ein paar Worte zum Thema Prüfungsangst. Es ist normal, dass
+man vor einer Prüfung angespannt ist. Es ist nicht normal, wenn die Anspannung
+so ausartet, dass man sich übergibt, Krämpfe bekommt oder ähnlich starke
+Symptome zeigt. Ich leide selbst an solchen Problemen und habe mich schon
+mehrfach vor Prüfungen übergeben. Eine klassische Konfrontationstherapie
+funktioniert aufgrund der Seltenheit der Prüfungen nicht oder nur sehr schwer.
+Ich habe mich an meinen Arzt gewendet und habe nun genau für solche Situationen
+ein Medikament. 1-2h vor einer Prüfung nehme ich das und komme in einen
+komischen Zustand. Ich merke zwar noch, dass ich Angespannt bin und eigentlich
+Angst hätte, aber es "stört" mich nicht wirklich. Es versetzt mich nicht in
+Panik oder sonstwas. Es schaltet mein Gehirn nicht aus oder hat andere negative
+Effekte. Natürlich geht das auch mit Nachteilen einher: ein paar Tage keinen
+Alkohol, kein Auto fahren, etc. - Aber meist ist das ja nur 2-3x/Semester der
+Fall. Wenn man nicht so stark betroffen ist, dann ist davon allerdings
+abzuraten. Das Medikament gleicht die Panik durch Gelassenheit aus - wenn man
+keine Panik hat, dann wird man hierdurch so "gelassen" dass man mehrere Stunden
+einschläft - was in einer Prüfung vielleicht nicht ganz so gut ist ;)
 
-Es gibt auch zahlreiche Regularien und Rechtsansprüche, die ihr bei sowas habt. Ihr habt zum Beispiel (sofern ein (Amts?-)Arzt eine Prüfungsangst bestätigt hat) Anspruch auf mehr Prüfungszeit, die Prüfung alleine abzulegen (z.b. bei einem Mitarbeiter, während andere im Hörsaal schreiben), eine mündliche durch eine schriftliche zu tauschen (oder umgekehrt), etc. Das kann man individuell mit dem Prüfer absprechen. Ich weiss nicht, wie das in anderen Fakultäten läuft - aber in der Technischen Fakultät hat fast jeder Prüfer dafür volles Verständnis (einige litten sogar früher selbst an sowas).
+Es gibt auch zahlreiche Regularien und Rechtsansprüche, die ihr bei sowas habt.
+Ihr habt zum Beispiel (sofern ein (Amts?-)Arzt eine Prüfungsangst bestätigt hat)
+Anspruch auf mehr Prüfungszeit, die Prüfung alleine abzulegen (z.b. bei einem
+Mitarbeiter, während andere im Hörsaal schreiben), eine mündliche durch eine
+schriftliche zu tauschen (oder umgekehrt), etc. Das kann man individuell mit dem
+Prüfer absprechen. Ich weiss nicht, wie das in anderen Fakultäten läuft - aber
+in der Technischen Fakultät hat fast jeder Prüfer dafür volles Verständnis
+(einige litten sogar früher selbst an sowas).
 
-Die kostenlose psychologische Beratung an der Uni (aka. "Das rote Sofa" im X) bietet hier auch Hilfestellung bei und vermittelt in schwereren Fällen auch gleich noch eine Therapie/Ärzte. Hier kann man z.b. Prüfungssimulationen abhalten oder sich Hilfe holen, wenn ein Dozent sich querstellt. Die Mitarbeiter begleiten einen z.B. auch zu einer Prüfung (nach Absprache mit dem Veranstalter), falls das hilft, etc.
+Die kostenlose psychologische Beratung an der Uni (aka. "Das rote Sofa" im X)
+bietet hier auch Hilfestellung bei und vermittelt in schwereren Fällen auch
+gleich noch eine Therapie/Ärzte. Hier kann man z.b. Prüfungssimulationen
+abhalten oder sich Hilfe holen, wenn ein Dozent sich querstellt. Die Mitarbeiter
+begleiten einen z.B. auch zu einer Prüfung (nach Absprache mit dem
+Veranstalter), falls das hilft, etc.
 
-Es ist keine Schande so ein Problem zu haben und es gibt genug, die sich damit rumschlagen. Aber man ist hier an der Uni auch nicht alleine damit. Es gibt zahlreiche Hilfsangebote.
+Es ist keine Schande so ein Problem zu haben und es gibt genug, die sich damit
+rumschlagen. Aber man ist hier an der Uni auch nicht alleine damit. Es gibt
+zahlreiche Hilfsangebote.
 
-Ein kleiner Hinweis hier noch auf das [Prüfungsangst-Stipendium](http://www.eurocentres.com/de/pr%C3%BCfungsangst-stipendium), dass einem eine Belohnung gibt, wenn man sich seinen Ängsten stellt und sie überwindet. :)
+## Schlusswort
 
-# Schlusswort
-
-Viel Erfolg bei euren Prüfungen. Falls euch dieser Artikel geholfen hat oder ihr noch Anregungen/Verbessenguswünsche habt, schreibt mir einfach unter `sdressel@techfak.uni-bi...`, ich werde die dann einbauen.
+Viel Erfolg bei euren Prüfungen. Falls euch dieser Artikel geholfen hat oder ihr
+noch Anregungen/Verbessenguswünsche habt, schreibt mir einfach unter
+`sdressel@techfak.uni-bi...`, ich werde die dann einbauen.

content/index.md

@@ -1,3 +1,8 @@
-Unsortierte Einsichten und Erfahrungen. Archiviert zum verlinken, späteren Überdenken oder Diskutieren.
+# Home
 
-Keine Garantie auf Richtigkeit oder Trollfreiheit :D
+Unsortierte Einsichten und Erfahrungen. Archiviert zum verlinken, späteren
+Überdenken oder Diskutieren.
+
+Keine Garantie auf Richtigkeit oder Trollfreiheit :grin:
+
+<a rel="me" href="https://toot.kif.rocks/@Drezil"></a>

content/index.yaml

@@ -9,17 +9,14 @@ page:
     <snippet var="js.highlightjs" />
 
 template:
-  theme: red
+  theme: purple
 
   # You can add your own variables here, like editBaseUrl.
   # See after-note.tpl to see where editBaseUrl gets used.
   # editBaseUrl: https://github.com/srid/emanote-template/edit/master/content
 
   # Uncomment this to get neuron-style pages
-  name: /templates/layouts/note
-  layout:
-    note:
-      containerClass: container mx-auto max-w-screen-lg
+  name: /templates/layouts/myNote
 
   sidebar:
     collapsed: false

content/templates/filters/embed-note.tpl

@@ -0,0 +1,14 @@
+<section title="Embedded note" class="p-4 mx-2 mb-2 bg-white border-2 rounded-lg shadow-inner">
+  <details>
+    <summary class="flex items-center justify-center text-2xl italic bg-${theme}-50 rounded py-1 px-2 mb-3" >
+      <header style="display:list-item">
+        <a href="${ema:note:url}">
+          <ema:note:title />
+        </a>
+      </header>
+    </summary>
+    <div>
+      <apply template="/templates/components/pandoc" />
+    </div>
+  </details>
+</section>

content/templates/layouts/myNote.tpl

@@ -0,0 +1,85 @@
+<apply template="base">
+   <bind tag="head-main">
+    <link rel="stylesheet" href="${ema:emanoteStaticLayerUrl}/inverted-tree.css" />
+  </bind>
+  <bind tag="body-main">
+    <div class="container mx-auto">
+
+      <apply template="components/breadcrumbs" />
+
+      <div id="container"
+        class="flex flex-nowrap flex-col md:flex-row bg-gray-50 md:mt-8 md:shadow-2xl md:mb-8">
+        <!-- Sidebar column -->
+        <nav id="sidebar"
+          class="flex-shrink hidden leading-relaxed md:block md:sticky md:top-0 md:h-full md:w-48 xl:w-64">
+          <div class="px-2 py-2 text-gray-800">
+            <div id="indexing-links" class="flex flex-row float-right p-2 space-x-2 text-gray-500">
+              <a href="${ema:tagIndexUrl}" title="View tags">
+                <svg style="width: 1rem;" class="hover:text-${theme}-700" fill="none"
+                  stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+                  <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                    d="M7 7h.01M7 3h5c.512 0 1.024.195 1.414.586l7 7a2 2 0 010 2.828l-7 7a2 2 0 01-2.828 0l-7-7A1.994 1.994 0 013 12V7a4 4 0 014-4z">
+                  </path>
+                </svg>
+              </a>
+              <a href="${ema:indexUrl}" title="Expand full tree">
+                <svg style="width: 1rem;" class="hover:text-${theme}-700" fill="none"
+                  stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+                  <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                    d="M4 8V4m0 0h4M4 4l5 5m11-1V4m0 0h-4m4 0l-5 5M4 16v4m0 0h4m-4 0l5-5m11 5l-5-5m5 5v-4m0 4h-4">
+                  </path>
+                </svg>
+              </a>
+              <a title="Search (Ctrl+K)" class="cursor-pointer"
+                onclick="window.emanote.stork.toggleSearch()">
+                <apply template="components/stork/stork-icon" />
+              </a>
+            </div>
+
+            <div id="site-logo" class="pl-2">
+              <div class="flex items-center my-2 space-x-2 justify-left">
+                <a href="${ema:homeUrl}" title="Go to Home">
+                  <ema:metadata>
+                    <with var="template">
+                      <!-- The style width attribute here is to prevent huge
+                      icon from displaying at those rare occasions when Tailwind
+                      hasn't kicked in immediately on page load 
+                      -->
+                      <img style="width: 1rem;"
+                        class="transition transform hover:scale-110 hover:opacity-80"
+                        src="${value:iconUrl}" />
+                    </with>
+                  </ema:metadata>
+                </a>
+                <a class="font-bold truncate" title="Go to Home" href="${ema:homeUrl}">
+                  Home
+                </a>
+              </div>
+            </div>
+
+            <ema:route-tree>
+              <apply template="components/sidebar-tree" />
+            </ema:route-tree>
+
+          </div>
+        </nav>
+
+        <!-- Main body column -->
+        <div class="flex-1 w-full overflow-x-auto bg-white">
+          <main class="px-4 py-4">
+            <apply template="components/note-uptree" />
+            <apply template="components/note-title" />
+            <apply template="components/note-body" />
+            <div class="flex flex-col lg:flex-row lg:space-x-2">
+              <apply template="components/timeline" />
+              <apply template="components/backlinks" />
+            </div>
+            <apply template="components/metadata" />
+            <apply template="/templates/hooks/note-end" />
+          </main>
+        </div>
+      </div>
+      <apply template="components/footer" />
+    </div>
+  </bind>
+</apply>

fixPermissions.bash

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+chgrp -R www-data static_gen/
+
+fix_dirs()
+{
+	local IFS=$'\n'
+       	for line in `find static_gen/ -type d`;	do
+		chmod g+s ${line}
+        done
+}
+
+fix_dirs

flake.lock

@@ -1,57 +1,134 @@
 {
   "nodes": {
-    "ema": {
-      "flake": false,
+    "check-flake": {
       "locked": {
-        "lastModified": 1660941244,
-        "narHash": "sha256-gGhvmSjjr07u8uWaBIv6F5WE+VCGngSVXN9mhb4BmQo=",
+        "lastModified": 1662502605,
+        "narHash": "sha256-jAT55UhabAxLAVGanxjnNdzH2/oX2ZjLsL4i2jPIP+g=",
         "owner": "srid",
-        "repo": "ema",
-        "rev": "d74daa4d0d1f7a14cebd415787166fe7909fc33b",
+        "repo": "check-flake",
+        "rev": "48a17393ed4fcd523399d6602c283775b5127295",
+        "type": "github"
+      },
+      "original": {
+        "owner": "srid",
+        "repo": "check-flake",
+        "type": "github"
+      }
+    },
+    "devenv": {
+      "inputs": {
+        "flake-compat": "flake-compat",
+        "nix": "nix",
+        "nixpkgs": "nixpkgs",
+        "pre-commit-hooks": "pre-commit-hooks"
+      },
+      "locked": {
+        "lastModified": 1688728027,
+        "narHash": "sha256-qyMvHtzm7BRtwA5TBE+syQbIDNyEpfqmsHwEV+PBe+o=",
+        "owner": "cachix",
+        "repo": "devenv",
+        "rev": "9ba9e3b908a12ddc6c43f88c52f2bf3c1d1e82c1",
+        "type": "github"
+      },
+      "original": {
+        "owner": "cachix",
+        "repo": "devenv",
+        "rev": "9ba9e3b908a12ddc6c43f88c52f2bf3c1d1e82c1",
+        "type": "github"
+      }
+    },
+    "ema": {
+      "inputs": {
+        "check-flake": [
+          "emanote",
+          "check-flake"
+        ],
+        "flake-parts": [
+          "emanote",
+          "flake-parts"
+        ],
+        "flake-root": [
+          "emanote",
+          "flake-root"
+        ],
+        "haskell-flake": [
+          "emanote",
+          "haskell-flake"
+        ],
+        "nixpkgs": [
+          "emanote",
+          "nixpkgs"
+        ],
+        "treefmt-nix": [
+          "emanote",
+          "treefmt-nix"
+        ]
+      },
+      "locked": {
+        "lastModified": 1678746319,
+        "narHash": "sha256-vOh7o0AK2PohGa1LPTAGIPmua1beR67XowEcaI8UPhg=",
+        "owner": "srid",
+        "repo": "ema",
+        "rev": "b46a08d7a26491b9801642ab9c13e94f929c6a90",
         "type": "github"
       },
       "original": {
         "owner": "srid",
-        "ref": "master",
         "repo": "ema",
         "type": "github"
       }
     },
     "emanote": {
       "inputs": {
+        "check-flake": "check-flake",
         "ema": "ema",
         "flake-parts": "flake-parts",
+        "flake-root": "flake-root",
         "haskell-flake": "haskell-flake",
-        "nixpkgs": "nixpkgs",
-        "tailwind-haskell": "tailwind-haskell"
+        "nixpkgs": "nixpkgs_2",
+        "systems": "systems_2",
+        "treefmt-nix": "treefmt-nix"
       },
       "locked": {
-        "lastModified": 1661096607,
-        "narHash": "sha256-DtSvkXRTsILCcWGcmP50fLupGroAP7EJVk3da+5yLvU=",
-        "owner": "EmaApps",
+        "lastModified": 1688491882,
+        "narHash": "sha256-b3hIpvCGTIWIOvkFJbkrBmlifF8JGVlOOJElE2NKKe0=",
+        "owner": "srid",
         "repo": "emanote",
-        "rev": "aad6e789829ce35b042ea6fcc728ae0b76086dd8",
+        "rev": "d1dd7ea4ad89dc74f8d4b90650e07e788b489bb6",
         "type": "github"
       },
       "original": {
-        "owner": "EmaApps",
+        "owner": "srid",
         "repo": "emanote",
         "type": "github"
       }
     },
+    "flake-compat": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1673956053,
+        "narHash": "sha256-4gtG9iQuiKITOjNQQeQIpoIB6b16fm+504Ch3sNKLd8=",
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "35bb57c0c8d8b62bbfd284272c928ceb64ddbde9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
     "flake-parts": {
       "inputs": {
-        "nixpkgs": [
-          "emanote",
-          "nixpkgs"
-        ]
+        "nixpkgs-lib": "nixpkgs-lib"
       },
       "locked": {
-        "lastModified": 1657102481,
-        "narHash": "sha256-62Fuw8JgPub38OdgNefkIKOodM9nC3M0AG6lS+7smf4=",
+        "lastModified": 1671710971,
+        "narHash": "sha256-YZdt5IJrfsdUTtVB94EMsBvaJbK9ve6QaZyzRuup+sY=",
         "owner": "hercules-ci",
         "repo": "flake-parts",
-        "rev": "608ed3502263d6f4f886d75c48fc2b444a4ab8d8",
+        "rev": "98bec08c58a9547d705f2f5e300ac8eef6665e52",
         "type": "github"
       },
       "original": {
@@ -60,49 +137,68 @@
         "type": "github"
       }
     },
-    "flake-parts_2": {
-      "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ]
-      },
+    "flake-root": {
       "locked": {
-        "lastModified": 1661009076,
-        "narHash": "sha256-phAE40gctVygRq3G3B6LhvD7u2qdQT21xsz8DdRDYFo=",
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
-        "rev": "850d8a76026127ef02f040fb0dcfdb8b749dd9d9",
+        "lastModified": 1671378805,
+        "narHash": "sha256-yqGxyzMN2GuppwG3dTWD1oiKxi+jGYP7D1qUSc5vKhI=",
+        "owner": "srid",
+        "repo": "flake-root",
+        "rev": "dc7ba6166e478804a9da6881aa48c45d300075cf",
         "type": "github"
       },
       "original": {
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
+        "owner": "srid",
+        "repo": "flake-root",
         "type": "github"
       }
     },
     "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
       "locked": {
-        "lastModified": 1652776076,
-        "narHash": "sha256-gzTw/v1vj4dOVbpBSJX4J0DwUR6LIyXo7/SuuTJp1kM=",
+        "lastModified": 1685518550,
+        "narHash": "sha256-o2d0KcvaXzTrPRIo0kOLV0/QXHhDQ5DTi+OxcjO8xqY=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "04c1b180862888302ddfb2e3ad9eaa63afc60cf8",
+        "rev": "a1720a10a6cfe8234c0e93907ffe81be440f4cef",
         "type": "github"
       },
       "original": {
         "owner": "numtide",
-        "ref": "v1.0.0",
         "repo": "flake-utils",
         "type": "github"
       }
     },
+    "gitignore": {
+      "inputs": {
+        "nixpkgs": [
+          "devenv",
+          "pre-commit-hooks",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1660459072,
+        "narHash": "sha256-8DFJjXG8zqoONA1vXtgeKXy68KdJL5UaXR8NtVMUbx8=",
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "rev": "a20de23b925fd8264fd7fad6454652e142fd7f73",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "type": "github"
+      }
+    },
     "haskell-flake": {
       "locked": {
-        "lastModified": 1660319056,
-        "narHash": "sha256-MX6PLEtXVyXXUEk3t1e0c20XRL4m4u9TFET2X0TpTdE=",
+        "lastModified": 1685469326,
+        "narHash": "sha256-esxJLsGexI/J6Fc32tJd2p3K5IOBZSCHgFvegjIpc+0=",
         "owner": "srid",
         "repo": "haskell-flake",
-        "rev": "1ca2be3c354ef2a3296cac7e54ae21e1d6ead6d7",
+        "rev": "996f5c2cdc67285c4990df378976f9dbf26f8401",
         "type": "github"
       },
       "original": {
@@ -111,49 +207,243 @@
         "type": "github"
       }
     },
+    "lowdown-src": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1633514407,
+        "narHash": "sha256-Dw32tiMjdK9t3ETl5fzGrutQTzh2rufgZV4A/BbxuD4=",
+        "owner": "kristapsdz",
+        "repo": "lowdown",
+        "rev": "d2c2b44ff6c27b936ec27358a2653caaef8f73b8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "kristapsdz",
+        "repo": "lowdown",
+        "type": "github"
+      }
+    },
+    "nix": {
+      "inputs": {
+        "lowdown-src": "lowdown-src",
+        "nixpkgs": [
+          "devenv",
+          "nixpkgs"
+        ],
+        "nixpkgs-regression": "nixpkgs-regression"
+      },
+      "locked": {
+        "lastModified": 1676545802,
+        "narHash": "sha256-EK4rZ+Hd5hsvXnzSzk2ikhStJnD63odF7SzsQ8CuSPU=",
+        "owner": "domenkozar",
+        "repo": "nix",
+        "rev": "7c91803598ffbcfe4a55c44ac6d49b2cf07a527f",
+        "type": "github"
+      },
+      "original": {
+        "owner": "domenkozar",
+        "ref": "relaxed-flakes",
+        "repo": "nix",
+        "type": "github"
+      }
+    },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1659077768,
-        "narHash": "sha256-P0XIHBVty6WIuIrk2DZNvLcYev9956y1prT4zL212H8=",
-        "path": "/nix/store/1ha33ma070pyxw5kkcx61qi7ypzzxzah-source",
-        "rev": "2a93ea177c3d7700b934bf95adfe00c435f696b8",
-        "type": "path"
+        "lastModified": 1678875422,
+        "narHash": "sha256-T3o6NcQPwXjxJMn2shz86Chch4ljXgZn746c2caGxd8=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "126f49a01de5b7e35a43fd43f891ecf6d3a51459",
+        "type": "github"
       },
       "original": {
-        "id": "nixpkgs",
-        "type": "indirect"
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-lib": {
+      "locked": {
+        "dir": "lib",
+        "lastModified": 1671359686,
+        "narHash": "sha256-3MpC6yZo+Xn9cPordGz2/ii6IJpP2n8LE8e/ebUXLrs=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "04f574a1c0fde90b51bf68198e2297ca4e7cccf4",
+        "type": "github"
+      },
+      "original": {
+        "dir": "lib",
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-regression": {
+      "locked": {
+        "lastModified": 1643052045,
+        "narHash": "sha256-uGJ0VXIhWKGXxkeNnq4TvV3CIOkUJ3PAoLZ3HMzNVMw=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",
+        "type": "github"
+      }
+    },
+    "nixpkgs-stable": {
+      "locked": {
+        "lastModified": 1685801374,
+        "narHash": "sha256-otaSUoFEMM+LjBI1XL/xGB5ao6IwnZOXc47qhIgJe8U=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "c37ca420157f4abc31e26f436c1145f8951ff373",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-23.05",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1687245362,
+        "narHash": "sha256-+f9tH+k3u9lSS136M2LCsl5NJTNPvhmHEiVOcypiu1E=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "205ee073b053fc4d87d5adf2ebd44ebbef7bca4d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_3": {
+      "locked": {
+        "lastModified": 1696039360,
+        "narHash": "sha256-g7nIUV4uq1TOVeVIDEZLb005suTWCUjSY0zYOlSBsyE=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "32dcb45f66c0487e92db8303a798ebc548cadedc",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-23.05",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "pre-commit-hooks": {
+      "inputs": {
+        "flake-compat": [
+          "devenv",
+          "flake-compat"
+        ],
+        "flake-utils": "flake-utils",
+        "gitignore": "gitignore",
+        "nixpkgs": [
+          "devenv",
+          "nixpkgs"
+        ],
+        "nixpkgs-stable": "nixpkgs-stable"
+      },
+      "locked": {
+        "lastModified": 1688056373,
+        "narHash": "sha256-2+SDlNRTKsgo3LBRiMUcoEUb6sDViRNQhzJquZ4koOI=",
+        "owner": "cachix",
+        "repo": "pre-commit-hooks.nix",
+        "rev": "5843cf069272d92b60c3ed9e55b7a8989c01d4c7",
+        "type": "github"
+      },
+      "original": {
+        "owner": "cachix",
+        "repo": "pre-commit-hooks.nix",
+        "type": "github"
       }
     },
     "root": {
       "inputs": {
+        "devenv": "devenv",
         "emanote": "emanote",
-        "flake-parts": "flake-parts_2",
-        "nixpkgs": [
-          "emanote",
-          "nixpkgs"
-        ]
+        "nixpkgs": "nixpkgs_3",
+        "systems": "systems_3"
       }
     },
-    "tailwind-haskell": {
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "systems_2": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "systems_3": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "treefmt-nix": {
       "inputs": {
-        "flake-utils": "flake-utils",
         "nixpkgs": [
           "emanote",
           "nixpkgs"
         ]
       },
       "locked": {
-        "lastModified": 1658431129,
-        "narHash": "sha256-AtTxP0AMXdeU0ZTJP5R1lCtx5az3ejrmGP1klEdu1qU=",
-        "owner": "srid",
-        "repo": "tailwind-haskell",
-        "rev": "09a102164b1a4559892277ff38efdc9b949c5433",
+        "lastModified": 1675588998,
+        "narHash": "sha256-CLeFLmah0mxNp/EIW0PMG3YutKxVIIs4B0f5oJhwe8E=",
+        "owner": "numtide",
+        "repo": "treefmt-nix",
+        "rev": "70e03145e26c2f3199f4320ecd9fd343f1129c60",
         "type": "github"
       },
       "original": {
-        "owner": "srid",
-        "ref": "master",
-        "repo": "tailwind-haskell",
+        "owner": "numtide",
+        "repo": "treefmt-nix",
         "type": "github"
       }
     }

flake.nix

@@ -1,38 +1,78 @@
 {
-  nixConfig.extra-substituters = "https://cache.garnix.io";
-  nixConfig.extra-trusted-public-keys = "cache.garnix.io:CTFPyKSLcx5RMJKfLo5EEPUObbA78b0YQ2DTCJXqr9g=";
-
   inputs = {
-    emanote.url = "github:EmaApps/emanote";
-    nixpkgs.follows = "emanote/nixpkgs";
-    flake-parts.url = "github:hercules-ci/flake-parts";
-    flake-parts.inputs.nixpkgs.follows = "nixpkgs";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-23.05";
+    systems.url = "github:nix-systems/default";
+    devenv.url = "github:cachix/devenv/9ba9e3b908a12ddc6c43f88c52f2bf3c1d1e82c1"; # until https://github.com/cachix/devenv/issues/756 is fixed
+    emanote.url = "github:srid/emanote";
   };
 
-  outputs = inputs@{ self, flake-parts, nixpkgs, ... }:
-    flake-parts.lib.mkFlake { inherit self; } {
-      systems = nixpkgs.lib.systems.flakeExposed;
-      imports = [
-        inputs.emanote.flakeModule
-      ];
-      perSystem = { self', pkgs, system, ... }: {
-        emanote = {
-          # By default, the 'emanote' flake input is used.
-          # package = inputs.emanote.packages.${system}.default;
-          sites."default" = {
-            path = ./content;
-            pathString = "./content";
-            # port = 8080;
-            # baseUrl = "/mynotes";
-            # prettyUrls = true;
-          };
-        };
-        devShells.default = pkgs.mkShell {
-          buildInputs = [
-            pkgs.nixpkgs-fmt
-            pkgs.zk
-          ];
-        };
-      };
+  nixConfig = {
+    extra-trusted-public-keys = ["devenv.cachix.org-1:w1cLUi8dv3hnoSPGAuibQv+f9TZLr6cv/Hm9XgU50cw="
+                                 "srid.cachix.org-1:3clnql5gjbJNEvhA/WQp7nrZlBptwpXnUk6JAv8aB2M="
+    ];
+    extra-substituters = [
+      "https://devenv.cachix.org"
+      "https://srid.cachix.org"
+    ];
+  };
+
+  outputs = { self, nixpkgs, devenv, systems, emanote, ... } @ inputs:
+    let
+      forEachSystem = nixpkgs.lib.genAttrs (import systems);
+    in
+    {
+      devShells = forEachSystem
+        (system:
+          let
+            pkgs = nixpkgs.legacyPackages.${system};
+          in
+          {
+            default = devenv.lib.mkShell {
+              inherit inputs pkgs;
+              modules = [
+               ({ pkgs, emanote, ... }:
+
+                {
+                  # https://devenv.sh/basics/
+
+                  # https://devenv.sh/packages/
+                  packages = [
+                    pkgs.git
+                    pkgs.docker
+                    emanote.packages.${system}.emanote
+                  ];
+
+                  enterShell = ''
+                    echo 'Hello from "Emanote" environment.'
+                    git --version
+                    echo -n "Emanote version " && emanote --version
+                  '';
+
+                  # https://devenv.sh/languages/
+                  # languages.nix.enable = true;
+
+                  # https://devenv.sh/pre-commit-hooks/
+                  pre-commit.hooks.shellcheck.enable = true;
+                  pre-commit.hooks.markdownlint.enable = true;
+                  pre-commit.settings.markdownlint.config = {
+                    "MD041"= false;
+                  };
+
+                  # https://devenv.sh/processes/
+                  # processes.ping.exec = "ping example.com";
+
+                  processes = {
+                    emanote.exec = "cd $DEVENV_ROOT/content && emanote run --port=8081";
+                  };
+
+                  scripts.showDoc.exec = "sensible-browser http://127.0.0.1:8081/";
+                  scripts.generate.exec = "cd $DEVENV_ROOT/content && emanote gen $DEVENV_ROOT/static_gen";
+                  scripts.nix-cleanup.exec = "nix-env --delete-generations old && nix-store --gc && nix-collect-garbage -d";
+
+                  # See full reference at https://devenv.sh/reference/options/
+                })
+              ];
+            };
+          });
     };
 }

static_gen/-/tags.html

@@ -0,0 +1,342 @@
+<html lang='en'>
+
+<head>
+  <meta charset='UTF-8' />
+  <meta name='viewport' content='width=device-width, initial-scale=1' />
+  <title>
+    Tag Index – Home
+  </title>
+  
+    
+      <meta property='og:description' content='Unsortierte Einsichten und Erfahrungen. Archiviert zum verlinken, späteren Überdenken oder Diskutieren.' />
+      <meta property='og:site_name' content='Home' />
+      <meta property='og:image' content />
+      <meta property='og:type' content='website' />
+      <meta property='og:title' content='Tag Index' />
+    
+    
+      <base href='/' />
+      <link href='favicon.svg' rel='icon' />
+    
+    <script>
+  window.MathJax = {
+    startup: {
+      ready: () => {
+        MathJax.startup.defaultReady();
+      }
+    }
+  };
+</script>
+<script async id='MathJax-script' src='https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js'></script>
+
+<!-- mermaid.js --><script src='https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js'></script>
+<script>
+  mermaid.initialize({startOnLoad:false});
+  mermaid.init(undefined,document.querySelectorAll(".mermaid"));
+</script>
+
+<!-- highlight.js -->
+<link rel='stylesheet' href='https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.6.0/styles/hybrid.min.css' />
+<script src='https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.6.0/highlight.min.js'></script>
+<!-- Include languages that Emanote itself uses -->
+<script src='https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.6.0/languages/haskell.min.js'></script>
+<script src='https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.6.0/languages/nix.min.js'></script>
+<script>hljs.highlightAll();</script>
+
+
+
+  
+  <link href='tailwind.css?instanceId=e98d22b9-5039-4bd9-8072-cac8aca20ee6' rel='stylesheet' type='text/css' />
+
+  <style>
+    /* Heist error element */
+    strong.error {
+      color: lightcoral;
+      font-size: 90%;
+      font-family: monospace;
+    }
+
+    /* External link icon */
+    a[data-linkicon=""]::after {
+      content: ""
+    }
+
+    a[data-linkicon=none]::after {
+      content: ""
+    }
+
+    a[data-linkicon="external"]::after {
+      content: url('data:image/svg+xml,\
+      <svg xmlns="http://www.w3.org/2000/svg" height="0.7em" viewBox="0 0 20 20"> \
+        <g style="stroke:gray;stroke-width:1"> \
+          <line x1="5" y1="5" x2="5" y2="14" /> \
+          <line x1="14" y1="9" x2="14" y2="14" /> \
+          <line x1="5" y1="14" x2="14" y2="14" /> \
+          <line x1="5" y1="5" x2="9" y2="5"  /> \
+          <line x1="10" y1="2" x2="17" y2="2"  /> \
+          <line x1="17" y1="2" x2="17" y2="9" /> \
+          <line x1="10" y1="9" x2="17" y2="2" style="stroke-width:1.0" /> \
+        </g> \
+      </svg>');
+    }
+
+    a[data-linkicon="external"][href^="mailto:"]::after {
+      content: url('data:image/svg+xml,\
+        <svg \
+          xmlns="http://www.w3.org/2000/svg" \
+          height="0.7em" \
+          fill="none" \
+          viewBox="0 0 24 24" \
+          stroke="gray" \
+          stroke-width="2"> \
+          <path \
+            stroke-linecap="round" \
+            stroke-linejoin="round" \
+            d="M3 8l7.89 5.26a2 2 0 002.22 0L21 8M5 19h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v10a2 2 0 002 2z" /> \
+        </svg>');
+    }
+  </style>
+  <!-- What goes in this file will appear on near the end of <head>--><link rel='preload' href='_emanote-static/fonts/Work_Sans/WorkSans-VariableFont_wght.ttf' as='font' type='font/ttf' crossorigin />
+
+<style>
+  @font-face {
+    font-family: 'WorkSans';
+    /* FIXME: This ought to be: ${ema:emanoteStaticLayerUrl}/fonts/Work_Sans/WorkSans-VariableFont_wght.ttf */
+    src: url(_emanote-static/fonts/Work_Sans/WorkSans-VariableFont_wght.ttf) format("truetype");
+    font-display: swap;
+  }
+
+  body {
+    font-family: 'WorkSans', sans-serif;
+    font-variation-settings: 'wght' 350;
+  }
+
+  a.mavenLinkBold {
+    font-variation-settings: 'wght' 400;
+  }
+
+  strong {
+    font-variation-settings: 'wght' 500;
+  }
+
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6,
+  header,
+  .header-font {
+    font-family: 'WorkSans', sans-serif;
+  }
+
+  h1 {
+    font-variation-settings: 'wght' 500;
+  }
+
+  h2 {
+    font-variation-settings: 'wght' 400;
+  }
+
+  h3 {
+    font-variation-settings: 'wght' 300;
+  }
+</style>
+
+
+  <head-main></head-main>
+  <link rel='stylesheet' href='_emanote-static/stork/flat.css' />
+<!-- Custom Stork-search styling for Emanote -->
+<style>
+  #stork-search-container {
+    z-index: 1000;
+    background-color: rgb(15 23 42/.8);
+  }
+
+  .stork-overflow-hidden-important {
+    overflow: hidden !important;
+  }
+</style>
+
+
+<script src='_emanote-static/stork/stork.js'></script>
+
+  
+    <script id='emanote-stork' data-emanote-base-url='/'>
+      window.emanote = {};
+      window.emanote.stork = {
+        searchShown: false,
+        indexIsStale: false,
+        toggleSearch: function () {
+          window.emanote.stork.refreshIndex();
+          document.getElementById('stork-search-container').classList.toggle('hidden');
+          window.emanote.stork.searchShown = document.body.classList.toggle('stork-overflow-hidden-important');
+          if (window.emanote.stork.searchShown) {
+            document.getElementById('stork-search-input').focus();
+          }
+        },
+        clearSearch: function () {
+          document.getElementById('stork-search-container').classList.add('hidden');
+          document.body.classList.remove('stork-overflow-hidden-important');
+          window.emanote.stork.searchShown = false;
+        },
+
+        getBaseUrl: function () {
+          const baseUrl = document.getElementById("emanote-stork").getAttribute('data-emanote-base-url') || '/';
+          return baseUrl;
+        },
+
+        registerIndex: function (options) {
+          const indexName = 'emanote-search'; // used to match input[data-stork] attribute value
+          const indexUrl = window.emanote.stork.getBaseUrl() + '-/stork.st';
+          stork.register(
+            indexName,
+            indexUrl,
+            options);
+        },
+
+        init: function () {
+          if (document.readyState !== 'complete') {
+            window.addEventListener('load', function () {
+              stork.initialize(window.emanote.stork.getBaseUrl() + '_emanote-static/stork/stork.wasm');
+              window.emanote.stork.registerIndex();
+            });
+
+            document.addEventListener('keydown', event => {
+              if (window.emanote.stork.searchShown && event.key === 'Escape') {
+                window.emanote.stork.clearSearch();
+                event.preventDefault();
+              } else if ((event.key == 'k' || event.key == 'K') && (event.ctrlKey || event.metaKey)) {
+                window.emanote.stork.toggleSearch();
+                event.preventDefault();
+              }
+            });
+          } else {
+            // This section is called during Ema's hot reload.
+            // 
+            // Mark the current index as stale, and refresh it *only when* the
+            // user actually invokes search.
+            // 
+            // We do not refresh the index *right away*, as that will cause
+            // memory leaks in the browser. See
+            // https://github.com/srid/emanote/issues/411#issuecomment-1402056235
+            console.log("stork: Marking index as stale");
+            window.emanote.stork.markIndexAsStale();
+          }
+        },
+
+        markIndexAsStale: function () {
+          window.emanote.stork.indexIsStale = true;
+        },
+
+        refreshIndex: function () {
+          if (window.emanote.stork.indexIsStale) {
+            console.log("stork: Reloading index");
+            window.emanote.stork.indexIsStale = false;
+            // NOTE: This will leak memory. See the comment above.
+            window.emanote.stork.registerIndex({ forceOverwrite: true });
+          }
+        }
+
+      };
+
+      window.emanote.stork.init();
+    </script>
+  
+
+</head>
+
+<!-- DoNotFormat -->
+
+
+
+<!-- DoNotFormat -->
+
+<body class='bg-gray-400 overflow-y-scroll'>
+  
+    <div class='container mx-auto '>
+      <main class='flex-col items-center justify-center mx-2'>
+        <h1 class='pb-2 mt-2 mb-2 text-6xl text-center'>
+          Tag Index
+        </h1>
+        <div class='pb-2 mx-auto my-4 lg:max-w-screen-md '>
+          
+    <div class='bg-gray-200 pb-2'>
+      <nav id='tagcrumbs' class='w-full pl-2 bg-gray-100'>
+        <div class='flex items-center justify-left'>
+          <div class='w-full px-2 py-2 '>
+            <ul class='flex flex-wrap text-lg'>
+              
+              <li class='inline-flex items-center text-black'>
+                <a class='px-1 font-mono'>
+                  /
+                </a>
+              </li>
+            </ul>
+          </div>
+        </div>
+      </nav>
+      <div class='flex flex-col pl-2 my-4 ml-2 space-y-2'>
+        
+        
+      </div>
+    </div>
+  
+        </div>
+      </main>
+      <footer class='flex items-center justify-center mt-2 mb-8 space-x-4 text-center text-gray-800'>
+  
+  <div>
+    <a href='' title='Go to Home page'>
+      <svg xmlns='http://www.w3.org/2000/svg' class='w-6 h-6 hover:text-purple-700' fill='none' viewBox='0 0 24 24' stroke='currentColor'>
+        <path stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M3 12l2-2m0 0l7-7 7 7M5 10v10a1 1 0 001 1h3m10-11l2 2m-2-2v10a1 1 0 01-1 1h-3m-6 0a1 1 0 001-1v-4a1 1 0 011-1h2a1 1 0 011 1v4a1 1 0 001 1m-6 0h6'></path>
+      </svg>
+    </a>
+  </div>
+  <div>
+    <a href='-/all' title='View Index'>
+      <svg class='w-6 h-6 hover:text-purple-700' fill='none' stroke='currentColor' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'>
+        <path stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M4 8V4m0 0h4M4 4l5 5m11-1V4m0 0h-4m4 0l-5 5M4 16v4m0 0h4m-4 0l5-5m11 5l-5-5m5 5v-4m0 4h-4'>
+        </path>
+      </svg>
+    </a>
+  </div>
+  <div>
+    <a href='https://emanote.srid.ca' target='_blank' title='Generated by Emanote 1.0.3.11'>
+      <img class='w-6 h-6 hover:text-purple-700' src='_emanote-static/emanote-logo.svg' />
+    </a>
+  </div>
+  <div>
+    <a href='-/tags' title='View tags'>
+      <svg class='w-6 h-6 hover:text-purple-700' fill='none' stroke='currentColor' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'>
+        <path stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M7 7h.01M7 3h5c.512 0 1.024.195 1.414.586l7 7a2 2 0 010 2.828l-7 7a2 2 0 01-2.828 0l-7-7A1.994 1.994 0 013 12V7a4 4 0 014-4z'>
+        </path>
+      </svg>
+    </a>
+  </div>
+  <div>
+    <a href='-/tasks' title='View tasks'>
+      <svg xmlns='http://www.w3.org/2000/svg' class='w-6 h-6 hover:text-purple-700' fill='none' viewBox='0 0 24 24' stroke='currentColor'>
+        <path stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z'></path>
+      </svg>
+    </a>
+  </div>
+</footer>
+    </div>
+  
+  <div id='stork-search-container' class='hidden fixed w-screen h-screen inset-0 backdrop-filter backdrop-blur-sm'>
+  <div class='fixed w-screen h-screen inset-0' onclick='window.emanote.stork.toggleSearch()'></div>
+
+  <div class='container mx-auto p-10 mt-10'>
+    <div class='stork-wrapper-flat container mx-auto'>
+      <input id='stork-search-input' data-stork='emanote-search' class='stork-input' placeholder='Search (Ctrl+K) ...' />
+      <div data-stork='emanote-search-output' class='stork-output'></div>
+    </div>
+  </div>
+</div>
+  
+    
+  
+</body>
+
+</html>

static_gen/-/tasks.html

@@ -0,0 +1,327 @@
+<html lang='en'>
+
+<head>
+  <meta charset='UTF-8' />
+  <meta name='viewport' content='width=device-width, initial-scale=1' />
+  <title>
+    Task Index – Home
+  </title>
+  
+    
+      <meta property='og:description' content='Unsortierte Einsichten und Erfahrungen. Archiviert zum verlinken, späteren Überdenken oder Diskutieren.' />
+      <meta property='og:site_name' content='Home' />
+      <meta property='og:image' content />
+      <meta property='og:type' content='website' />
+      <meta property='og:title' content='Task Index' />
+    
+    
+      <base href='/' />
+      <link href='favicon.svg' rel='icon' />
+    
+    <script>
+  window.MathJax = {
+    startup: {
+      ready: () => {
+        MathJax.startup.defaultReady();
+      }
+    }
+  };
+</script>
+<script async id='MathJax-script' src='https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js'></script>
+
+<!-- mermaid.js --><script src='https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js'></script>
+<script>
+  mermaid.initialize({startOnLoad:false});
+  mermaid.init(undefined,document.querySelectorAll(".mermaid"));
+</script>
+
+<!-- highlight.js -->
+<link rel='stylesheet' href='https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.6.0/styles/hybrid.min.css' />
+<script src='https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.6.0/highlight.min.js'></script>
+<!-- Include languages that Emanote itself uses -->
+<script src='https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.6.0/languages/haskell.min.js'></script>
+<script src='https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.6.0/languages/nix.min.js'></script>
+<script>hljs.highlightAll();</script>
+
+
+
+  
+  <link href='tailwind.css?instanceId=e98d22b9-5039-4bd9-8072-cac8aca20ee6' rel='stylesheet' type='text/css' />
+
+  <style>
+    /* Heist error element */
+    strong.error {
+      color: lightcoral;
+      font-size: 90%;
+      font-family: monospace;
+    }
+
+    /* External link icon */
+    a[data-linkicon=""]::after {
+      content: ""
+    }
+
+    a[data-linkicon=none]::after {
+      content: ""
+    }
+
+    a[data-linkicon="external"]::after {
+      content: url('data:image/svg+xml,\
+      <svg xmlns="http://www.w3.org/2000/svg" height="0.7em" viewBox="0 0 20 20"> \
+        <g style="stroke:gray;stroke-width:1"> \
+          <line x1="5" y1="5" x2="5" y2="14" /> \
+          <line x1="14" y1="9" x2="14" y2="14" /> \
+          <line x1="5" y1="14" x2="14" y2="14" /> \
+          <line x1="5" y1="5" x2="9" y2="5"  /> \
+          <line x1="10" y1="2" x2="17" y2="2"  /> \
+          <line x1="17" y1="2" x2="17" y2="9" /> \
+          <line x1="10" y1="9" x2="17" y2="2" style="stroke-width:1.0" /> \
+        </g> \
+      </svg>');
+    }
+
+    a[data-linkicon="external"][href^="mailto:"]::after {
+      content: url('data:image/svg+xml,\
+        <svg \
+          xmlns="http://www.w3.org/2000/svg" \
+          height="0.7em" \
+          fill="none" \
+          viewBox="0 0 24 24" \
+          stroke="gray" \
+          stroke-width="2"> \
+          <path \
+            stroke-linecap="round" \
+            stroke-linejoin="round" \
+            d="M3 8l7.89 5.26a2 2 0 002.22 0L21 8M5 19h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v10a2 2 0 002 2z" /> \
+        </svg>');
+    }
+  </style>
+  <!-- What goes in this file will appear on near the end of <head>--><link rel='preload' href='_emanote-static/fonts/Work_Sans/WorkSans-VariableFont_wght.ttf' as='font' type='font/ttf' crossorigin />
+
+<style>
+  @font-face {
+    font-family: 'WorkSans';
+    /* FIXME: This ought to be: ${ema:emanoteStaticLayerUrl}/fonts/Work_Sans/WorkSans-VariableFont_wght.ttf */
+    src: url(_emanote-static/fonts/Work_Sans/WorkSans-VariableFont_wght.ttf) format("truetype");
+    font-display: swap;
+  }
+
+  body {
+    font-family: 'WorkSans', sans-serif;
+    font-variation-settings: 'wght' 350;
+  }
+
+  a.mavenLinkBold {
+    font-variation-settings: 'wght' 400;
+  }
+
+  strong {
+    font-variation-settings: 'wght' 500;
+  }
+
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6,
+  header,
+  .header-font {
+    font-family: 'WorkSans', sans-serif;
+  }
+
+  h1 {
+    font-variation-settings: 'wght' 500;
+  }
+
+  h2 {
+    font-variation-settings: 'wght' 400;
+  }
+
+  h3 {
+    font-variation-settings: 'wght' 300;
+  }
+</style>
+
+
+  <head-main></head-main>
+  <link rel='stylesheet' href='_emanote-static/stork/flat.css' />
+<!-- Custom Stork-search styling for Emanote -->
+<style>
+  #stork-search-container {
+    z-index: 1000;
+    background-color: rgb(15 23 42/.8);
+  }
+
+  .stork-overflow-hidden-important {
+    overflow: hidden !important;
+  }
+</style>
+
+
+<script src='_emanote-static/stork/stork.js'></script>
+
+  
+    <script id='emanote-stork' data-emanote-base-url='/'>
+      window.emanote = {};
+      window.emanote.stork = {
+        searchShown: false,
+        indexIsStale: false,
+        toggleSearch: function () {
+          window.emanote.stork.refreshIndex();
+          document.getElementById('stork-search-container').classList.toggle('hidden');
+          window.emanote.stork.searchShown = document.body.classList.toggle('stork-overflow-hidden-important');
+          if (window.emanote.stork.searchShown) {
+            document.getElementById('stork-search-input').focus();
+          }
+        },
+        clearSearch: function () {
+          document.getElementById('stork-search-container').classList.add('hidden');
+          document.body.classList.remove('stork-overflow-hidden-important');
+          window.emanote.stork.searchShown = false;
+        },
+
+        getBaseUrl: function () {
+          const baseUrl = document.getElementById("emanote-stork").getAttribute('data-emanote-base-url') || '/';
+          return baseUrl;
+        },
+
+        registerIndex: function (options) {
+          const indexName = 'emanote-search'; // used to match input[data-stork] attribute value
+          const indexUrl = window.emanote.stork.getBaseUrl() + '-/stork.st';
+          stork.register(
+            indexName,
+            indexUrl,
+            options);
+        },
+
+        init: function () {
+          if (document.readyState !== 'complete') {
+            window.addEventListener('load', function () {
+              stork.initialize(window.emanote.stork.getBaseUrl() + '_emanote-static/stork/stork.wasm');
+              window.emanote.stork.registerIndex();
+            });
+
+            document.addEventListener('keydown', event => {
+              if (window.emanote.stork.searchShown && event.key === 'Escape') {
+                window.emanote.stork.clearSearch();
+                event.preventDefault();
+              } else if ((event.key == 'k' || event.key == 'K') && (event.ctrlKey || event.metaKey)) {
+                window.emanote.stork.toggleSearch();
+                event.preventDefault();
+              }
+            });
+          } else {
+            // This section is called during Ema's hot reload.
+            // 
+            // Mark the current index as stale, and refresh it *only when* the
+            // user actually invokes search.
+            // 
+            // We do not refresh the index *right away*, as that will cause
+            // memory leaks in the browser. See
+            // https://github.com/srid/emanote/issues/411#issuecomment-1402056235
+            console.log("stork: Marking index as stale");
+            window.emanote.stork.markIndexAsStale();
+          }
+        },
+
+        markIndexAsStale: function () {
+          window.emanote.stork.indexIsStale = true;
+        },
+
+        refreshIndex: function () {
+          if (window.emanote.stork.indexIsStale) {
+            console.log("stork: Reloading index");
+            window.emanote.stork.indexIsStale = false;
+            // NOTE: This will leak memory. See the comment above.
+            window.emanote.stork.registerIndex({ forceOverwrite: true });
+          }
+        }
+
+      };
+
+      window.emanote.stork.init();
+    </script>
+  
+
+</head>
+
+<!-- DoNotFormat -->
+
+
+
+<!-- DoNotFormat -->
+
+<body class='bg-gray-400 overflow-y-scroll'>
+  
+    <div class='container mx-auto '>
+      <main class='flex-col items-center justify-center mx-2'>
+        <h1 class='pb-2 mt-2 mb-2 text-6xl text-center'>
+          Task Index
+        </h1>
+        <div class='pb-2 mx-auto my-4 lg:max-w-screen-md '>
+          
+    <div class='w-full bg-gray-300'>
+      <div class='w-full px-3 py-1'>
+        
+      </div>
+    </div>
+  
+        </div>
+      </main>
+      <footer class='flex items-center justify-center mt-2 mb-8 space-x-4 text-center text-gray-800'>
+  
+  <div>
+    <a href='' title='Go to Home page'>
+      <svg xmlns='http://www.w3.org/2000/svg' class='w-6 h-6 hover:text-purple-700' fill='none' viewBox='0 0 24 24' stroke='currentColor'>
+        <path stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M3 12l2-2m0 0l7-7 7 7M5 10v10a1 1 0 001 1h3m10-11l2 2m-2-2v10a1 1 0 01-1 1h-3m-6 0a1 1 0 001-1v-4a1 1 0 011-1h2a1 1 0 011 1v4a1 1 0 001 1m-6 0h6'></path>
+      </svg>
+    </a>
+  </div>
+  <div>
+    <a href='-/all' title='View Index'>
+      <svg class='w-6 h-6 hover:text-purple-700' fill='none' stroke='currentColor' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'>
+        <path stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M4 8V4m0 0h4M4 4l5 5m11-1V4m0 0h-4m4 0l-5 5M4 16v4m0 0h4m-4 0l5-5m11 5l-5-5m5 5v-4m0 4h-4'>
+        </path>
+      </svg>
+    </a>
+  </div>
+  <div>
+    <a href='https://emanote.srid.ca' target='_blank' title='Generated by Emanote 1.0.3.11'>
+      <img class='w-6 h-6 hover:text-purple-700' src='_emanote-static/emanote-logo.svg' />
+    </a>
+  </div>
+  <div>
+    <a href='-/tags' title='View tags'>
+      <svg class='w-6 h-6 hover:text-purple-700' fill='none' stroke='currentColor' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'>
+        <path stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M7 7h.01M7 3h5c.512 0 1.024.195 1.414.586l7 7a2 2 0 010 2.828l-7 7a2 2 0 01-2.828 0l-7-7A1.994 1.994 0 013 12V7a4 4 0 014-4z'>
+        </path>
+      </svg>
+    </a>
+  </div>
+  <div>
+    <a href='-/tasks' title='View tasks'>
+      <svg xmlns='http://www.w3.org/2000/svg' class='w-6 h-6 hover:text-purple-700' fill='none' viewBox='0 0 24 24' stroke='currentColor'>
+        <path stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z'></path>
+      </svg>
+    </a>
+  </div>
+</footer>
+    </div>
+  
+  <div id='stork-search-container' class='hidden fixed w-screen h-screen inset-0 backdrop-filter backdrop-blur-sm'>
+  <div class='fixed w-screen h-screen inset-0' onclick='window.emanote.stork.toggleSearch()'></div>
+
+  <div class='container mx-auto p-10 mt-10'>
+    <div class='stork-wrapper-flat container mx-auto'>
+      <input id='stork-search-input' data-stork='emanote-search' class='stork-input' placeholder='Search (Ctrl+K) ...' />
+      <div data-stork='emanote-search-output' class='stork-output'></div>
+    </div>
+  </div>
+</div>
+  
+    
+  
+</body>
+
+</html>

static_gen/_emanote-static/emanote-logo.svg

@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Generator: Adobe Illustrator 19.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 512.003 512.003" style="enable-background:new 0 0 512.003 512.003;" xml:space="preserve">
+<polygon style="fill:#0068FF;" points="276.547,363.724 156.428,439.952 229.841,320.17 "/>
+<g>
+	<polygon style="fill:#10BAFC;" points="424.343,501.551 229.841,320.17 499.021,10.446 	"/>
+	<polygon style="fill:#10BAFC;" points="156.428,264.439 12.979,188.915 499.021,10.446 	"/>
+</g>
+<polygon style="fill:#0084FF;" points="156.428,264.439 156.428,439.952 229.841,320.17 499.021,10.446 "/>
+<path d="M409.804,197.83c-2.509,0-5.026-0.898-7.027-2.72c-4.269-3.883-4.582-10.491-0.699-14.76l0.164-0.181
+	c3.883-4.268,10.493-4.582,14.76-0.698c4.27,3.883,4.582,10.491,0.699,14.76l-0.164,0.181
+	C415.475,196.679,412.644,197.83,409.804,197.83z"/>
+<path d="M318.886,298.027c-2.505,0-5.018-0.895-7.019-2.71c-4.274-3.879-4.594-10.487-0.716-14.759l68.202-75.162
+	c3.877-4.274,10.487-4.594,14.759-0.717c4.274,3.878,4.594,10.487,0.717,14.759L326.627,294.6
+	C324.565,296.871,321.731,298.027,318.886,298.027z"/>
+<path d="M503.407,0.963c-2.579-1.193-5.448-1.251-7.987-0.32c0-0.002,0-0.003-0.001-0.005L9.377,179.106
+	c-3.876,1.423-6.551,4.996-6.823,9.116c-0.275,4.12,1.904,8.015,5.558,9.939l137.867,72.584v169.208
+	c0,4.679,3.111,8.787,7.612,10.057c0.94,0.265,1.895,0.393,2.837,0.393c1.992,0,3.923-0.589,5.586-1.644
+	c0.004,0.006,0.008,0.01,0.014,0.017l113.3-71.9l141.89,132.319c1.966,1.833,4.523,2.807,7.127,2.807c1.15,0,2.31-0.19,3.431-0.58
+	c3.66-1.273,6.315-4.467,6.898-8.299l74.678-491.105C510.051,7.42,507.628,2.915,503.407,0.963z M434.512,45.265l-279.03,206.867
+	l-116.834-61.51L434.512,45.265z M166.877,269.699l261.434-193.82L221.954,313.315c-0.386,0.444-0.718,0.915-1.016,1.401
+	c-0.002-0.003-0.004-0.004-0.007-0.007l-54.055,88.198V269.699H166.877z M188.896,406.972l43.17-70.439l27.465,25.613
+	L188.896,406.972z M416.988,480.407L244.345,319.408l238.93-274.914L416.988,480.407z"/>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+</svg>

static_gen/_emanote-static/inverted-tree.css

@@ -0,0 +1,118 @@
+/* Adapted from https://neuron.zettel.page/uplink-tree
+   Originally from https://codepen.io/philippkuehn/pen/QbrOaN
+*/
+
+body .tree.flipped {
+  -webkit-transform: rotate(180deg);
+  -moz-transform: rotate(180deg);
+  -ms-transform: rotate(180deg);
+  -o-transform: rotate(180deg);
+  transform: rotate(180deg);
+}
+body .tree {
+  overflow: auto;
+  /* See more-head.tpl */
+  font-family: 'WorkSans', sans-serif;
+  font-variation-settings: 'wght' 475;
+
+  font-size: 0.8em;
+}
+body .tree ul.root {
+  padding-top: 0px;
+  margin-top: 0px;
+}
+body .tree ul {
+  position: relative;
+  padding: 1em 0px 0px 0px;
+  white-space: nowrap;
+  margin: 0px auto 0px auto;
+  text-align: center;
+}
+body .tree ul::after {
+  content: "";
+  display: table;
+  clear: both;
+}
+body .tree ul:last-child {
+  padding-bottom: 0.1em;
+}
+body .tree li {
+  display: inline-block;
+  vertical-align: top;
+  text-align: center;
+  list-style-type: none;
+  position: relative;
+  padding: 1em 0.5em 0em 0.5em;
+}
+body .tree li::before {
+  content: "";
+  position: absolute;
+  top: 0px;
+  right: 50%;
+  border-top: solid 2px #cccccc;
+  width: 60%;
+  height: 1.19999em;
+}
+body .tree li::after {
+  content: "";
+  position: absolute;
+  top: 0px;
+  right: 50%;
+  border-top: solid 2px #cccccc;
+  width: 50%;
+  height: 1.19999em;
+}
+body .tree li::after {
+  right: auto;
+  left: 50%;
+  border-left: solid 2px #cccccc;
+}
+body .tree li:only-child {
+  padding-top: 0em;
+}
+body .tree li:only-child::after {
+  display: none;
+}
+body .tree li:only-child::before {
+  display: none;
+}
+body .tree li:first-child::before {
+  border-style: none;
+  border-width: 0px;
+}
+body .tree li:first-child::after {
+  border-radius: 5px 0px 0px 0px;
+}
+body .tree li:last-child::after {
+  border-style: none;
+  border-width: 0px;
+}
+body .tree li:last-child::before {
+  border-right: solid 2px #cccccc;
+  border-radius: 0px 5px 0px 0px;
+}
+body .tree ul ul::before {
+  content: "";
+  position: absolute;
+  top: 0px;
+  left: 50%;
+  border-left: solid 2px #cccccc;
+  width: 0px;
+  height: 1.19999em;
+}
+body .tree li div.forest-link {
+  border: solid 2px #cccccc;
+  padding: 0.2em 0.29999em 0.2em 0.29999em;
+  text-decoration: none;
+  display: inline-block;
+  border-radius: 5px 5px 5px 5px;
+  position: relative;
+  top: 2px;
+}
+body .tree.flipped li div.forest-link {
+  -webkit-transform: rotate(180deg);
+  -moz-transform: rotate(180deg);
+  -ms-transform: rotate(180deg);
+  -o-transform: rotate(180deg);
+  transform: rotate(180deg);
+}

static_gen/_emanote-static/stork/flat.css

@@ -0,0 +1,191 @@
+.stork-wrapper-flat {
+  position: relative;
+  font-family: inherit;
+  box-sizing: border-box;
+  font-size: 1em;
+
+  --stork-blue-2: #a5d8ff;
+  --stork-blue-3: #74c0fc;
+  --stork-blue-4: #4dabf7;
+  --stork-blue-5: #339af0;
+  --stork-blue-7: #1c7ed6;
+  --stork-gray-8: #343a40;
+  --stork-gray-9: #212529;
+  --stork-yellow-2: #ffec99;
+
+  --stork-border-color: hsl(0, 0%, 80%);
+  --stork-background-color: hsla(0, 0%, 97%);
+  --stork-text-color: var(--stork-gray-9);
+
+  --stork-input-height: 2.4em;
+}
+
+.stork-wrapper-flat *,
+.stork-wrapper-flat *:before,
+.stork-wrapper-flat *:after {
+  box-sizing: border-box;
+}
+
+.stork-wrapper-flat .stork-input {
+  width: 100%;
+  height: var(--stork-input-height);
+  font-size: 1em;
+  padding: 0.4em 0.8em;
+  position: relative;
+  border: 2px solid var(--stork-border-color);
+  border-radius: calc(var(--stork-input-height) / 2);
+  background-color: var(--stork-background-color);
+  color: var(--stork-text-color);
+  font-family: inherit;
+}
+
+.stork-wrapper-flat .stork-input:focus {
+  outline: none;
+}
+
+.stork-wrapper-flat .stork-progress {
+  position: absolute;
+  display: block;
+  content: "";
+  bottom: 1px;
+  background-color: var(--stork-blue-5);
+  box-shadow: 0 0 8px var(--stork-blue-4);
+  height: 1px;
+  transition: width 0.25s ease, opacity 0.4s ease 0.4s;
+  margin-left: calc(var(--stork-input-height) / 2);
+  max-width: calc(100% - var(--stork-input-height));
+}
+
+.stork-wrapper-flat .stork-output {
+  position: absolute;
+  width: 100%;
+  margin-top: 0.5em;
+  border-radius: 6px;
+  display: flex;
+  flex-direction: column;
+  z-index: 100;
+  color: var(--stork-text-color);
+  font-weight: 400;
+  font-family: inherit;
+}
+
+.stork-wrapper-flat .stork-attribution a:link,
+.stork-wrapper-flat .stork-attribution a:visited {
+  color: var(--stork-blue-7);
+}
+
+.stork-wrapper-flat .stork-output-visible {
+  border: 2px solid var(--stork-border-color);
+  background: var(--stork-background-color);
+}
+
+.stork-wrapper-flat .stork-message {
+  width: 100%;
+  padding: 0.5em 1em;
+  color: var(--stork-text-color);
+}
+
+.stork-wrapper-flat .stork-attribution {
+  width: 100%;
+  padding: 0.5em 1em;
+  font-size: 0.8em;
+  color: var(--stork-text-color);
+}
+
+.stork-wrapper-flat .stork-results {
+  margin: 0;
+  padding: 0;
+  width: 100%;
+  list-style-type: none;
+  max-height: 25em;
+  overflow-y: scroll;
+  border-top: 1px solid var(--stork-border-color);
+  border-bottom: 1px solid var(--stork-border-color);
+}
+
+.stork-wrapper-flat .stork-result:not(:last-child) {
+  border-bottom: 1px solid var(--stork-border-color);
+}
+
+.stork-wrapper-flat .stork-result.selected {
+  background: var(--stork-blue-2);
+}
+
+.stork-wrapper-flat .stork-result a:link {
+  padding: 1em;
+  display: block;
+  color: currentcolor;
+  text-decoration: none;
+}
+
+.stork-wrapper-flat .stork-result p {
+  margin: 0;
+}
+
+.stork-wrapper-flat .stork-title {
+  font-weight: bold;
+  font-size: 0.95em;
+  margin: 0;
+  color: var(--stork-text-color);
+
+  /* Flexbox container for the title and the score, when debugging */
+  display: flex;
+  justify-content: space-between;
+}
+
+.stork-wrapper-flat .stork-excerpt-container {
+  margin-top: 0.75em;
+}
+
+.stork-wrapper-flat .stork-excerpt {
+  font-size: 0.8em;
+  line-height: 1;
+  margin: 0;
+  color: var(--stork-gray-8);
+
+  /* Flexbox container for the title and the score, when debugging */
+  display: flex;
+  justify-content: space-between;
+}
+
+.stork-wrapper-flat .stork-excerpt:not(:last-of-type) {
+  margin-bottom: 0.6em;
+}
+
+.stork-wrapper-flat .stork-highlight {
+  background-color: var(--stork-yellow-2);
+  padding: 0 0.1em;
+}
+
+.stork-wrapper-flat .stork-error {
+  outline: 2px solid #c92a2a;
+}
+
+.stork-wrapper-flat .stork-close-button {
+  position: absolute;
+  right: 0;
+  margin: 0.5em 0.5em;
+  height: 1.4em;
+  width: 1.4em;
+  padding: 0px;
+  background: hsl(0, 0%, 85%);
+  border: 1px solid hsla(0, 0%, 70%);
+  font-size: 1em;
+  color: hsl(0, 0%, 50%);
+  border-radius: 50%;
+  line-height: 1;
+}
+
+.stork-wrapper-flat .stork-close-button svg {
+  width: 11px;
+  height: 11px;
+}
+
+.stork-wrapper-flat .stork-close-button:hover {
+  background: hsla(0, 0%, 78%);
+  cursor: pointer;
+}
+
+.stork-wrapper-flat .stork-close-button:active {
+  background: hsla(0, 0%, 65%);
+}

static_gen/favicon.svg

@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Generator: Adobe Illustrator 19.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 512.003 512.003" style="enable-background:new 0 0 512.003 512.003;" xml:space="preserve">
+<polygon style="fill:#0068FF;" points="276.547,363.724 156.428,439.952 229.841,320.17 "/>
+<g>
+	<polygon style="fill:#10BAFC;" points="424.343,501.551 229.841,320.17 499.021,10.446 	"/>
+	<polygon style="fill:#10BAFC;" points="156.428,264.439 12.979,188.915 499.021,10.446 	"/>
+</g>
+<polygon style="fill:#0084FF;" points="156.428,264.439 156.428,439.952 229.841,320.17 499.021,10.446 "/>
+<path d="M409.804,197.83c-2.509,0-5.026-0.898-7.027-2.72c-4.269-3.883-4.582-10.491-0.699-14.76l0.164-0.181
+	c3.883-4.268,10.493-4.582,14.76-0.698c4.27,3.883,4.582,10.491,0.699,14.76l-0.164,0.181
+	C415.475,196.679,412.644,197.83,409.804,197.83z"/>
+<path d="M318.886,298.027c-2.505,0-5.018-0.895-7.019-2.71c-4.274-3.879-4.594-10.487-0.716-14.759l68.202-75.162
+	c3.877-4.274,10.487-4.594,14.759-0.717c4.274,3.878,4.594,10.487,0.717,14.759L326.627,294.6
+	C324.565,296.871,321.731,298.027,318.886,298.027z"/>
+<path d="M503.407,0.963c-2.579-1.193-5.448-1.251-7.987-0.32c0-0.002,0-0.003-0.001-0.005L9.377,179.106
+	c-3.876,1.423-6.551,4.996-6.823,9.116c-0.275,4.12,1.904,8.015,5.558,9.939l137.867,72.584v169.208
+	c0,4.679,3.111,8.787,7.612,10.057c0.94,0.265,1.895,0.393,2.837,0.393c1.992,0,3.923-0.589,5.586-1.644
+	c0.004,0.006,0.008,0.01,0.014,0.017l113.3-71.9l141.89,132.319c1.966,1.833,4.523,2.807,7.127,2.807c1.15,0,2.31-0.19,3.431-0.58
+	c3.66-1.273,6.315-4.467,6.898-8.299l74.678-491.105C510.051,7.42,507.628,2.915,503.407,0.963z M434.512,45.265l-279.03,206.867
+	l-116.834-61.51L434.512,45.265z M166.877,269.699l261.434-193.82L221.954,313.315c-0.386,0.444-0.718,0.915-1.016,1.401
+	c-0.002-0.003-0.004-0.004-0.007-0.007l-54.055,88.198V269.699H166.877z M188.896,406.972l43.17-70.439l27.465,25.613
+	L188.896,406.972z M416.988,480.407L244.345,319.408l238.93-274.914L416.988,480.407z"/>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+</svg>