A variable is defined as: an element, feature, or factor that is liable to vary or change.

On the computer, a variable is memory location containing binary data. Often times, additional rules of interpretation will be applied to the binary data, pertaining to a certain format (integer data, floating point data, memory address data)

In C, variables need to be declared and ideally initialized before we use them. All variables need to be identified with some data format (otherwise known as a data type).

As talked about in class, and on the dtr0 project, there are a number of possible data types to choose from. For dtr0, we will be focusing on the integer types:

• char
• short int
• int
• long int
• long long int

Each of these can store whole numbers, of differing ranges. The idea is to use the data type that “best fits” the scenario you are using it for.

ie, if you know you will ONLY need to use the values 0-100, while ALL of these integer types can accommodate such a request, there's one which can accommodate it while wasting the least amount of storage.

There is an additional qualifier we can associate with each of the integer types, and that is the indication of whether or not we wish to interact with negative numbers. The two qualifiers are:

• signed - allow positive AND negative numbers
• unsigned - no negative numbers at all

If you omit the signedness qualifier, it will likely default to a signed type.

To declare a short integer type named number with unsigned qualities:

unsigned short int number;

It is good programming practice to be as specific as possible. As such, when we declare variables, it is also a good idea to then initialize them to a known starting value (don't assume!). Here, we will initialize number to 0:

number  = 0;

We can combine both of these steps into one:

unsigned short int number  = 0;

The computer is a binary device. That means it stores and transacts all its data in base 2, where there are only 2 counting bits: 0 and 1.

Think of this as a light switch, which can be either turned off, or turned on. That's it.

The computer will group a number of these bits together when it stores, retrieves, or manipulates information. The common unit of transaction is the byte, which in modern days has been set to eight bits.

The computer can access data in units of bytes (typically in some power of two), and the amount of bytes (and therefore bits) we have within that collection of data denotes the number of different combinations which can be represented (one at a time).

For example, take a single bit. That “light switch”. How many possible combinations can exist with one light switch?

Two, right? It can either be ON, or it can be OFF. Nothing else.

We can use a mathematical expression to aid us in determining the number of possibilities, based on how many bits are present.

It is: 2^x=y

Where x is the number of bits, and y is the number of possibilities.

If there are eight bits in a byte, a byte can store any one of 256 unique possibilities (but of course, it can only be ONE of those possibilities at any given time).

If we had two bytes, we would have sixteen total bits. How many total possibilities can sixteen bits represent?

While the computer is a binary device, when interacting with the computer we will often use base 16 (hexadecimal), as a convenient short hand for interacting with the computer's information.

This is because, like 2, 16 is a power of two, so there are certain conveniences leveraged.

Mainly, as it takes four binary bits to represent sixteen unique possibilities, one hexadecimal counting symbol reflects four binary bits. Hexadecimal values will be much shorter than their binary counterparts, while both storing the same information, and not needing any complicated conversion process.

Take the following table: