Rust Programming Basics Quiz

Introduction to C/Rust Programming Languages

• Covered Lesson #22, Quiz #3 notes
• Introduces the C and Rust programming languages.

The Secret of the Red Dot

• Page 2 of the presentation.
• No further details on the topic.

An Introduction to the C/Rust Programming Languages

• Covered Lesson #17
• Topics include: Cargo, Comments, Variables, Data Types, Mutable/Immutable
• Page 3 of the presentation.

History of Rust

• Rust started as a personal language developed by Graydon Hoare for Mozilla in 2006.
• Officially recognized as a Mozilla-sponsored project in 2009.
• Publicly announced in 2010.
• First pre-alpha version released in January 2012.
• Current stable version is 1.16.
• Supported operating systems include: Linux, Windows, macOS, Android, iOS, etc.
• Page 4 of the presentation.

What is Rust?

• Rust is described as a "safe, concurrent, and practical language."
• Supports functional and imperative programming paradigms.
• Syntax is comparable to C++.
• Free and open-source software.
• Source code is openly available for anyone to enhance.
• Manages memory internally, eliminating the need for manual memory management functions such as calloc or malloc.
• Built to offer great performance similar to C and C++, prioritizing code safety, a known area where C++ and C struggle.
• Page 5 of the presentation.

Rust is Built on Other Languages

• Rust has a family tree of languages, including ML, Haskell, Cyclone, and C++.
• Page 6 of the presentation.

Why Use Rust?

• Prioritizes speed and safety and extraordinarily safe concurrency and memory management.
• Addresses two major concerns for C/C++ developers: memory errors and concurrent programming.
• Manages memory internally (no garbage collection required)
• Each reference has a lifespan, clearly defining its scope.
• Over 70% of security flaws in Microsoft products are due to memory safety concerns over the last 12 years.
• Page 7 of the presentation, Page 8 of the presentation.

Why Use Rust? (Continued)

• Provides low-level control similar to C, which is beneficial for systems programming.
• Protects against resource leakage issues.
• Other languages can use Rust projects as libraries using foreign function interfaces.
• Ideal for existing projects requiring higher performance and memory safety, allowing you to integrate crucial areas that need speed enhancement without significant restructuring of the entire application.
• Page 7 and Page 8.

Why Use Rust – The NSA Memo

• NSA released a memo on 11/10/2022 titled "Software Memory Safety."
• Memory issues in software are a significant component in exploitable vulnerabilities.
• The NSA suggests a strategic shift from languages with limited memory protection (like C/C++) to more memory-safe languages when possible and necessary.
• Memory safe languages include: C#, Go, Java, Ruby, Rust, and Swift.
• Page 9 of the presentation.

The Stack & The Heap

• Data stored on the stack is ordered, known size at compile time, and follows FIFO (First-In, First-Out).
• Data without a known size at compile time or with a size that may change is stored on the heap.
• Rust stores variables in the stack or the heap, with different behaviors for speed and size.
• Page 10 of the presentation.

Hello World and Variables

• Page 11 of the presentation.

"Hello World" in Rust

• Basic Rust "Hello, world!" program example.
• Page 12 of the presentation.

Picking Apart "Hello World"

• Explanation of the individual components of the Rust "Hello, world!" program.
• Page 13 of the presentation.

Picking Apart "Hello World" (Macros)

• Explains the println! macro as a method to "print and add a new line."
• Similar to functions but ends with an exclamation mark.
• Stays on the same line after printing (not the case for println).
• Page 14 of the presentation.

Rust Interpolation

• println! can include variable values directly within the string (interpolation).
• Page 15 of the presentation.

Interpolation

• Explanation of println! macro's use of curly braces.
• How parameters are separated.
• Page 16 of the presentation.

println! Macro

• println! macro accepts a placeholder and a variable name.
• Expands into more code than the original.
• Page 17 of the presentation.

The Difference Between Macros and Functions

• Macros are a way of writing code that writes other code (metaprogramming).
• println! macro generates more code than the original call.
• ! character marks macro invocation, not a function call.
• Macros, unlike functions, can take a flexible number of parameters.
• Macros are used before compile time, in contrast to the run-time execution of functions.
• Macro definitions are more complex, harder to read, understand, and maintain.
• Page 18 and Page 19 of the presentation

Anatomy of Rust

• Page 20 of the presentation.

Comments

• Two ways to create comments in Rust:
• // (single-line comment) and /* */ (multi-line comment). Everything inside the // or between /* */ will be ignored by the compiler
• Page 21 and Page 22 of the presentation.

Expressions, Values, and Types

• Values (e.g., numbers, booleans, strings) have types.
• Expressions are the way values are created in Rust.
• Evaluation is the process of converting an expression into a value.
• Page 23 of the presentation.

Effects Versus Results

• Effects are actions caused by evaluating an expression (e.g. printing to the console).
• Results are the values produced by expressions that may not cause immediate actions (e.g. arithmetic).
• println! macro causes a side effect through output display, but returns a result of type () (unit).
• Page 24 of the presentation.

Variables in Rust

• Variables are named storage locations that programs can access.
• Always linked with a specific data type, dictating storage size, usable value ranges, and available operations
• Page 25 of the presentation.

Variable Naming Rules

• Names can be letters, numbers, and underscores.

• Starts with a letter or an underscore.

• Case-sensitive.

• Typically use snake_case for variables and functions.

• Compiler warns if a declared variable is not used.

• Underscore prefix for variables that are not meant to be used. Not used variable prefixes will produce no warning messages

• Page 26 of the presentation.

Variable Naming Syntax

• Data type is optional.
• The assigned value determines the type.
• Syntax for declaring variables (with and without types).
• Page 27 of the presentation.

Number Separator

• Underscores can be used to improve readability of large numbers.
• Page 28 of the presentation.

Data Types in Rust

• The type system in Rust checks the provided values before the software stores or manipulates them, ensuring code works correctly.
• Rust is a statically typed language.
• Each value has an associated data type.
• Page 29 of the presentation.

Rust Scalar Types

• Scalar types hold a single value.
• Rust's scalar types include integers, floating-point numbers, booleans, and characters.
• Page 30 of the presentation.

Declaring Variables

• Variables are declared using the let keyword.
• Type is inferred from the value assigned.
• Page 31 of the presentation.

Unit

• A type and value representing the absence of a meaningful value.
• Use the () type and expression syntax when a value is not present or returned.
• Page 32 and Page 33 of the presentation.

Immutable

• Variables in Rust are immutable by default.
• Once a value is assigned, it cannot be changed.
• Page 34 of the presentation.

Let Without Assignment

• Valid to declare a variable without immediate assignment in Rust.
• Page 35 of the presentation.

Mutable

• mut keyword before a variable declaration allows for variable assignment changes.
• Page 36 of the presentation.

Number Types in Rust

• Integers are whole numbers (e.g., 5, -2, 0).
• Floating-point numbers can include decimal points.
• Page 37 of the presentation.

Math in Rust

• Standard math operators (+, -, *, /, %).
• pow, powi, powf functions for exponents.
• Floor division.
• Page 38 and Page 39 of the presentation.

Integers in Rust

• Integer types (signed and unsigned) are available in various bit sizes (e.g., i8, u32, isize).
• isize and usize are special types.
• Page 40 and Page 41 of the presentation.

Rust Integers

• Integer size is determined by the architecture (i.e., 32 bits or 64 bits).
• isize and usize are adaptable to different architectures.
• Page 42 of the presentation.

Integer Range

• Signed integers have a range from -2^n-1 to 2^n-1 -1.
• Unsigned integers have a range from 0 to 2ⁿ - 1. (n = number of bits)
• Page 43 and page 45 of the presentation.

Integer Overflow

• Overflow occurs when an assigned value exceeds the data type's permitted range (e.g., attempts to assign a value greater than 255 to a u8).
• Rust prevents access to out-of-range memory addresses during execution, causing a panic.
• Page 44 and Page 45 of the presentation.

Float Data Type

• Float types can be either f32 (single-precision) or f64 (double-precision). Default is f64.
• Page 46 of the presentation

Printing Floats

• Floats are formatted with syntax similar to C.
• Has formatting control over size, decimals, etc. Lacks comma separators and other advanced string formatting options found in C.
• Page 47 of the presentation.

Character Type

• char type in Rust stores Unicode characters.
• Page 48 of the presentation.

Attributes

• Attributes are a way to add extra information to declarations in Rust.
• #[...] and #![...] are used to control compiler warnings and code style checks, specify runtime behaviour, and interactions with code written in other languages.
• Page 49, Page 50, Page 51, Page 52, and Page 53 of the presentation.

Blocks and Statements

• Blocks ({}) are used to group statements.
• Statements execute in order; the last expression in a block is its result.
• Page 54, Page 55, Page 56, and Page 57 of the presentation.

Number Variables in Rust

• Example declaration and usage of number variables in Rust.
• Page 58 of the presentation.

Use of Multiple Variables

• Example usage and declaration and assignment of multiple variables.
• Page 59 of the presentation.

Reuse of Variable Names

• Variable shadowing in Rust when you reuse the same variable name; the new variable hides/shadows the previous one.
• Page 60 of the presentation.

Shadowing

• The prior variable is shadowed, so we can't use it later
• Page 61 of the presentation.

Types in Rust

• Rust uses type inference for many cases, eliminating explicit type declaration. However, there are instances where specifying types is beneficial.
• Page 62 of the presentation.

String and &str

• String type is dynamically sized, allocates memory on heap, can modify.
• &str is a string slice, is immutable, a reference to a string in memory that doesn't move. String slice references do not take ownership and thus do not have to be copied to memory.
• Page 63, Page 64, Page 65,Page 66,Page 67, and Page 68 of the presentation.

Creating Strings

• Creating an empty String.
• Creating a String from a string literal.
• Retrieving a string length.
• Mutable nature of String vs. immutable nature of &str.
• Page 69 of the presentation.

&String

• Reference to a String.
• The size is known at compile time as it is just a pointer to a String.
• Page 70 of the presentation.

&str

• Reference to a string slice (str) stored in memory.
• The size of a str is known at compile time
• Page 71 of the presentation.

&str (Conversion to String)

• Converting a &str (string slice) to a String.
• Page 72 of the presentation.

Tuple, User input, Files, Operators, If, Else, Match

• Lesson #19 covers tuples, user input, files, operators, if-else, match statements in Rust.
• Page 73 of the presentation.

Compound Types in Rust

• Combine multiple values into a single type.
• Tuples and arrays are examples.
• Page 74 of the presentation.

Tuples in Rust

• Tuples are compound data types.
• Scalar types can only store one data type per variable.
• Page 75 of the presentation.

Tuple Type

• Generic compound types combining multiple items of varying types.
• Fixed size once created.
• Formed by comma-separated list of values within parentheses.
• Types of values in a tuple don't need to be the same
• Page 76 of the presentation.

Tuples in Rust

• Syntax for creating tuples.
• Printing all values in a tuple.
• Page 77 of the presentation.

Formatting in println!

• Formatting directives for printing tuples can be used effectively
• Page 78 of the presentation

Tuple in Rust (Example)

• Accessing elements using indexing.
• Page 79 of the presentation

Tuple Type (Destructuring)

• Binding tuples to variables. Destructuring (Extract Individual Values).
• Page 80 of the presentation

Tuple type (Index Access)

• Accessed using the dot operator followed by index starting at 0 for the first element.
• Page 81 of the presentation.

Tuple Type (Unit)

• Tuples with no values also exist. Unit type and value. Implicit return if no other value is returned.
• Page 82 of the presentation.

Changing Tuples

• Tuples are immutable by default.
• The mut keyword is required to modify a tuple.
• Page 83 of the presentation

Decision Making in Rust

• If statements, if...else statements, else if for multiple conditions, conditional expression return values.
• Page 84 of the presentation.

Rust If Statement

• if statement evaluates a Boolean expression.
• Executes the code block only if the expression is true.
• Page 85 of the presentation.

Conditionals

• More complex expressions in if statements and in nested if...else statements (using && and other boolean operators).
• Page 87, Page 88, and Page 89 of the presentation.

A Note on Semicolons and ifs

• if expressions do not require semicolons.
• Page 90 of the presentation.

Else

• else clause to handle cases where the if condition is false.
• Page 91 and Page 92 of the presentation.

Evaluating to Values

• if can produce a result value.
• Page 93 of the presentation

Match Statement in Rust

Explanatory information on match statements/comparisons.

• Page 95 of the presentation.

Match Statement

• Matches a value to one from a list, like a switch statement in C. Does not require parentheses after the match clause
• Page 96 of the presentation.

### Match Example

• An example of how match works with different cases including a default case. Returns a string based on value input.
• Page 97 of the presentation

Arrays, Vectors, Loop, While

• Lesson #20 covers Array, Vector, Loop, and While statements in Rust.

Arrays and Vectors

• Three methods used to store sequences of values: arrays ([T; N]), vectors (Vec<T>), and slices (&[T] / &mut [T]). Descriptions of each
• Page 99 of the presentation.

Arrays and Vectors (Indexing, Length)

• Indexing elements of arrays/vectors (v[i]). Note that v must be passed by reference
• len() method used for getting the number of elements, indexing starts at 0, panic occurs if the index is out of bounds
• Page 100 of the presentation.

Arrays in Rust

• Variables have a scalar nature, this means only single values
• Arrays are used when the size is not expected to change during program execution, unlike vectors
• Page 101 of the presentation.

Array Declaration and Initialization

• Different syntaxes for declaring and initializing arrays.
• Page 102 of the presentation.

Arrays (Example Arrays)

• Example showing how to create an array. Using different initializer methods such as setting default values or creating explicit values
• Page 103, Page 108, Page 109, and Page 110 of the presentation.

Arrays (Invalid Element Access)

• Trying to access an array element beyond its bounds will produce a runtime error (panic). Rust prevents memory access outside of the array.
• Page 111 of the presentation

Invalid Array Element Access

• Rust safety guard on array accessing. len() method used in bounds checking before index access.
• Page 112 of the presentation.

Vectors

• Dynamically sized sequences of elements.
• Page 113 of the presentation.

Rust Vectors

• Module that provides a container Vec<T> to store data. Resizable heap-based collection. Dynamic sizing.
• Page 114 of the presentation.

Vectors (Capacity and Allocation)

• Vec::with_capacity used for allocating a vector with a desired capacity.
• Page 115 of the presentation.

Vectors

• Multiple ways to create vectors. Shows usage of vec! macro and some additional vector operations

• Page 116 of the presentation.

Vectors (Initializing, collect Method)

• Initializing vectors using the collect method. Iterators
• Page 118 of the presentation.

Vector Capacity

• Method for getting the storage capacity of a Vec<T>. Comparison with the method len().
• Page 119 of the presentation.

Vectors (Insertion, Removal)

• Methods for inserting and removing elements within the vector that shifts members.
• Page 120 of the presentation.

Vectors (Pop Method)

• Description of the pop() method which removes elements from the back of a vector
• Page 121 of the presentation.

Vectors

• Vector methods (e.g., reverse()) work on slices produced from vectors.

• Methods will return slices (&mut [&str])

• Page 122 of the presentation.

Building Vectors, Element By Element

• Describing how Vec handles resizing when needed to accommodate increased elements. The overall cost is linear, but constant per element since the underlying operations are constant
• Page 123 of the presentation.

Building Vectors, Element by Element

• Building a vector with Vec::with_capacity, speed improvement, and reduced calls to heap allocator.
• Page 124 of the presentation.

Vector Functions

• List of common essential functions available on a Vec<T>
• Page 125 of the presentation.

Vector Functions (Continued)

• List of additional vector functions.

• Page 126 of the presentation

Loops in Rust

• loop statement creates an infinite loop.
• Page 127 of the presentation.

Loop

• Example of using the loop statement.

• loop executes the block of code repeatedly until explicitly broken out of using the break keyword.

• Page 128 of the presentation.

Exit from Loops

• How to break out of a loop. The break keyword, which stops the loop and transfers control to the next expression after the loop (if any exist).
• Page 129 of the presentation.

Summary

• Page 130 of the presentation.

Test your knowledge of the fundamental concepts of Rust programming with this quiz. It covers variable declaration, types, shadowing, and block expressions. Perfect for beginners looking to solidify their understanding of Rust.