---
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 data

> 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 data

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_

---

# Binary data