archive previous course edition

Author: wprzytula

content/lessons/old/2022Z/00_organizational/index.md

@@ -0,0 +1,30 @@
++++
+title = "Oragnizational lesson"
+date = 2022-10-10
+weight = 0
+[extra]
+lesson_date = 2022-10-10
++++
+
+# JNP 3: Rust
+
+We will be using [Github Classroom](https://classroom.github.com) for task submission and [Discord](https://discord.gg/j2JFAsj7) for discussions.
+
+Our main learning/teaching resource will be ["The Book"](https://doc.rust-lang.org/stable/book/).
+
+## Grading
+
+- 1/3 of the grade is based on small tasks. There will be approximately 1 task every two weeks and each task will be graded on a scale of 0 to 3.
+- 2/3 of the grade is based on a big project. You can choose a topic yourself, but it must be accepted by me. The project has to be split into two parts. It can be done in groups of two (or bigger).
+- The grade may be increased by a bonus. You can get a bonus for:
+  - Making a presentation about some advanced topic (const generics, futures, macros, etc.) or about architecture of a selected Rust open-source library
+  - Contributing to a selected Rust open-source library
+  - Contributing to this course's materials
+  - Quizzes, homeworks, etc.
+
+## Project Deadlines
+
+1. 2022-11-11: Project ideas should be presented to me for further refining. If you wish to pair up with someone, now is the time to tell me.
+2. 2022-11-18: Final project ideas should be accepted by now.
+3. 2022-12-16: Deadline for submitting the first part of the project.
+4. 2023-01-13: Deadline for submitting the second and final part of the project.

content/lessons/old/2022Z/01_introduction/clippy.jpg

@@ -0,0 +1,20 @@
+#![allow(unused_variables)]
+
+fn main() {
+    let x = 42;
+
+    if x == 42 {
+        println!("x is 42");
+    } else if x == 43 {
+        println!("x is 43");
+    } else {
+        println!("x is not 42 or 43");
+    }
+
+    // we can also use ifs as expressions
+    let a_or_b = if x == 0 {
+        "a" // notice no semicolon at the end
+    } else {
+        "b"
+    };
+}

content/lessons/old/2022Z/01_introduction/conditionals.rs

@@ -0,0 +1,35 @@
+#include <stdio.h>
+
+#define LENGTH 3
+
+int main() {
+    //# Syntax error
+    // printf("hello world";
+
+    //char* array[LENGTH] = {"hello", "ancient", "world!"};
+
+    //# Array out-of-bounds with a statically known index
+    // printf("%s\n", array[LENGTH]);
+
+    //# Array out-of-bounds with a dynamically computed index
+    // for (int i = 0; i <= LENGTH; i++) {
+    //     printf("%s\n", array[i]);
+    // }
+
+    //# Doing God knows what
+    // char* format = "a very innocent hello %s";
+    // printf(format);
+
+    //# Division by zero
+    // int joy_division = 1/0;
+
+    // int joy = 0;
+    // int joy_division = 1/joy;
+
+    // int joy = 0 ? 1 : 0;
+    // int joy_division = 1/joy;
+
+    // printf("joy division equals %d", joy_division);
+
+    return 0;
+}

content/lessons/old/2022Z/01_introduction/cpp_meme.jpg

@@ -0,0 +1,49 @@
+#include <iostream>
+#include <cstdio>
+#include <array>
+
+using std::cout;
+using std::endl;
+
+int main() {
+    //# Syntax error
+    // cout < "hello world";
+
+    // constexpr int length = 3;
+    // std::array<std::string, length> array = {"hello", "old", "world!"};
+
+    //# Array access with an out of bounds index and bounds checking during compile time
+    // cout << std::get<length>(array) << endl;
+
+    //# Array access with an out of bounds index and bounds checking during runtime
+    // cout << array.at(length) << endl;
+
+    //# Most common access without any checks
+    // cout << array[length] << endl;
+    
+    //# Array out-of-bounds with a dynamically computed index
+    // for (int i = 0; i <= length; i++) {
+    //     cout << array.at(i) << endl;
+    // }
+
+    //# This will be there in Clang 14 ...
+    // std::string format = std::format("a very innocent hello {}");
+    // cout << format << endl;
+
+    //# ... but for now, this is doing God knows what
+    // const char* format = "a very innocent hello %s";
+    // printf(format);
+
+    //# Division by zero
+    // int joy_division = 1/0;
+
+    // int joy = 0;
+    // int joy_division = 1/joy;
+
+    // int joy = false ? 1 : 0;
+    // int joy_division = 1/joy;
+
+    // cout << "joy division equals " << joy_division << endl;
+
+    return 0;
+}

content/lessons/old/2022Z/01_introduction/errors_demo.c

@@ -0,0 +1,29 @@
+fn main() {
+    //# Syntax error
+    // println("hello world");
+
+    // let array = ["hello", "new", "world!"];
+
+    //# Array out-of-bounds with a statically known index
+    // println!("{}", array[3]);
+
+    //# Array out-of-bounds with a dynamically computed index
+    // for i in 0..=array.len() {
+    //     println!("{}", array[i]);
+    // }
+
+    //# An unsuccessful attempt at emulating C++'s ability to read the memory we're not supposed to access
+    // let format = "a very innocent hello {}";
+    // println!(format);
+
+    //# Division by zero
+    // let joy_division = 0/0;
+
+    // let joy = 0;
+    // let joy_division = 0/joy;
+
+    // let joy = if false {1} else {0};
+    // let joy_division = 0/joy;
+
+    // println!("{}", joy_division);
+}

content/lessons/old/2022Z/01_introduction/errors_demo.cpp

@@ -0,0 +1,12 @@
+fn get_5() -> u32 {
+    5 // we could also write "return 5;"
+}
+
+fn print_sum(a: u32, b: u32) {
+    println!("a + b = {}", a + b);
+}
+
+fn main() {
+    let a = 100;
+    print_sum(a, get_5());
+}

content/lessons/old/2022Z/01_introduction/errors_demo.rs

@@ -0,0 +1,4 @@
+fn main() {
+    let name = "World";
+    println!("Hello, {}!", name); // using the println! macro
+}

content/lessons/old/2022Z/01_introduction/functions.rs

@@ -0,0 +1,118 @@
++++
+title = "Introduction to Rust"
+date = 2022-10-10
+weight = 1
+[extra]
+lesson_date = 2022-10-10
++++
+
+![Logo](https://www.rust-lang.org/logos/rust-logo-blk.svg)
+
+# A language empowering everyone to build reliable and efficient software.
+
+([unofficial logo](https://rustacean.net/))
+
+## Why use Rust?
+
+- It is **safe** (compared to C++ for example, as we will see in a minute)
+- It is **fast** (because it is compiled to machine code)
+- It is ergonomic and pleasant to use (static typing, expressive type system, helpful compiler
+  warnings)
+- It
+  is [loved by programmers](https://insights.stackoverflow.com/survey/2021#section-most-loved-dreaded-and-wanted-programming-scripting-and-markup-languages)
+- It provides excellent tooling
+
+## Why learn Rust?
+
+Even if you don't end up using Rust, learning it expands your horizons
+
+- it helps especially with the awareness of what you can and can't do in concurrent applications
+- it helps you understand memory management and learn its good practices
+
+## Why not to learn Rust?
+
+- Some people say Rust is too hard to learn because of the borrow checker
+- Once you get to know Cargo you won't ever want to use a language without a built-in package
+  manager ;)
+- You will start hating C++
+
+## Demos
+
+![Meme](cpp_meme.jpg)
+
+Let's compare the same code written in [C](errors_demo.c), [C++](errors_demo.cpp)
+and [Rust](errors_demo.rs).
+
+## Code you sent me!
+
+### Aleksander Tudruj
+
+{{ include_code_sample(path="lessons/01_introduction/students/tudruj.cpp", language="cpp") }}
+
+### Krystyna Gasińska
+
+{{ include_code_sample(path="lessons/01_introduction/students/gasinska.py", language="python") }}
+
+### Antoni Koszowski
+
+{{ include_code_sample(path="lessons/01_introduction/students/koszowski.go", language="go") }}
+
+### Mieszko Grodzicki
+
+{{ include_code_sample(path="lessons/01_introduction/students/grodzicki.py", language="python") }}
+
+## Installing Rust
+
+- [Rustup](https://rustup.rs/)
+- Setup an IDE
+  - [CLion](https://www.jetbrains.com/clion/) (you can get
+    it [for free](https://www.jetbrains.com/community/education/))
+    and [Intellij-Rust](https://intellij-rust.github.io/)
+  - [VSCode](https://code.visualstudio.com/)
+    and [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=matklad.rust-analyzer)
+  - rust-analyzer also works
+    with [other IDEs](https://rust-analyzer.github.io/manual.html#installation)
+
+## Useful tools
+
+![Clippy](clippy.jpg)
+
+- `cargo clippy` (for static analysis)
+- there's also `cargo check`, but it's less powerful than clippy
+- `cargo fmt` (for code formatting)
+
+### Rust Playground
+
+- [online Rust compiler](https://play.rust-lang.org/)
+
+## Hello world
+
+{{ include_code_sample(path="lessons/old/2021L/01_introduction/hello_world.rs", language="rust") }}
+
+### Variables
+
+{{ include_code_sample(path="lessons/old/2021L/01_introduction/variables.rs", language="rust") }}
+
+### Conditionals
+
+{{ include_code_sample(path="lessons/old/2021L/01_introduction/conditionals.rs", language="rust") }}
+
+### Loops
+
+{{ include_code_sample(path="lessons/old/2021L/01_introduction/loops.rs", language="rust") }}
+
+### Functions
+
+{{ include_code_sample(path="lessons/old/2021L/01_introduction/functions.rs", language="rust") }}
+
+## Test assignment (not graded)
+
+Click [here](https://classroom.github.com/a/P_z-gHH-)
+
+## Obligatory reading
+
+- [The Book, chapters 1-3](https://doc.rust-lang.org/stable/book/)
+
+## Additional reading
+
+- [Rust By Example](https://doc.rust-lang.org/stable/rust-by-example/)

content/lessons/old/2022Z/01_introduction/hello_world.rs

@@ -0,0 +1,55 @@
+#![allow(unused_variables)]
+
+fn main() {
+    for i in 0..10 {
+        println!("i is {}", i); // i in [0, 10)
+    }
+
+    let mut x = 0;
+
+    while x < 50 {
+        x += 1;
+    }
+
+    let mut y = 0;
+    let mut iterations = 0;
+    loop {
+        iterations += 1;
+        if iterations % 2 == 0 {
+            continue;
+        }
+        y += 1;
+        if y == 10 {
+            break;
+        }
+    }
+
+    // we can use labels to refer to a specific loop
+    let mut count = 0;
+    'counting_up: loop {
+        let mut remaining = 10;
+
+        loop {
+            if remaining == 9 {
+                break;
+            }
+            if count == 2 {
+                break 'counting_up; // ends the outer loop
+            }
+            remaining -= 1;
+        }
+
+        count += 1;
+    }
+
+    // We can use break with a value.
+    // Because loops are expressions too,
+    // the value we break with will be returned from the functions
+    let mut counter = 0;
+    let value = loop {
+        counter += 1;
+        if counter == 10 {
+            break 32;
+        }
+    };
+}