Why do we have Data and Variables?

Computer data is the reason programs exist.  Data is the numbers, text, dates, and currency that we process to accomplish work.  Imagine a spreadsheet without the numbers or a word processor without text in the document. For the purposes of programming, we deal with data in ways that let us know what kind of information we are working with.  For example, a set of data might be two numbers that are added together to create a sum. 

Think of math.  An equation might be represented as follows:

A + B = C

In this example, A, B, and C are variables.  By substituting real numbers; you could solve the equation:

A=2, B=3

2 + 3 = 5

C=5

Variables in programs are used in a similar fashion.  They often represent data that is to be input to the program or store data generated by the program.  

Computer Data

Before we go much further, consider how data and ultimately, information is stored in a computer.

The basic unit of data in a computer is a bit.  A bit is a one or zero.  A bit can be used to represent two things: on or off, yes or no, true or false, and so on.  This is a very limited set of options.

Most computer systems depend on the byte for storing data.  A byte is eight bits, which can be used to represent 256 different things (you get 256 by taking 2 to the eighth power: 2⁸).  

Now we can encode a lot of things:

We often combine groups of bytes for various data storage situations:

Data is stored collectively in files which can be as small as few bytes or very, very large (even hundreds of megabytes).   

Data Types

Depending on the programming environment, there are various data types to support various applications.  At a minimum, data types include numbers and strings; however, most programming environments use many data types, including dates, currency, and various formats for numbers including integers and whole numbers.

There are some important things to notice about data types:

1. The type of data that is represented (string, number, date, etc.).

2. The amount of space, in bytes, required for storing a variable in memory (disk or RAM). ]

3. The range for the data type; for example, integers in Visual Basic range from -32,768 to 32,767.

Generally speaking, data types include:

 Depending on the programming language, the kinds of data types that can be used will vary.  

The following table summarizes data types found in Visual Basic (v. 6):

Variables

Variables are temporary holders of data in computer programs.  For example:

In a computer program, "i" could be set to 10 and "mystring" set to "A dog is in the park."  Typically you declare the name of the variable and its type prior to using it. 

During program execution, variable values may change numerous times.

Some things you should consider in creating variables:

Creating Variables in Programs

In most programming environments, the programmer defines or declares  variables when building an application.

For example, in Visual Basic, a variable is created as follows:

Dim lastname as string

And in C, an  integer variable is created as follows:

Int x;

And in JavaScript:

Var lastname

Variables are created prior to when they are used.  For example:

Dim X,Y,Z as integer  
X = 2
Y = 3
Z = X + Y

In some programming environments, variables can be implicitly created.  For example, in Visual Basic, you can create a variable simply by using it.  Unfortunately, the variable is usually defined a variant, which can handle any kind of data (numbers or text) and requires more memory than if you had simply declared the variable as an integer or string.

Variable Scoping

Variables are typically used within program procedures to accomplish some task.  In some cases, variables are shared between procedures, even throughout an application.  

Variable scoping assumes you know something about how programs are organized into subroutines or functions.  We will talk more about this later.

In many programs, if a variable is declared within a procedure, it is localized to that procedure.  When the procedure is done executing, the variable is forgotten.  However, if the variable is declared outside of a particular procedure, it can be used in many procedures.  This is useful in situations where you need to share data between different procedures in a program.  Consider the following example:

Dim age as integer   'age is a variable that can be used anyhere

Sub aprocedure()

  Dim userage as integer  'userage is a local variable

  userage = 20       'userage is now equal to 20

  userage + 10 = age    'age is now equal to 30 

End sub

    'age is available to other procedures

The following illustration shows the relationship of variables (scoping) at the program, module, and routine levels.  Note that variable names used in routines can be reused in other routines, even as different data types.

Constants

A constant is a special kind of variable with a preset value that can be used throughout an application.  The advantage of a constant is that it is set in one place in the program, usually by the program itself.

System-Defined Constants

System-defined constants are often used to simplify the "remembering" of values that are used .  For example, the constant vbBlue in Visual Basic is the same as "&H00FF0000&", a hexadecimal number.

User-Defined Constants

The programmer can also declare constants for values that will be used over and over.  For example, Const myaddr as string = "111 Elm Str." results in storing the address in the variable "myaddr."

Arrays

In some situations, you may want to have a number of variables that represent a similar kind of data.  For example, you may need to collect several number of names and addresses.  You could create a variable for each name and address: name1, address1, name2, address2, name3, address3, and so forth.  But this can be difficult to keep track of in the program.  Also, you may not know how many variables to create.  And remember each variable takes up space whether you use it or not.  This is where arrays come in.

Imagine a "set of names."   The set called "names" could have several  entries, each of which could be numerically referenced.  For example:

Name(1) ="John"

Name(2)="Tommy"

Name(3)="Cindy"

This is an example of a one-dimensional array.  The array can be defined with a fixed set of potential entries.

Arrays can be multidimensional.  For example a 3 by 5 array called "codes" could be created and values applied:

If you called on codes(2,4)  you would get the value: 67 (second row, fourth item).

Some things to remember about arrays:

User Defined Structures

Structures are often referred as:

Structures are formed by combining other variables (strings, numbers, etc.) and even previously defined structures.

In some languages, the "type" is used:

type employee

name as string

empnumber as long

address as string

end type

In languages such as C, the "struct" keyword is used.

In this example, note that the employee data is made up of other data.

Stacks, Queues, and Linked Lists

Stacks are "lists" of data that operate on a last-in, first-out (LIFO) basis.  In other words, the last data put in, is the first data to be pulled out.  Stacks are often used by lower level languages to handle function calls and managing events (i.e., system interrupts).

Queues are also lists that operate on a first-in, first-out (FIFO) basis.  Things of a queue as a line to enter a theater.  The first person there, is the first to get seat.

Linked lists consist of lists in which each element of the list points to the next element.  This is efficient for managing the list because you merely need to check the pointers to and from the element to be added or deleted and adjust them.

[ Home ] [ Up ] [ Computer Architecture ] [ Database Bootcamp ] [ Visual BasicS ] [ Web Basics ] [ Web Multimedia ] [ Web Programming ] [ Advanced Web Topics ] [ Developing Web Sites ] [ XML Technology ] [ Web Glossary ]

Copyright © 1999 - 2005 
ThePlace - Written and Sponsored by Dave Hillman