PC Labs in the Engineering Center
CR 235	CR 239
CR 244	CR 252 (24 hours)

It is best to start a lab exercise during your assigned recitation period. If you run into any immediate problems, one of the instructors will be able to help. However, some of you might have missed your assigned time during the first week. If so, then you'll need to work on your own home machine or go to one of the PC labs on your own to get started.

Required Completion Date

This exercise must be completed as soon as possible after your first recitation. Otherwise you won't have time to complete the first homework (which is due the next week).

Set up Your University Account and Identikey

• If you are working in the university PC labs, you must first have a university account and identikey password. If you've already set these up, go to the next step. Otherwise, you can try to activate your identikey at https://cuidm.colorado.edu If that won't work, then y'll need to call Information Technology Services (303-735-4357) for help.

• Now, whenever you use a university PC, your first task is to login through the Identikey system. Do this by pressing the return key to get the login screen, then type your login name and IdentiKey password. This will take you to the Windows work screen.

Start the CS1300 Software

• At the beginning of each lab exercise, you'll need to prepare the PC to use the CS1300 software. There are several ways to do this, depending on your location:

  On Engineering Center PCs:

  Click Department Applications. Then choose the cs1300 option. A black rectangular window will appear on the screen. (See "Using a CD" below if your engineering machine does not have the cs1300 option. Thanks!)

  At Home:

  You can download the cs1300 software from www.cs.colorado.edu/~main/cs1300/cs1300-setup.msi. Download the file to your desktop and double click on the cs1300-setup.msi. After the installation finishes, you may delete cs1300-setup.msi. You will have a cs1300 icon on your desktop. When you click the icon, the black rectangular window appears on the screen.

  Using a CD:

  To use a cs1300 CD on any Windows machine, put the CD in the drive. A small Autoplay window will open up. Make a note of the CD drive letter (such as E:), and then click the red close X in the upper right corner of the window.

  To use the software from the drive, follow these instructions:

  1. Go to the Start menu, and in the text bar at the bottom, type cmd and then press the Enter key.
  2. A black command line window will open up. In this window, type this command, where the E: is the letter of your CD drive. Notice that you type E: twice in the command (once at the start and once at the end!)

     E:\gocs E:

  Michael will have some of these CDs at the start of the semester, but if you don't get one, you can make it yourself by following the instructions in the next item.

  Making a CD or Thumbdrive with the CS1300 Software:

  The cs1300 software can also be put on a CD or a thumbdrive to use on any Windows machine. If you are making this CD or thumbdrive yourself, then you should first go to a machine that already has the cs1300 software installed. From that machine, copy all of the files from here to your drive (not in a subfolder, but just right onto the drive):

  C:\Program Files\Colorado\cs1300\

Create a Working Directory

At the end of the installation step, you should have a black window open where you will carry out all your work. The prompt message in the black window should list your Documents folder or Home folder as the current working directory (such as C:\Users\michael\Documents or C:\Users\michael). If it does not list this, then please ask your TA how to change to your Documents folder (I do it with the command "cd /Users/main/Documents" because my identikey name is main.)

Within that folder, you will create a separate subfolder for today's work. I called my subfolder lab1, and I created it and moved into it with these commands typed in the black window:
  mkdir lab1
  cd lab1

Always put your work in a subfolder (rather than at the top of the Documents folder). It's also useful to have a Windows Explorer window open in this subfolder, so do this now by these steps: From the Start menu, choose Computer. Then click on the drive that you are using (usually C:), click on Users, click on your name, and click on your subdirectory.

Copying and Listing Files

Now you'll download a file into your working directory. Open a browser (the instructions here are for the Firefox browser). Go to www.cs.colorado.edu/~main/cs1300/lab/. From here, you'll need to download the file called heatwave.cxx (right click and choose Save Link As). After the file downloads, please right click on the file in the Downloads window and choose Open Containing Folder. Then drag and drop the file from there into your working directory. Ask your TA if you are uncertain how to do this on your machine. You can then minimize this window for now, and open it again when needed.

• The file that you downloaded is a C++ program. The last part of the file's name, cxx, indicates that the file is a C++ program. The program, heatwave.cxx, computes some information about heating a house, but the real purpose of the program is to demonstrate what a program looks like and how to run a program on a machine.

  Later, during your reading assignment, you can look at how this program was written. But for now you will simply see how to run a program such as this one. The first step in running a program is to run the C++ compiler. A compiler does the task of translating from a programming language (such as C++) to the low level instructions that a computer actually runs. Our compiler is Version 2.7 of the Gnu C++ compiler. You can start the compiler from the black command window by typing this command:

      bgi++ -Wall -g heatwave.cxx -o heatwave.exe
  

  In your compilation command, the -Wall option instructs the compiler to list all warning messages. These warning messages usually indicate programming errors, and we'll forbid most warning messages in your programs. The -g option puts extra debugging information into your program. At the end of the compilation line, the arguments -o heatwave indicate that the compiler should put its result (the "object code") in a file called heatwave.exe. If you don't specify a location for the object code, then the compiler places its result in a file named a.exe, which is not a particularly useful name.

  Anyway, compile the heatwave program now (as shown above), and then list your files by typing the command dir. You should see something like these files:

      08/11/2004  10:23 AM             2,160 heatwave.cxx
      01/08/2009  12:27 PM           550,345 heatwave.exe
  

Running a Program

The important thing now is that heatwave.exe is an executable file, meaning that you can run it by typing its name at the black command window. Do this now. Type heatwave, press return, and then interact with the program.

Using GNU emacs

In order to modify any of your files, you'll need to use one of the text editors. Some of your have probably used a text editor before, such as edit, vi, pico, or even emacs. In the past, we have let students use whichever editor they wanted. But this semester I'd like everyone to use an editor that has a good degree of integration with a compiler and other tools. The editor is called GNU emacs (yes, the G in GNU is pronounced!).

You'll first use emacs to edit heatwave.cxx. In order to start emacs and edit the heatwave.cxx file, give this command from the command line:

emacs heatwave.cxx

The editor will open, and display the current contents of your heatwave.cxx file. Spend one minute using the terminal's arrow keys to browse through the file. You can also use the keys to page down or page up. Each line of the file is part of a small C++ program. The lines near the top are comments indicating what the program does. One of these comments says that the program is an exercise for Irving Forbush. Use the backspace key to erase Irving's name and put your name instead.

After you make this change, you may write out the new heatwave.cxx file, by typing Ctrl-x followed by Ctrl-s, and answering y to the prompt at the bottom of the screen.

Six Pieces of C++

The next step of this lab is to browse through heatwave.cxx a bit. Using emacs, open the file heatwave.cxx. You might notice that emacs recognized the program as a C++ program, and put the characters (C++) in the status line at the bottom. Move through the program and find the following aspects:

1. Comments in C++ are indicated by two slashes in a row. The entire line, after the // is a comment.

2. The program has two include directives that include two C++ libraries:

   #include <iostream> // Provides cin, cout
#include <cstdlib> // Provides EXIT_SUCCESS

   These directive will appear in most every C++ program. The library iostream provides standard input and output functions and devices such as the standard input. The library cstdlib provides several other standard items such as a constant named EXIT_SUCCESS that our program uses.

3. After the two include directives, the program declares a double number named PI. But PI is no ordinary variable; it is a constant variable, declared as shown here:

   const double PI = 3.14159;

   A constant declaration, such as this, is a new feature of C and C++. They are like ordinary variable declarations that are given an initial value, but because they are declared as a const, the compiler will prevent you from writing any statements that change the value of this variable. In this class, our programming style requires the names of all constants to be written in capital letters, allowing constants to be easily spotted.

4. Search through the code and find the heading of the main program, which begins with the words "int main". The word int indicates that the main program computes an integer value and returns this value to the Windows operating system. This integer can be used to tell the operating system whether the program was successful or not. For our compilers, a main program returns the number 0 to indicate successful termination. For our bgi++ compiler, this "successful return value" is defined in cstdlib as a constant called EXIT_SUCCESS. Can you find the return statement in heatwave's main program, which indicates successful termination. (If you want to indicate an unsuccessful program, you can return EXIT_FAILURE instead).

5. Some output is quite simple in C++. A basic output statement looks like this:

   cout << "How big is your tree?" << endl;

   The name cout is the "console output device"--the screen. The operator << is the output operator. So this statement sends the string "How big is your tree?" to the console output device, and then the special object, endl, is sent to the console output device. The object endl is an end-of-line, and it also serves to "flush" the output (meaning that the output will be written then and there, rather than waiting for some output buffer to fill up).

6. Some input is also quite simple in C++. A basic input statement looks like this:

   cin >> radius;

   The name cin is the "console input device"--the keyboard. The operator >> is the input operator. So this statement inputs a real number into the variable radius. You'll learn a lot more about input/output in other labs, but this will do for now.

Emacs Indenting

When emacs knows that a file is a C++ program, it can help you to make sensible indentation. To demonstrate this ability, go down into the body of heatwave.cxx, and mess up the indentation on a few lines. Get rid of some spaces or add some extra spaces at the start of a line. Just mess it up some way. Then press the Esc key followed by p. The letter p stands for "pretty-print," and the command will nicely indent your entire program. This command is one of the things that I set up in your emacs initialization file.

Here are the indentation items that I have set up in the initialization file:

• The TAB key: When you press TAB, emacs will attempt to correctly indent the current line.

• The RETURN key: When you press the RETURN key, emacs will indent the current line, insert a blank line, and move the cursor to the right spot to start typing. If the first character of the newline is a bracket, then its indentation will be corrected after you type the bracket. If you find that you need to turn off the annoying behavior of the RETURN key, then go into your .emacs file and put three semi-colons at the front of the lines that look like this:

  (local-set-key [13] 'tab-return-tab)

• The Pretty-Printer: When you press the Esc key and then press p, emacs will nicely indent the entire file.

Now that you know about pretty-printing, you can move to the next step.

Compiling from within Emacs

At the moment you are looking at heatwave.cxx from within emacs. You can actually compile heatwave.cxx without stopping the editor. To compile from within the editor, press the escape key once, press x, type the word "compile", and press return. The "mini-window" at the bottom of the screen will change to this message:

Compile command: make -k

Use the backspace key to erase "make -k", and instead type your usual compilation command, so that the mini-window looks like this:

Compile command: bgi++ -Wall -g heatwave.cxx -o heatwave.exe

Then press return. When you press return, the screen will split into two pieces. The top piece is still your heatwave program. The bottom piece is a new window that will contain any error messages from the compilation. During the compilation, there will also be a message near the bottom of the screen indicating "Compilation: run Compiling". When the compilation finishes, the message changes to "Compilation: exit[0]". If there were no compilation errors, you can get rid of the compile window by giving the "one window" command (Ctrl-x followed by typing the digit 1).

Finding Compilation Errors

Compiling from within emacs is a big help when there are compilation errors. For example, let's put a compilation error into the heatwave.cxx file. Go down to the input line "cin >> height;" and delete the semicolon at the end of the line. This is certainly an error! Move the cursor away from this error before you proceed to the next paragraph.

Now, type the compile command again (ESCAPE x compile RETURN). Notice that when you press return, the miniwindow still remembers your compilation command, so just press return once more to get the compilation underway. When the new compilation starts, emacs will ask whether you want to save the changes to heatwave.cxx before compiling. You should answer y (otherwise the compilation would compile the old version of heatwave.cxx, which did not have an error). The compilation will find your syntax error pretty quickly, and display some error message such as "heatwave.cxx:42: parse error before `<'".

With the error message in the compilation window, you can ask emacs to move the cursor to the location of the error. The emacs "find error" command is Ctrl-x followed by the "backquote" key. (The backquote key is the single quote mark that seems to go backward.) Give this command now. Emacs will move the error message to the top of the compilation window, and move the cursor in the program to line 42. Line 42 is actually one line after the real error. (Remember that usually you must move backward from the error line to find the location of the actual syntax error.) Go ahead and fix this syntax error now, and save the file before moving to the next step.

• The heatwave program prints its answer in days. In order to show you how to modify a program, we'll add weeks to the answer. At this point you still don't need to understand how the program is working--it is enough to just understand how to modify a program in the way that these steps describe.

  For the first modification, move to the top part of the program and find the lines shown here:

      double height;            // Height of a tree in feet
      double radius;            // Radius of a tree in feet
      double requirement;       // Cubic feet of wood to heat house for a day
      double volume;            // Volume of the tree in cubic feet
      double days;              // Number of days that tree will heat house
  

  These lines tell the program to use memory locations to keep track of various computational values. We'll tell the program to keep track of one more value, the approximate number of weeks that the tree will heat the house. To do this move the cursor to the end of these lines--somewhere after the words " will heat house". You can move the cursor here with the arrow keys, or by moving the mouse to the location and clicking the left button. Once the cursor is here, press return, which will open up a new line. On the new line you should type:

  int weeks;                // Number of whole weeks that tree will heat house
  

  Try to align your new line with the rest of the program, aligning front of each line, and aligning the slashes (which indicate the start of a comment that is meant to be read by a person).

• For the second modification, find these lines:

      // Computations
      volume = height * PI * radius * radius;
      days = volume / requirement;
  
      // Output days
      cout << "That tree will heat a house for " << days << " days." << endl;
  

  Add the two new lines shown here:

      // Computations
      volume = height * PI * radius * radius;
      days = volume / requirement;
      weeks = (int) days / 7;
  
      // Output days
      cout << "That tree will heat a house for " << days << " days." << endl;
      cout << "Which is " << weeks << " whole weeks." << endl;
  

  The first new line calculates the number of whole weeks by dividing the days by 7. The second new line prints this number of whole weeks.

  Now save and recompile the program (from within emacs). After recompilation, you can click on your black window and run the program by typing its name. You might be surprised to see that the number of whole weeks was rounded down. This rounding down to a whole integer occurs whenever a value is assigned to an integer variable.

Printing a Program

You can print a program from within emacs (from the Tools menu), but many of the Engineering PCs aren't correctly set up to do this. An alternative way to print a program such as heatwave.cxx is to give this command from the black command window:

notepad heatwave.cxx

This will open the notepad program with heatwave.cxx, and you can choose the print option from the File menu. Don't edit your program within notepad, though, because it's not set up to provide much help such as pretty-printing and compiling and debugging.

More About Emacs

• When you are satisfied that the program is running correctly, shut down emacs by pressing its close X in the top right corner. (Or by pressing Ctrl-x followed by Ctrl-c.)

• As the semester progresses, you'll learn a lot more about emacs. For example, you can change the definitions of various keys to match your own preferences for editing operations. You can invoke a debugger from within emacs. For now however, a summary of basic editing commands should be sufficient, available at http://www.cs.colorado.edu/~main/cs1300/lab/emacs.html , and a handy pocket reference guide at. http://www.cs.colorado.edu/~main/cs1300/lab/refcard.html

  Later you might find it useful to also browse the emacs online manual from http://www.cs.utah.edu/csinfo/texinfo/emacs19/emacs_toc.html .

• On the university computers, your should copy your heatwave.cxx from the PC's hard drive to a backup device before you leave. One option is to use a memory stick as your backup. A second possibility is to send your current work to yourself by e-mail. You should send only the .cxx file (not the .exe file).