(sec:Syllabus)= # Syllabus ## Course Information - **Instructor(s):** Michael McNeil Forbes [`m.forbes+581@wsu.edu`](mailto:m.forbes+581@wsu.edu) - **Course Assistants:** - **Office:** Webster 947F - **Office Hours:** F2-4pm in [Webster 1243][Webster Hall], MW4pm (after class), or by appointment. - **Course Homepage:** - **Class Number:** 581 - **Title:** Phys 581: Compute Anything -- Effective Scientific Computing - **Credits:** 3 - **Recommended Preparation**: Strong background in calculus, real and complex analysis, linear algebra, familiarity with differential equations, and basic programming skills. - **Meeting Time and Location:** MW, 2:10pm - 4pm, [Webster 941][Webster Hall], Washington State University (WSU), Pullman, WA - **Grading:** Grade based on assignments, and project. [Webster Hall]: ```{contents} ``` ## Prerequisites and Resources There are no formal prerequisites for the course, but I will expect you to be comfortable with the material discussed in the {ref}`sec:Prerequisites` section, which contains links to additional resources should you need to refresh your knowledge. Generally, I will expect familiarity with the following: Domain Specific Preparation: : The most important prerequisite is the ability to communicate about and formulate complex problems in your field of study that would benefit from the techniques covered in this course. Students will expected to actively engage with the techniques taught in this course, apply them to relevant problems in their domain of expertise, and to communicate about the efficacy to the class. Linear Algebra : Properties of Linear Operators (Self-Adjoint, Hermitian, Unitary, etc.), Matrix Factorization including the Singular Value Decomposition, Bases and Orthogonalization via [Gram-Schmidt](https://en.wikipedia.org/wiki/Gram%E2%80%93Schmidt_process). Real and Complex Analysis : Topology (notions of continuity), Calculus, [Banach spaces](https://en.wikipedia.org/wiki/Banach_space) (e.g. conditions for the existence of extrema), Fourier Analysis, Contour Integration, Conformal Maps. Differential Equations : Formulation of differential equations, existence of solutions and boundary value requirements, [Sturm-Liouville Theory](https://en.wikipedia.org/wiki/Sturm%E2%80%93Liouville_theory). Programming Skills : There are some specific skills you will need for this course, including basic programming skills, distributed version control, how to connect remotely to computers etc. with [SSH][]. We will use the [CoCalc][] platform so you do not need to install any of the software on your computer. See the {ref}`sec:prerequisites` section for details and learning resources. :::{include} Textbooks.md ::: ### Student Learning Outcomes The main objective of this course is for students to be able to effectively use numerical techniques to solve complex problems following principles of good software engineering and reproducible computing. 1. **Reproducible Computing:** Write and communicate computational results in a way that allows one to reproduce these results in the future, possibly on different computing platforms. 2. **Problem Assessment:** Be able to assess complex problems to determine if computational techniques will contribute to their solutions. 3. **Choice of Algorithm/Technique:** Be able to identify which algorithms are appropriate for solving the computational problems. 4. **Implementation:** Be able to implement the chosen algorithm. 5. **Convergence and Performance Analysis:** Be able to quantify and understand the convergence and performance of the algorithm being used. 6. **Solution Assessment:** Be able to assess the validity of the solution. For example, to quantify the uncertainties associated with the results, accounting for the accumulation of round-off, truncation, and discretization errors, with an understanding of the conditioning of both the problem and the algorithm. 7. **Communicate and Defend the Solution:** Communicate the results with peers, defending the approximations made, the accuracy of the techniques used, and the assessment of the solutions. Demonstrate insight into the nature of the solutions, making appropriate generalizations, and providing intuitive descriptions of the quantitative behavior found from solving the problem. These learning outcomes will be assessed through the assignments as follows: * By maintaining a code repository subject to automated testing, students will have to master all skills needed for reproducible computing (1). * Through the successful completion of their assignments, students will demonstrate the ability to choose a technique (3) and implement it (4). * Class assignments will test both accuracy and performance of the code. Passing the associated tests will require that students have understood the convergence and performance properties of there code (5). * Code coverage will ensure that students implement tests for their code, assessing their solutions (6). * Through code reviews and documentation, students will be required to communicate and defend their solutions (7). (sec:CourseTimeline)= ## Course Timeline :::::{list-table} Course Timeline :header-rows: 1 * - Date                - [Pragmatic Programmer Topic](https://research.ebsco.com/c/5vlwng/ebook-viewer/epub/2i7ajzij2v)      - Topics * - Week 1:
(18, 20 Aug) - **1:** It's Your Life
**2:** The Cat Ate My Source Code
**3:** Software Entropy
**4:** Stone Soup and Boiled Frogs
**22:** Engineering Daybooks - CoCalc, General programming: Loops, Conditionals, Functions, Abstract Data Types (Queue, Priority Queue, Searching, and Sorting). * - Week 2:
(25, 27 Aug) - **5:** Good-Enough Software
**6:** Your Knowledge Portfolio
**7:** Communicate!
**8:** The Essence of Good Design - Survey, Recursion, Printing, Arrays, Plotting, Data, Floating Point Numbers, Finite difference derivatives, Round-off errors vs. truncation error * - Week 3:
(1, 3 Sep) - **9:** DRY - The Evils of Duplication
**10:** Orthogonality *(1 Sep = Labour Day - No class)* - Floating Point Numbers, Finite difference derivatives, Round-off errors vs. truncation error * - Week 4:
(8, 10 Sep) - **11:** Reversibility
**12:** Tracer Bullets
**13:** Prototypes and Post-it Notes - Reading data. Fitting. Random numbers, seeds, MC integration * - Week 5:
(15, 17 Sep) - **14:** Domain Languages
**15:** Estimating
**16:** The Power of Plain Text
**17:** Shell Games - Spline interpolation, Model fitting (least squares) * - Week 6:
(22, 24 Sep) - **18:** Power Editing
**19:** Version Control - Version control (git/mercurial/jujitsu), Sums and Integrals (trapezoid), Changing variables * - Week 7:
(29 Sep, 1 Oct) - **20:** Debugging
**21:** Text Manipulation
**22:** You Cant Write Perfect Software
- Debugging code, ODEs * - Week 8:
(6, 8 Oct) - **23:** Design by Contract
**24:** Dead Programs Tell No Lies
**25:** Assertive Programming - PDEs * - Week 9:
(13, 15 Oct) - **26:** How to Balance Resources
**27:** Don't Outrun Your Headlights
**28:** Decoupling
**29:** Juggling the Real World - Optimization and Root Finding * - Week 10:
(20, 22 Oct) - **30:** Transforming Programming
**31:** Inheritance Tax
**32:** Configuration
**33:** Breaking Temporal Coupling - Data Types: Sets, Tuples, Maps/Dictionaries, Stacks, Trees (binary), Hashtables * - Week 11:
(27, 29 Oct) - **34:** Shared State is Incorrect State
**35:** Actors and Processes - Linear algebra, Condition number, LU/Cholesky, QR (Gram Schmidt), Eigenvalues, SVD, $e^{\mat{M}}$ * - Week 12:
(3, 5 Nov) - **36:** Blackboards
**37:** Listen to Your Lizard Brain
**38:** Programming by Coincidence
**50:** Coconuts Don’t Cut It - TBD * - Week 13:
(10, 12 Nov) - **39:** Algorithm Speed
**40:** Refactoring
**41:** Test to Code
**42:** Property-Based Testing - Algorithms, Complexity, Memory, Testing * - Week 14:
(17, 19 Nov) - **43:** Stay Safe Out There
**44:** Naming Things
**45:** The Requirements Pit
**46:** Solving Impossible Puzzles
**47:** Working Together
**49:** Pragmatic Teams - Plotting, Log/Log, Axes labels, Units, Legends, Histograms, 3D, Animations * - Week 15:
(24, 26 Nov) - **51:** Pragmatic Starter Kit
**52:** Delight Your Users
**53:** Pride and Prejudice - *(Thanksgiving - No class)* * - Week 16:
(1, 3 Dec) - **48:** The Essence of Agility - *(Dead week)* ::::: (sec:SpecificSkills)= ### Specific Skills Oracle Expert Familiar Aware unaware * Programming Constructs * Loops * Conditionals * Classes (Object Oriented) * Coroutines * Printing * Reading input/files * Installing stuff * Windows Subsystem for Linux * Understand floating point numbers: * [E, A] Model for estimating round-off error. * [E, F] Estimate the memory requirements for storing arrays of data. * [E, E] Know that single precision exists, and might be of use. * Know how to use pseudo-random numbers: * [F, F] To perform statistical tests of models. * [F, F] Be able to generate arbitrary distributions given uniform deviates. (MCMC) * [F, u] MC integration. * [A, A] Metropolis * [E, E] Know how and why to use a seed. * [F, F] Be aware that not all generators are good, and know how to find good ones. * Know how to load data for analysis: * [F, F] Download data from the internet (`wget`, `curl`, etc.). * [A, A] Convert data to a machine-readable format. (Using `regex` for text processing, knowing about `SQL` for database access, `CSV` files, `JSON`, `YAML`, `HDM5`, `.npy` and `.npz` files, memory-mapped files, etc.) * [A, A] Be able to work with data that does not fit into memory. * [A, A] Have a toolkit for plotting/displaying large amounts of data. * Interpolation: * [F, F] Splines * [F, E] Spectral Methods / RBF * [u, u] Regression? * Signal Analysis: * [E, E] FFT * [F, F] Windowing/Aliasing * [A, u] Linear Predictive Coding (LPC) * Differentiation: * [E, E] Finite difference: truncation vs. round-off errors. * [F, F] Richardson extrapolation. * [F, E] Spectral methods. * [F, u] Automatic differentiation. * Integration: * [E, E] Trapezoidal and Simpsons * [F, A] Quadrature * [F, F] Adaptive integration * [E, E] Changing variables * [F, u] MC integration for high dimensions * ODEs * [E, E] Euler method and error analysis * [F, u] Backward Euler (stiff ODEs) * [F, F] RK45 * [A, u] Bulrich-Stoer (Richardson extrapolation) * [E, E] Changing variables * PDEs * [E, E] Finite Difference: boundary conditions * [F, E] Spectral Methods (Basis expansion) * [F, A] Pseudo Spectral Methods (DVR) (Basis expansion with colocation points) * [A, A] Finite Element Methods * [F, E] [Courant-Freidrichs-Lewy condition][] (CFL) * [A, E] Tensor product (higher dimensions) * Optimization/Root Finding: * [E, F] Gradient Descent * [E, E] Newton's Method * [F, A] Broyden's Method (and L-BGFS-B) * Data Types: * [E, E] Sets * [E, E] Tuples * [F, u] Linked Lists * [E, E] Stack * [E, u] Queues (parallel programming) * [F, F] Trees * [F, F] Balanced binary trees. * [F, F] [$k$-d trees][] * [A, A] Where $\log N$ comes into costs. * [F, F] Graphs/Networks * [F, F] Hash-tables * [F, u] Heaps * [F, F] Priority Queues * [E, E] Arrays * [F, F] Sparse arrays * Algorithms: * [E, F] o() O() notation * [E, F] Searching * [E, F] Sorting * [E, A] Quick sort ($N^2$ worst-case) * [E, A] Merge sort/Heap sort ($N\log N$ worst case) * [E, A] Radix sort. * [A, F] Primality testing? * [F, A] Convex Hull * [F, A] Tree/graph traversal (BFS, DFS, Dijkstra, Min-cut/Max-flow) * [A, u] Dynamic Programming (What algorithms are best? Is there one that has a good quantum solution? I seem to recall the Knapsack problem having a quantum solution...) * [E, E] FFT * [E, E] Convolution theorem * [A, A] Big Number multiplication * [E, E] SVD/Eigenvalues/Krylov * [A, A] Multigrid (Galerkin) * [A, A] Multipole * Linear Algebra: * [E, u] Condition number. * [E, F] LU/Cholesky * [E, E] QR (Gram Schmidt) * [E, E] Eigenvalues * [E, E] SVD * [E, E] Matrix Exponential * Taylor Expansion * Diagonalization * Troterization * ODE * Plotting: * [E, E] Log-Log etc. * [E, E] Axis labels. Units. * [E, E] Histograms (errors), KDE * [F, F] 3D * [F, F] Animations * Languages: * [F, F] Python * Numpy/Scipy/Pandas/Matplotlib/Uncertainties/Sympy * [F, F] C++/Fortran * [F, F] MATLAB * [A, A] Julia * [A, A] Make * [F, F] Bash (Terminal) * [A, A] Regex * [F, F] Sympy/Maple/Mathematica * [A, A] Spreadsheets * [A, A] Haskell/F#/Verse * [A, A] SQL * [A, A] HTML/CSS * [A, A] Java * [A, A] Javascript/Typescript * [F, F] TeX/LaTeX * Tools * git * hg * jujutsu * jinja * cpp * linters * sed/awk * make/cmake * curl/wget * conda/pip/pdm/npm/apt/macports/homebrew * tar/gzip/zip * imagemagick/ffmpeg * Editors (Emacs/Vi/VS-Code/Spyder/PyCharm) * JupyterLab * Jupyterbook * Sphinx * PyTest * Hardware * CPU/FPU * GPU * [A, u] Cache * Memory * Disk * Bus * Pipelines * Network * Pragmatic Programming * Problem solving with Code (How to tell a computer how to solve your problem. Advantages of different languages.) * Recursion. Tail recursion. Stackless programming * Iterative vs Declarative * Scope * Cache * Parallel Programming * Debugging * Optimization Algorithms: o() O() notation Searching Sorting Quick sort ($N^2$ worst-case) Merge sort/Heap sort ($N\log N$ worst case) Radix sort. Primality testing? Convex Hull Tree/graph traversal (BFS, DFS, Dijkstra, Min-cut/Max-flow) Dynamic Programming FFT Convolution theorem Big Number multiplication SVD/Eigenvalues/Krylov Multigrid (Galerkin) Multipole Linear Algebra: Condition number LU/Cholesky QR (Gram Schmidt) Eigenvalues SVD Matrix Exponential Taylor Expansion Diagonalization Troterization ODE Plotting: Log-Log etc Axis labels. Units Histograms (errors), KDE 3D Animations Languages: Python Numpy/Scipy/Pandas/Matplotlib/Uncertainties/Sympy C++/Fortran MATLAB Julia Make Bash (Terminal) Regex Sympy/Maple/Mathematica Spreadsheets Haskell/F#/Verse SQL HTML/CSS Java Javascript/Typescript TeX/LaTeX Tools git hg jujutsu jinja cpp linters sed/awk make/cmake curl/wget conda/pip/pdm/npm/apt/macports/homebrew tar/gzip/zip imagemagick/ffmpeg Editors (Emacs/Vi/VS-Code/Spyder/PyCharm) JupyterLab Jupyterbook Sphinx PyTest Hardware CPU/FPU GPU Cache Memory Disk Bus Pipelines Network Pragmatic Programming * Problem solving with Code (How to tell a computer how to solve your problem. Advantages of different languages.) * Recursion. Tail recursion. Stackless programming * Iterative vs Declarative * Scope * Cache * Parallel Programming * Debugging * Optimization ### Expectations for Student Effort Students are expected to: 1. Stay up to date with reading assignments. 2. Participate in online forums, both asking questions and addressing peers questions. 3. Identify areas of weakness, work with peers to understand difficult concepts, then present remaining areas of difficulty to the instructor for personal attention or for discussion in class. 4. Complete assignments on time, providing well crafted solutions to the posed problems that demonstrate mastery of the material through the [Learning Outcomes](#learning-outcomes) 1-7. Student's are encouraged to discuss their intended approach with peers and with the instructor, but must ultimately write their own code. For each hour of lecture equivalent, students should expect to have a minimum of two hours of work outside class. ### Assessment and Grading Policy 1. Submit and have approved 2 Pull Requests (Merge Requests) resolving issues in open source project hosted on [GitHub][] (or [GitLab][]) or the class project. Be careful to familiarize yourselves with the community guidelines for the projects, and follow their protocol for ensuring that your contribution meets style, testing, and documentation guidelines. Projects outside of the class repository must be approved by your instructor. 2. Maintain your own repository for the class where you solve the assigned problems, and document your solutions. Template projects will be provided using [JupyterBook][]. 3. Pose, solve, and document a problem of interest from your domain of study, producing a paper in the format of a journal relevant for your field. The paper need not be submitted or accepted for publication, but this should be your goal. Papers will undergo in-class review. Grading will be largely automated: you are expected to maintain a project on [GitLab][] where you keep the code in a [Git][] clone of the [Official Course Repository][]. Your projects should contain all of the code you develop for this course, including solutions to the assignments. This code should be well-documented, and well-tested using [GitLab]'s continuous integration (CI) tools. Each assignment (see {ref}`sec:assignments` for details) will be distributed as a set of files made available through the `main` branch of the [Official Course Repository][]: you will be instructed when to pull and merge these with your project. These assignments will contain skeleton code and tests. You will be expected to complete the skeleton code so that the tests pass. These will include python code with skeleton functions, class, etc. which you are expected to complete, along with automated tests (which you must not modify) for the assignment, and CI instructions such that these tests can be run on [GitLab], producing a badge for that assignment. Your numeric grade for the course will be the percentage of passing assignment test badges for your code. Thus, if there are 10 assignments in the course and you have passing tests for 8 of those, you will have a grade of 80%. The final grade will be converted to a letter grade using the following scale: | Percentage P | Grade | | ------------------ | ----- | | 90.0% ≤ P | A | | 85.0% ≤ P \< 90.0% | A- | | 80.0% ≤ P \< 85.0% | B+ | | 75.0% ≤ P \< 80.0% | B | | 70.0% ≤ P \< 75.0% | B- | | 65.0% ≤ P \< 70.0% | C+ | | 60.0% ≤ P \< 65.0% | C | | 55.0% ≤ P \< 60.0% | C- | | 50.0% ≤ P \< 55.0% | D+ | | 40.0% ≤ P \< 50.0% | D | | P \< 40.0% | F | As discussed in section {ref}`sec:assignments`, there will be two stages of testing for each assignment. Completion of the first stage tests will allow you to get up to a grade of A-. Successful completion of sufficient second stages will be required for an overall A in the course. *Currently there is no other mechanism for partial credit, but I will attempt to implement this during the course.* As a fail-safe, you will get a minimum grade of a B+ if you meet the following requirements: * You make a reasonable attempt to solve the assignments by writing functioning code in your project. This code should be well documented, appropriately commented, and should follow best coding practices. * You write comprehensive automated tests for your code which pass when run using the [GitLab][] CI, resulting in at least 85% code coverage. * You participate in at least one formal code review of either code pertaining to a project in your domain of focus, or a randomly selected assignment, where we go over your code as a class, looking for potential bugs, places for optimizing performance, etc. The `main` branch of the [Official Course Repository][] will meet these requirements, and will provide a skeleton of all the code needed to make and run the tests. Thus, you should be able to easily maintain this standard as you develop code, obtaining a minimum grade of B+ with modest effort. I expect some of the assignments will be challenging, so to obtain a grade of A will require some commitment and skill. There will be no exams in this course. ### Attendance and Make-up Policy While there is no strict attendance policy, students are expected attend an participate in classroom activities and discussion. Students who miss class are expected to cover the missed material on their own, e.g. by borrowing their classmates notes, reviewing recorded lectures (if available), etc. ### Course Timeline The following details the content of the course. It essentially follows the main textbook. Content from the supplement will be inserted as appropriate throughout. Details and further resources will be included on the lecture pages on the [Canvas][] server. 1. Introduction and Basic Principles *(~2-3 week)* - Structure of the course. - Establish accounts and appropriate projects on [CoCalc][] and [GitLab][] - Numerical Evaluation of functions: Round-off error etc. (Assignment 0). - The Monty Hall Problem: Simple Monte Carlo Analysis (Assignment 1). 2. Basic Techniques *(~2-3 weeks)* - Differentiation and Integration. - Optimization and Root Finding. - Interpolation: Splines, Polynomials, Radial Basis Functions (RBF), Gaussian Processes. - Loops, Arrays, etc. - Bases. 3. Curve Fitting/Cycle Finding *(~2 week)* - Finding cycles in data. - Least squares fitting. - Fourier analysis. - Other techniques. - Bayesian techniques. 4. Ordinary Differential Equations (ODEs) *(~1-2 week)* - Orbiting Planets. - Falling Objects. - Agent-Based Modeling. 5. Partial Differential Equations (PDFs) *(~2 weeks)* - Schrodinger Equation - Fluid Dynamics - Diffusion 6. Other Topics/Domain Specific Problems *(~4-6 weeks)* - Renormalization Group, Effective Theories - Cellular Automata - Domain specific problems designed to address challenging problems in the fields of study represented by participants in the class. - Visualization techniques. - Profiling and Optimization. ### Topics Exact topics and techniques will be chosen to match the interests and needs of the participants (who are expected to communicate these needs to the instructor in advance of the course), but may include: * Case-studies: Part of the course will explore real-world examples of how physics has inspired solutions to hard problems in other fields of study. * [Renormalization Group Theory to understand traffic flow](https://discourse.iscimath.org/t/mar-17-renormalization-group-theory-the-systems-engineering-perspective/491). * Root-finding and Optimization * Finding ground states and excited states in quantum mechanics. * Density Functional Theory (DFT) * Machine learning *(Probably not in the first year...)* * Reaction/Diffusion networks: * Heat flow. * Hair follicle morphogenesis ([Turing's problem](https://en.wikipedia.org/wiki/The_Chemical_Basis_of_Morphogenesis)). * Ordinary Differential equations and Boundary Value Problems: * Classical Mechanics * Classical Chaos * Time-dependent Schrödinger equation. * Partial Differential Equations * Time-dependent Schrödinger equation/Time-dependent DFT (TDDFT) * Fluid dynamics *(Continuing from Matt's course)*. * Simple parallization: what to do when your data does not fit on a single node. *(@m.duez)* * Numerical Relativity *(Probably not in the first year...)* * Finite element techniques + Green's Functions for wave dynamics *(Talk to Phil)*. * Monte Carlo * Simulation of thermodynamic systems * Numerical experiments with Renormalization Group * Quantum Monte Carlo (QMC) *(Probably not in the first year...)* * Bayesian Analysis * Linear and Non-linear model fitting which properly characterized errors. * Manifold reduction techniques. * Data Analysis * How to access, store, and analyze data. * Clustering and searching in high dimensions. *(@gworthey)* ## Other Information ### Policy for the Use of Large Language Models (LLMs) or Generative AI in Physics Courses The use of LLMs or Generative AI such as Chat-GPT is becoming prevalent, both in education and in industry. As such, we believe that it is important for students to recognize the capabilities and inherent limitations of these tools, and use them appropriately. To this end, **please submit 4 examples of your own devising:** * Two of which demonstrate the phenomena of "hallucination" -- Attempt to use the tool to learn something you know to be true, and catch it making plausible sounding falsehoods. * Two of which demonstrate something useful (often the end of a process of debugging and correcting the AI). Note: one can find plenty of examples online of both cases. Use these to better understand the capabilities and limitations of the AIs, but for your submission, please find your own example using things you know to be true. *If you are in multiple courses, you may submit the same four examples for each class, but are encouraged to tailor your examples to the course.* Being able to independently establish the veracity of information returned by a search, an AI, or indeed any publication, is a critical skill for a scientist. **If you are the type of employee who can use tools like ChatGPT to write prose, code etc., but not accurately validate the results, then you are exactly the type of employee that AI will be able to replace.** Any use of Generative AI or similar tools for submitted work must include: 1. **A complete description of the tool.** (E.g. *"ChatGPT Version 3.5 via CoCalc's interface"* or *Chat-GPT 4 through Bing AI using the Edge browser"*, etc.) 2. **A complete record of the queries issued and response provided.** (This should be provided as an attachment, appendices, or supplement.) 3. **An attribution statement consistent with the following:** *“The author generated this in part with as documented in appendix <1>. Upon generating the draft response, the author reviewed, edited, and revised the response to their own liking and takes ultimate responsibility for the content.”* ### Academic Integrity You are responsible for reading WSU’s [Academic Integrity Policy][], which is based on [Washington State law][]. If you cheat in your work in this class you will: * Fail the course. * Be reported to the [Center for Community Standards][]. * Have the right to appeal the instructor's decision. * Not be able to drop the course or withdraw from the course until the appeals process is finished. If you have any questions about what you can and cannot do in this course, ask your instructor. If you want to ask for a change in the instructor's decision about academic integrity, use the form at the [Center for Community Standards][] website. You must submit this request within 21 calendar days of the decision. [Academic Integrity Policy]: [Washington State law]: [Center for Community Standards]: ### University Syllabus Students are responsible for reading and understanding all university-wide policies and resources pertaining to all courses (for instance: accommodations, care resources, policies on discrimination or harassment), which can be found in the [university syllabus][]. [university syllabus]: ### Students with Disabilities Reasonable accommodations are available for students with a documented disability. If you have a disability and need accommodations to fully participate in this class, please either visit or call the Access Center at (Washington Building 217, Phone: 509-335-3417, E-mail: , URL: ) to schedule an appointment with an Access Advisor. All accommodations MUST be approved through the Access Center. For more information contact a Disability Specialist on your home campus. ### Campus Safety Classroom and campus safety are of paramount importance at Washington State University, and are the shared responsibility of the entire campus population. WSU urges students to follow the “Alert, Assess, Act,” protocol for all types of emergencies and the “[Run, Hide, Fight]” response for an active shooter incident. Remain ALERT (through direct observation or emergency notification), ASSESS your specific situation, and ACT in the most appropriate way to assure your own safety (and the safety of others if you are able). Please sign up for emergency alerts on your account at MyWSU. For more information on this subject, campus safety, and related topics, please view the FBI’s [Run, Hide, Fight] video and visit [the WSU safety portal][the wsu safety portal]. ### Students in Crisis - Pullman Resources If you or someone you know is in immediate danger, DIAL 911 FIRST! * Student Care Network: https://studentcare.wsu.edu/ * Cougar Transit: 978 267-7233 * WSU Counseling and Psychological Services (CAPS): 509 335-2159 * Suicide Prevention Hotline: 800 273-8255 * Crisis Text Line: Text HOME to 741741 * WSU Police: 509 335-8548 * Pullman Police (Non-Emergency): 509 332-2521 * WSU Office of Civil Rights Compliance & Investigation: 509 335-8288 * Alternatives to Violence on the Palouse: 877 334-2887 * Pullman 24-Hour Crisis Line: 509 334-1133 [communitystandards.wsu.edu]: https://communitystandards.wsu.edu/ [definitions of cheating]: https://apps.leg.wa.gov/WAC/default.aspx?cite=504-26-010 [run, hide, fight]: https://oem.wsu.edu/emergency-procedures/active-shooter/ [the wsu safety portal]: https://oem.wsu.edu/about-us/ [wac 504-26-010(4)]: https://apps.leg.wa.gov/WAC/default.aspx?cite=504-26 [SSH]: "SSH on Wikipedia" [Canvas]: [CoCalc]: "CoCalc: Collaborative Calculation and Data Science" [GitLab]: "GitLab" [GitHub]: "GitHub" [Git]: "Git" [Anki]: "Powerful, intelligent flash cards." [Official Course Repository]: "Official Course Repository hosted on GitLab" [Shared CoCalc Project]: "Shared CoCalc Project" [WSU Courses CoCalc project]: [The Pragmatic Programmer]: [DRY]: [JupyterBook]: