Resolve "outline programming part"

book/_toc.yml

@@ -2,9 +2,20 @@ format: jb-book
 root: intro
 
 parts:
-  - caption: New Material
+  - caption: Programming
     chapters:
-    - file: new/blank
+    - file: programming/overview
+      title: Overview
+    - file: programming/golden_rules_dont_execute.ipynb
+      title: The Golden Rules
+    - file: programming/computers/overview
+      title: Computers
+    - file: programming/code/overview
+      title: Code
+    - file: programming/programs/overview
+      title: Programs
+    - file: programming/communication/overview
+      title: Communication
   - caption: Sandbox
     chapters:
     - file: sandbox/blank

book/intro.md

-# Home
+# Welcome to the MUDE Textbook
 
-```{note}
+Welcome to the MUDE textbook.
+
+_this is where stuff will be written later_
+
+````{admonition} Update for MUDE Teachers
+:class: note
+I got rid of the README that used to be here, because you should have your workflow set by now, and you should know by now that you can always check it on GitLab [here](https://gitlab.tudelft.nl/mude/book/). **I'll put recent updates here for the 2 weeks leading up to the start of Q1**:
+- Draft of Programming Part is ready---the first content for the "new" book to be placed! Note that it is located in `book/book/programming`.
+- As you finalize the ToC for your material, move it to the same level directory as the programming part. All Parts should be a sub-directory of `book`.
+- By the start of Q1, all material in `cookbook`, `old`, `sandbox` should be removed, moved or hidden (preferably by YOU!)
+````
+
+````{admonition} Dicatorial Proclamation by the MUDE Manager
+:class: warning
+The MUDE content formerly known as **coding** shall henceforth be called **programming.**
+
+Don't like it? Too bad, maybe you can become manager next year and change it back. I have plenty of reasons, but rather than type them I believe they are better discussed over a cold beverage.
+````
+
+<!-- ```{note}
 Right now, the home page of the book simply displays `README.md` which is located at `./book/` or you can [read on GitLab here](https://gitlab.tudelft.nl/mude/book/-/blob/main/README.md).
 ```
 
 ```{include} ../README.md
-```
+``` -->

book/new/blank.md

-# blank chapter
-
-There is no content here yet. This file is a chapter. Use this for unorganized material. If it's organized (e.g., the prob design/risk part) it does not need to go into `book/book/new/`
\ No newline at end of file

book/programming/code/overview.md

+# Code 
+
+text. Matlab also high level and multi-purpose like Python.
+
+Things that will definitely go here:
+- functions (a brief overview/highlight of features, then link to the object part of programs)
+- complexity: where does it come from and why is it important (work backwards to know which concepts need to be included (e.g., bits and flops etc)); can find good reference rather than repeat chapters of numerical analysis textbook material
\ No newline at end of file

book/programming/communication/overview.md

+# Communication 
+
+text.
\ No newline at end of file

book/programming/computers/overview.md

+# Computers 
+
+text.
+

book/programming/overview.md

+# Programming Overview
+
+Riccardo ideas. For now, when in doubt add content to the JB. Can move text to website later as needed.
+1. theory + best practices with examples for efficient numerical practices
+2. theory + best practices with examples of for loops (and not for loops)
+3. Visualization:
+   1. how to reduce the size of images (matplotlib plots) when large datasets are used (can use SHIP project as a case study)
+   2. advanced figure creation: define axes as objects and modifying attribues (i have some recent examples from another TA if needed)
+   3. saving a figure (vector/raster; file types; optimize file size; automatically regenerate it; add a test?)
+4. Memory considerations: how can you tell whether or not your code is working efficiently? (e.g., loading data, copies of objects, recopying or reloading on every nb run)
+5. Run time:
+   1. may need a bit of theory about computations, processor speeds, cores, comparison of disk, RAM, CPU/GPU etc, but doesn't need to be long, and perhaps we can find existing content with CC license to include directly (embedded video, copy content, direct link all ok...this applies to all generic programming and coding topics)
+   2. strategies for evaluating code efficiency and identifying slowest parts to improve: in a notebook and in an IDE (VS Code).
+   3. saving results of analyses---would this be pickle? ideally we should teach them how to create a JSON and binary (pickle) format, then they choose whats best (for example, the JSON is readable and may be useful to share with a colleague who cannot run nb's in combination with a PDF printout of the nb). This is a great example where we should have content in the book that then is referred to as needed when students run into issues in submitting reports (i.e., their nb is 10 MB, now what?)
+6. IDE's: a brief overview, then a recommendation and case study with Jupyter Lab and VS Code
+7. package management: we need some theory on this, but it should be concise. Since Robert is already working with the TA's about environments, maybe it's best to leave this one alone till the end
+8. Some handy tricks (we can make a special page on the website to quickly illustrate things described above, and provide links to the theory, explanation and case studies in the textbook)
+
+
+
+Loosely broken down into 4 Chapters, with some ideas for possible contents (will fine tune location as we create it!):
+
+1. Golden Rules (part of Communication, but introduced at beginning to set the stage)
+2. Computers: essentials concepts for Scientific Computation and Numerical Analysis 
+   1. Machine code, compilers, low- and high-level languages; Bits and bytes, storage, memory, precision; File types (e.g., txt, csv, ipynb, py, md; text and binary); 
+Data types (e.g., csv, JSON, netcdf, etc); FLOPS, run time; Complexity  
+3. Code: Instructions. Executed. 
+   1. Programming language (Python), Environments and package management, Fundamentals of programming, Executing code, Other languages 
+4. Programs: essentials for scientific computing 
+   1. Modular programming; Object-oriented programming, Version control, Debugging and error handling 
+5. Communication (and documentation)
+   1. Golden Rules, Visualization, Version control, Sharing your work (Static (*.ipynb, *.pdf, *.html) and Dynamic/Interactive (something with a Python kernel), Open-Source Projects / Collaboration 
+   2. some of this may be moved to the website; most will be short, except git
+
+
+Software is also considered a programming category, but that will be covered exclusively on the website.
\ No newline at end of file

book/programming/programs/overview.md

+# Programs 
+
+text. Can briefly mention programming paradigms and that we focus on object-oriented and functional. FORTRAN was old standard in engineering, which is declarative. 
+
+Things that will definitely go here:
+- Objects
+  - theory: what it is, why it's useful
+  - Case studies: interactive pages that focus on variables, functions, figures as objects
+- Modular programming workshop
+  - importing py files
+  - connection to how packages function (explore with interactive features)
+- Writing efficient programs for numerical analysis
+  - add theory missing from Code chapter
+  - explicit case studies illustrating best practices
+  - examples that quantitatively show the effect of bad practices
+  - e.g., sparse matrices, for loops and why they should be avoided
\ No newline at end of file