--- author: Adam T. Carpenter, Carpenter Tutoring --- # Computational problem solving with _Rust_ ## The study of computer science ``` ~~~fsays Not just for computer scientists ~~~ ``` [practice of computing using python](https://www.pearson.com/en-us/subject-catalog/p/practice-of-computing-using-python-the/p200000003329/9780137524839) [rust book](https://doc.rust-lang.org/book/) --- # Why computer science? Computers are "more universally applicable than any other commodity in history." (Punch & Enbody) There is no other machine with as many diverse uses as the computer. A reprogrammable machine is a machine that works for _you_. ## Not just computer programming - theory of computation - efficiency - algorithms and data structures - parallelism - software engineering _Computer programming is a great way to begin exploring these fields_ --- # Difficulty in first-time programming It's like learning how to write poetry in a foreign language. You need: - fluency: the vocabulary and grammar to read and write the language - ability: the skill to rhyme, write in verse, _make poetry_ Learning to program has similar roadblocks. You need: - syntax and semantics: the structure of Rust as a language - problem solving: the skill to transform your problem into a solution --- # Good programs are essays Programming is writing how _you_ think a problem should be solved. A program is your thoughts! ## 1. Think before you program Writing a program should describe your thoughts well. Not just for computers, but for other human beings! You're going to read your program over and over again. Eventually you'll inevitably write programs in a group. Then others will need to read it too. ## 2. A program is a human-readable essay on problem solving (that also runs on a computer) --- # The promise A program, or an essay on problem-solving, has impact because it can be executed on a computer. Your problem-solving thoughts - are executable - are repeatable - are independent of you Programming is a leap forward in the way the printing press was hundreds of years ago. --- # Choosing a language The variety of languages is enormous, each one with a specific intended purpose. ## Why Rust? "performance, reliability, productivity" - useful types and memory guarantees - makes it easy to write concurrent programs - has a friendly compiler and helpful borrow checker - provides good documentation - offers great standard library and third-party libraries Thanks to middle school math, most folks have the prerequisite knowledge to understand variables, functions, and types. ## Why not C, Java, Python, etc.? Some of these languages force you to think about computer organization. Others may direct you into an object-oriented programming mindset. Still others promote dynamic type conversion or make it easy to dereference null values. The most important reason for using Rust is it helps prevent you from making mistakes, regardless of your skill level. --- # Is Rust the best language? If you don't already know you'll soon learn there is no "best language." All languages compromise on something; Each has its strengths and weaknesses. Rust is a good, _general-purpose_ programming language with _broad_ _applications_. Once you've gotten started, you'll be better equipped to explore other languages that may be better suited to solving your specific problems. --- # Computation and computers _Computation_ is the manipulation of data by humans or machines ...be that data numbers, letters, or other symbols. A _computer_ is something that does computation Note this does not specify _how_ the computation is accomplished. However, there are some things that every computer needs in order to do its job. - accept data as input - manipulate data (do computation on the input) - output data --- # The modern computer Many components drive the function of a typical home computer. ``` ~~~graph-easy --as boxart [Processor] -> [Memory] [Memory] -> [Disk] [Memory] -> [Input] [Memory] -> [Output] [Memory] -> [Network] ~~~ ``` Inputs can be mouse and keyboard, or touch interfaces. Outputs may be a video monitor or a printer. The network itself is a glorified input/output device, allowing for communication between and among groups of computers. --- # The origin of the modern computer _Computer_ used to be a job description for human beings! General-purpose, reprogrammable, electronic digital computers first appeared in the 20th century. The basis of every digital computer is an on-off switch. The technology behind these "switches" has evolved from mechanical relays to vacuum tubes to transistors. _Transistors_, the tiny electronic switches powering modern computers, are either on or off. Just like a light switch, when turned on, they allow electricity to flow. Using switches to power other switches, you can create circuits that represent logic. --- # Example: a three-pole light switch ``` ~~~graph-easy --as boxart [hall switch] .. off ..> [ceiling lamp] [den switch] - on -> [ceiling lamp] [hall switch] <-> [den switch] ~~~ ``` --- # Example: a three-pole light switch ``` ~~~graph-easy --as boxart [hall switch] - on -> [*ceiling lamp*] { border: bold; } [den switch] - on -> [*ceiling lamp*] { border: bold; } [hall switch] <-> [den switch] ~~~ ``` Note: this is actually an XNOR gate, but we'll talk more about logical operators later. --- # Example: a three-pole light switch ## Replace AC power with truth Off: false, 0, "no" On: true, 1, "yes" These are the building blocks of every digital computer in the world today. --- # Representing numbers > Bits and bytes of information, turning darkness to light. (_Bits and Bytes_, 1983) So how do we use billions of tiny transistors, on-off switches, or 0s and 1s into English essays, photographs, or 3D animated feature films? --- # Representing numbers Probably before grade school, you learned to count from 1 to 10 on your fingers. Just like you, the _decimal_ number system gets its name from the ten digits it has to work with. In mathematics, we typically count from 0 to 9 and then increment the next digit up and start counting over again at 10. The _decimal_ system is also called _base 10_ for this reason. ``` 735 = 7 hundreds + 3 tens + 5 ones ``` We could also write this as: ``` 735 = 7 * 10^2 + 2 * 10^1 + 5 * 10^0 ``` Lots of other popular counting systems exist. _Sexagesimal_ uses 60 digits (0..59). It is the basis for timekeeping and measuring angles. ## Binary numbers If we want to count with just two digits (0 and 1), we have to use a _base 2_ system called _binary_. ``` 101 = 1 * 2^2 + 0 * 2^1 + 1 * 2^0 ``` 101 in binary is equal to 5 in decimal. _Bits_ is shorthand for _binary digits_, or every digit in a binary number. --- # Binary data With binary way we can use computers to do numeric calculations on integers and fractions. There are some limitations however. ## Integers In mathematics, integers count upwards and downwards forever. But computers have limited space to organize binary numbers. For example, a 32-bit computer uses 32-bit _words_ to represent numbers. This only allows you to represent numbers as big as `2^32`, or a little more than 4 billion. ## Fractions (Real numbers) Representing real numbers in binary is hard. No matter how we do it, it's always going to be an approximation of the mathematically understood truth. ```rust fn main() { println!("{}", 1.1 + 2.2); } ``` --- # Binary data There are some units worth knowing when working with binary data. You already know about _bits_, or _binary digits_. This is the smallest unit of measure, as a _bit_ is just a 0 or a 1. ## Bytes _Bytes_ are chunks of 8 bits. Storage, for example, is typically calculated in _bytes_ e.g., 8GB of RAM is about 8 billion _bytes_. ## Words Computer _words_ are made up of _bytes_. A 32-bit word is made up of 4 bytes (`32 = 4 * 8`). --- # Representing text Since everything in a computer is stored as binary numbers, we need a way of mapping those numbers into letters so we can work with text. ## Characters Characters are letters, printed digits, punctuation, whitespace, and unprintable controls used to write human-readable text on a computer. ## Printable characters ``` a, b, c 1, 2, 3 . " ; ) ``` ## Unprintable characters - newline (`\n`) - tab (`\t`) - carriage return (`\r`) ## Standards The first standard set, ASCII, was designed in 1963. Every character had an associated number: ```bash man -P "head -25" ascii ``` --- # Representing text ## Unicode Today we use Unicode, or an implementation of Unicode called UTF-8 for almost all web pages and modern programming languages. It is a superset of ASCII with support for thousands of multilingual characters, mathematical symbols, and shapes. UTF-8 is the default for Rust and what we'll be using. ```rust fn main() { println!("Parlez-vous français?"); } ``` --- # Representing images and sound If you look closely you can see the screen you're looking at now is made up of many tiny squares. When combined and viewed at a distance, all of these picture elements make up an image. These picture elements, or _pixels_, consist of location coordinates and color. We can use different color _schemes_ and image _resolutions_ to create, store, and display different images. Sound on the other hand, is normally described as a wave. This wave equates to levels of air pressure our ears can detect to register that sound. We can approximate a wave (take a sample) with a series of heights at given intervals. To record sound, we can use microphones and digital sampling to build a wave approximation in the computer. To play sound back, we reproduce the wave by playing the sample height at the rate it was recorded. This wave is pushed out through the speakers and registers as the same sound we heard when we recorded it before.