Day 0

On the way here, the hallway next to the classroom actually has source code framed on the wall, along with floppy disks. The ones on the wall come with warnings that they have viruses, software that does bad stuff, and that they should not be put into anything.

We got everyone a floppy disk from eBay (they’re really hard to find these days), so we can physically see some technology, even if today’s version of a floppy disk has evolved to be faster and smaller.

Sliding back the metal cover, we see that the actual "floppy" disk is inside a hard plastic shell.

Data is stored on the disk, which means that there are magnetic particles on the circular piece of material used to represent information. The polarity of each of these particles can be used to represent values. For example, a particle pointing north could be interpreted as a 0, and a particle pointing south might be a 1.

Let’s snap the plastic shell in half, and take out the actual disk. Back in the day, something like that probably stored 1.44 megabytes, or 1.44 million bytes.

Some hardware today, such as hard drives, are functionally equivalent to these floppy disks, with the exception that they’re physically hard and thus more durable.

Let’s take a closer look with this video. Electrical signals from a computer’s memory is translated into voltage fluctuations, which control the spinning disks in a hard drive, where other signals control a read/write head that actually changes the data on a disk.

Hard drives have more capacity than a floppy disk not only because they are harder and can fit things more densely, but because they are made up of multiple disks layered together.

The second part of the video visually shows how the read/write head has a magnet, which is controlled by electrical signals, that change the polarity of magnetic particles on a disk. Lots of these particles together, each of which represent a single bit, can then be used to make up a file.

Realize that this might all be unfamiliar, so there are no dumb questions or dumb answers in this class. In fact, we want to practice reasoning through problems to solve them, even if we have limited information, as that’s what people once did to solve these problems the first time around.

Computers still use 0s and 1s, or binary digits (bits). Humans normally use 10 digits, 0-9, to count. It turns out that decimal is quite similar to binary, or any other mode of counting.

Let’s take a look at 123, which we would normally read as "a hundred and twenty-three." Well, each number is in a column, or a place, with the 1s place on the right, the 10s place in the middle, and the 100s place on the left. So we have 1 times 100, 2 times 10, and 3 times 1, for a hundred and twenty-three altogether.

We can extend that to binary, where the columns will represent, from right to left, 1s, 2s, and 4s. So the places are powers of 2, where the rightmost column is 2^0, the middle is 2^1, and the right is 2^2. In the previous example with decimal, the 1s place was 10^0, the 10s place was 10^1, and the 100s place was 10^2.

So we can represent the number 1 as 001 in binary, 2 as 010 in binary, 3 as 011, and 4 as 100. Notice that we might need to change more than one digit sometimes, as we do when counting from, say, 99 to 100 in decimal.

To get 8, we’d need another digit, since with three bits 111 is equivalent to 7. Adding 1 to that, we’d get 1000, which has four bits.

Remember that YouTube was using a 32-bit number for their counter, which meant that they had 32 places, and eventually when all those bits counted up to 1s, all of them were flipped to 0s, as we would when going from 7 to 8, but their software only had 32 bits, so when that happened it looked like the count was actually just 0. (We’re simplifying here a bit, because the leftmost bit is usually used to keep track of the sign of the number, whether it’s positive or negative, so there might have actually been only 31 bits. And once the 32nd bit was incremented to a 1, the number as a whole was interpreted to be negative. Even that’s a simplification, as there’s an entire system for representing negative numbers called Two’s complement.

Let’s demonstrate this with a row of lightbulbs, labelling them like so:

Each of these circles are lightbulbs, which in turn represent bits. There are 8 total, and the total we can count up to is now 255.

To get the number 15, we’d turn on these lightbulbs:

To get the number 50, we’d do this:

The lightbulbs are actually called Philips Hue bulbs. They can change colors and respond to an API, application programming interface, which means that software has been written to allow them to take patterns of 0s and 1s and change color and brightness.

So far we’ve represented numbers, but we also know that computers can represent letters of the alphabet. Some years ago the world decided on a standard mapping of numbers to letters, called ASCII.

This website shows you the mappings of all 256 values that an 8-bit piece of data can be. In particular, note that the letter A is the decimal number 65, B 66, C 77, and so on. And lowercase letters are another set of numbers. Numbers, too, that you type, would be represented as different numbers according to the table.

To send the message HI, you’d send two numbers, 72 and then 73. Each number would be represented by 8 bits, for a total of 16 bits to be sent.

Additional symbols, like letters with accent marks, Asian languages, or even emoji, require a more sophisticated standard called Unicode, which uses additional bits per character to represent many more characters.

So now we can move on to solving problems a slightly higher level, knowing that humans and computers can share the same information, just in different formats. Let us also take for granted that images, sounds, and videos, too, are represented somehow by 0s and 1s.

Now that we can share data with computers, we can solve problems.

Let’s take a phone book, with, say, 1000 pages. And say that one of the pages contain the name Mike Smith.

We could open the book and flip from the beginning, one page at a time, until we reached Mike Smith. And this algorithm would be correct, since we’d eventually reach his name. But this isn’t a particular efficient solution.

We could go twice as fast by flipping two pages at a time, but this algorithm would no longer be correct since we might skip Mike Smith if we got unlucky.

Another way is to flip through the book one chunk at a time, skipping by the letter until we reached S.

But let’s do something simple, like opening the book to the middle. We’ll see that we’re in the Ms, which means that Mike Smith must be in the second half of the phone book, as S comes after M. So we can tear this problem in half, since we know we can get rid of the first half. We flip to the middle of what we have left, see that we’re in the Ts, and keep just the left half since S comes before T. And we’ll repeat this until we have one page, hopefully with Mike Smith’s name on it.

We can plot the relationship between the size of the problem and the time it takes to solve in this graph:

But we also have to assume that the data is sorted ahead of time. Otherwise, we can’t throw away half of the problem, and have to revert to our first idea of looking at one item at a time.

The size of memory given to a piece of data in a database, too, is independent of standards like ASCII or Unicode. For example, the counter in YouTube was originally a number of size 32 bits, but has probably since been increased to a 64-bit number.

Also, it turns out that the story about the view counter on YouTube was actually fake, but we can pretend it was true, for learning’s sake …​

Let’s use pseudocode, something English-like, to explain our algorithm:

We can cut some corners here. In step 3, for example, we say "look at names," but how or what isn’t exactly specified, since we really mean something like "look at all the last names, in both columns on the page." In fact, step 3 could be a function, or procedure, in a program, that we use to complete part of a task.

Step 4 has a condition, which mean that step 5 will only happen if step 4 is true. We indent to make this extra clear. And lines like step 5 or steps 1-3 that do something are called statements or instructions.

Step 6 is another condition, like another fork in the road, that will cause other things to happen if it’s true.

Step 8 is somewhat interesting, since it creates a loop, or cycle, that brings us back to step 3. And it seems like we’ll continue doing this, until we get to that last condition in step 12.

The terminal condition in step 12, known as a base case, is the case where we can end our loop since we have done everything we could. In this case, it’s when Mike Smith is not in the phone book, and we have no more pages to look at. (Notice that we could end our loop if we find Mike Smith before we went through the entire phone book, but this depends on the condition of finding him. In contrast, the base case will keep our loop from continuing forever for every case, as eventually we will have looked at all the pages and have nothing else to do.)

The final else in step 12 is technically unnecessary, but we choose to include it for completeness and clarity.

We followed this algorithm, and eventually 2 people remained. One had the number of 18, and one had 32, making for a total of 50 (by happy coincidence). But while we did this, David counted everyone in the room one at a time, and got a total of 90. So we found our first bug, but in theory we should have counted ourselves much more quickly than one at a time. If 90 more people came in the room, it might take David twice as long, but with this algorithm, we’d only take one more step to count twice as many people.

Don’t forget to do Assignment 0.