Programming

Last time we talked about binary, and one question on last night’s assignment asked:

01000001 01101110 01110011 01110111 01100101 01110010
00100000 01101001 01110011 00100000 00110100 00110010
00101110

Hm, we can translate these to numbers:

65 110 115 119 101 114 105 115 52 50 46

But we can also decode this message further with 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. For example, the letter A is the decimal number 65, B 66, C 67, 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.

Since ASCII only specified characters for most of the ones we need in English but not other languages,another standard called Unicode includes mappings for more characters.

In many programming languages, we actually need to also specific if a set of bits should be interpreted as raw numbers, or as characters under some standard.

Colors, too, are represented by numbers in computers. RGB is the standard most computers use, which indicates how much red, green, and blue are mixed together. For example, 72 73 33 for red, green, and blue will be a brownish color:

"24-bit color" on a computer, then, means that 24 bits total are being used to represent colors, with 8 bits per each color.

In any case, the message of the question translated to Answeris42.

And to recap the issue with Ariane 5’s launch, integer overflow led to a chain of events that ended in a tragic crash.

In the case of the Patriot defense system, imprecision in calculating missile speed also led to significant failure.

Now David will make a peanut butter and jelly sandwich based on a random submission from last night:

We’ll try this one more time:

Even though this "program" is many steps longer and seemingly more precise, there are still many opportunities for misinterpretation.

Legal contracts especially are long in order to try to avoid ambiguity.

We’ll have seminars that cover specific technical topics and office hours for one-on-one discussions about questions, with our team of teaching fellows.

Scratch is a simple graphical programming language, and perhaps the simplest program for it looks like this:

Learning Scratch in itself might not be too useful, but we will be able to talk about some programming ideas without having to worry too much about the smaller details.

We take a look at Oscartime remix again:

David will start with a new project:

Many of the pieces are visually self-explanatory. For example, the shape of conditions imply that we can place other pieces inside of them:

There are also events, where something happens and the program should respond. For example, these blocks start statements that are under them when their events occur:

For example, we can drag these two pieces together:

Let’s talk about a few topics to help us make our programs:

Let’s try this:

We can remove the purple block from inside the loop and put it under the green flag block:

We can solve this problem by having the program wait between playing the sound:

We’ll build this program with other pieces:
image::scratch_meow4.png[alt="Scratch meow", width=400]

In theory, if we did this over and over again, we should hear the sound 50% of the time. But computers aren’t truly random, since they can only do what they are instructed to. There’s probably some code that tells it how to "think" of a random number, which is difficult to do, since we want randomness in our security and cryptography programs. Patterns in encrypting a message, for example, might make it weaker and easier to exploit.

A physical device like a computer or phone can use other inputs, like the current time or the speed its accelerometer detects, to use as input for some algorithm that then produces some pseudorandom numbers.

Now we’ll build this program:

By the way, many of these examples will be at http://cdn.cs50.net/2016/mba/classes/1/src1/, and this one is called "pet the cat"!

Another example, "don’t pet the cat":

"counting sheep" is interesting:

There are ways to handle really big numbers by programming for them (for example, setting aside more bits for the number as we need them) but generally that doesn’t happen automatically in many programming languages.

The program "hi hi hi" has two sets of blocks running in parallel when the green flag is clicked:

One core in a CPU can actually only do one thing at a time, but they are so fast these days that they are switching constantly between working on tasks so we have the illusion of them doing two or more things at once. And most CPUs these days have multiple cores, so we can actually do multiple things at once (which is faster). But the software needs to written to be multithreaded, or able to support splitting tasks into multiple cores.

Let’s look at the program "events":

The blocks for our orange muppet look like this:

The blue muppet has just this set of blocks:

Now let’s look at "threads":

Now let’s look at "cough-0":

We can see that "cough-1" is a natural improvement:

With "cough-2", we begin to see a little abstraction:

We can add a feature where we tell our cough function how many times to actually cough, in "cough-3":

And our final version, "cough-4", is even fancier:

We look at a few final demos, "gwalker" and "Ivy’s Hardest Game remix", that are more complex but infer that events like arrow key presses help control movement and random numbers help place items on the screen in different places every time.

And these demos were probably built one component at a time, perhaps with items falling first, then different items each time, then different items in random positions each time.

So in Project 0, you’ll come up with some interactive program of your own. And together we build a quick program that has our cat walk back and forth across the screen.

Until next time!