UCR CS Grad Student Tech Orientation 2003

Note: Time markers are meant as a general guideline for how far the average incoming graduate should be, but experience levels here are expected to be wildly varied. Feel free to work faster if you know this material, or spend more time working on things that you haven't seen before, but try to help others that have less experience if you are bored. As an academic, one of your priorities is education: begin with those around you. (If nobody needs help, and you know all of this already, go learn Python or Ruby. If you already know those, figure out a way to make Perl readable.)

Thursday

1 pm

Debugger

One of your major duties as a TA will be to try to get students to use the debugger. Under Linux, the standard debugger is gdb. To compile C or C++ programs with debugging information, add the "-g" flag to your compilation options. (Thus, the preferred compilation options to write clean, ANSI standard, debuggable code are "-W -Wall -Werror -pedantic -g").

For this hour, practice using the debugger.

If you have never used a debugger before, please skim through our standard introduction to gdb, which can be found here.
If you have some experience using the debugger, try to debug this (more challenging) program.
If you aren't interested in the above, or you finish it quickly, please try your hand at creating buggy programs that are hard to debug without the debugger. We are always trying to get undergrads to understand the usefulness of the debugger, so an archive of problems like this is a very handy thing to have for our Software Engineering courses.

2pm

Grading

We will be covering usage of our home-grown auto-grader framework. The grader is still in "Beta", so if there are features that don't work, things you feel are missing, or you find anything to be terribly confusing, please send email to Titus (titus@cs.ucr.edu) to have your issues addressed.

We will be grading the Towers of Hanoi assignments that were submitted from yesterday. You can download the archive of these assignments here. Unzip this using the command

tar xfz graderproject.tgz

We will demonstrate how to use the grader at around 2pm. When we are finished, please try to "grade" those assignments according to the following rubric:

15 points - Compiles cleanly (no warnings, with warnings enabled: -W -Wall -Werror -pedantic). 5 points if it compiles, but not cleanly.
20 points each - We have 3 test cases in the OrientationProject directory: 2 from yesterday and 1 that tests the error checking conditions. For each test case that is passed, 20 points. For each test case that is "close", 5 points. (You may determine what you feel is "close").
25 points - Style. Unfortunately, most style issues cannot be automatically checked. Only one can: line wraps. You can see the list of style guidelines that is prevalent in the lower-division curriculum here.

3pm

Gnumeric

Part of our drive toward total archival of student information is that we store grades in a standard fashion. One of the nice things about the auto-grader system is that it allows us to do just that in conjunction with Gnumeric, the powerful GNU spreadsheet tool. Experiment with exporting information into Gnumeric from the grader. You will certainly want to change the "Assignment Name" field under "Options->Configure" within the grader.

Wednesday

1 pm

Intro to Linux / RedHat / The CS Cluster

Nautilus - Like Windows Explorer, only more functional. Some people use Nautilus extensively, some purists hate it with a passion. You should experiment with it for a few minutes at least before you make a decision. (Type "nautilus" on the command line.)
OpenOffice - A set of programs similar in look and feel to MS Office, although with limited compatibility for advanced features (Generally quite functional). Look at OpenOffice Writer (a word processor) and Impress (a presentation package). If you don't like the OpenOffice suite for any reason, AbiWord is a reasonable replacement word processor (much faster response time / startup, but fewer advanced features). (Look under the RedHat menu for links to these, or type "oowriter" or "ooimpress" on the command line)
Gnumeric - A spreadsheet. Generally more powerful than OpenOffice Calc, and with a very simple native format (GZipped XML), Gnumeric is heavily used by our grading scripts. TAs should play with Gnumeric extensively. (Type "gnumeric" on the command line)
Mozilla - The Open Source basis for Netscape 7.x and countless Linux/Unix derivatives (like Galeon, my personal favorite). A very good browser. Can support Flash, embedded movies (QuickTime, MPEG, and even many Windows Media formats), ask me later if you're interested. (Type "mozilla" on the command line, or click the launcher that looks like the planet Earth.)

Mozilla also includes Mozilla Mail / Thunderbird, a modern GUI mail-reading client. This is fairly cross-platform, so it is a good choice for a mail-client. If you have time, try setting up your mail client (the department FAQ on mail is here. Mozilla Mail is considered to be the standard mail client for the CS department.
Evolution - A wonderful GUI email client. Users of Outlook Express will have no problem adjusting, unless you really enjoy automatically running every piece of malware on the Internet. (Evolution has much better security.) Supports POP3 and IMAP, although IMAP is a bit touchy if you really push it hard (for example, 30+ mailboxes with 100+MB of mail makes it cranky. (Type "evolution" on the command line, or click the launcher that looks like an envelope.)
Acroread Adobe makes a version of Acrobat Reader, although there are numerous other PDF viewers available (xpdf, and ggv just to name two.) (Type "acroread" followed by the name of your PDF to invoke.)

2 pm

Command Line Stuff

Note: If you have had NO Linux/UNIX experience before, you probably need to read through the introductory material that we have created for the undergrads for their introduction to Linux. Read through that material here

A decent UNIX command reference can be found here. This is probably worth bookmarking.

ssh - ssh lets you use a terminal window on one machine as a terminal window onto another. Within the CS department, since your username is the same across the cluster, you can simply type:
```
  ssh hostname
  
```
in a terminal window, and it will prompt you for your password on that host. If you need to log on as a different user, you can do either
```
  ssh username@hostname
  
```
or
```
  ssh hostname -l username
  
```
Try logging on to hill from your terminal. Note that everything that ssh sends across the network is highly encrypted. Even in untrusted areas, if your SSH client and server are safe, your data will be secure.

There are scores of other options to SSH. The advanced options of SSH and the full usage of netcat are two things that any self-respecting networking student should know. Ask later if you have questions.
X-Tunneling - When SSHing from a host running X11 (the graphical system for most Unix derivatives) to a host that is aware of X11 (has a few libraries and some applications), you can have graphical applications from the remote host displayed on your local console. This is a high-bandwidth application, and is generally only usable on a LAN.

SSH onto hill and run a graphical application. Good choices are emacs (the world's only thermo-nuclear text editor), xclock (a clock), xbiff (a program that tells you if you have new mail). Running Mozilla or Evolution is generally not a very good idea, but Gnumeric has decent performance.
scp - securely copy (hence the name) files. Works using the same encrypted protocol as ssh, so nobody will (generally) be able to see what you are copying, or its contents. It works just like cp, with one exception: to specify a file on a remote host you prepend the hostname and a ":" to the file (relative to your login directory on that host).
```
  scp username@hill:dirInMyHomeDir/myFile .  
  
```
will copy the file ~username/dirInMyHomeDir/myFile on hill to the current directory (assuming you know the password for username.) Similarly,
```
  scp myFile username@hill:dirToPutItIn
  
```
will copy the file myFile to ~username/dirToPutItIn/myFile on hill.

Another useful flag is -r, for recursive. This allows you to recursively copy a directory structure to or from a remote host.

scp has a number of additional options, but these are by far the most common uses.
rdesktop - An open-source client for Windows Terminal Server. A script has been created by the Systems group to invoke rdesktop and perform necessary load-balancing and such. If you find that you just absolutely have to use Windows for something on the CS Cluster, this is how you do it.
```
  windows
  
```
It is as simple as that (doesn't get much simpler.) Then log in as normal, except under Windows. This uses an extremely efficient protocol, and is useful even across large stretches of the Internet so long as you have about 500Kbit/s worth of connection. A very useful tool. (Note that you can toggle Full-Screen Mode at any time by pressing Ctrl+Alt+Enter.)
Printing - Most modern apps will let you print by just clicking File->Print. However, some older applications will simply create a PostScript file (a file with a .ps extension). If this happens, use lpr to print the postscript file (programs like a2ps can be used to print ascii text, check the documentation for a2ps for more information). lpr can also be used to choose which printer to print to: for example you could print to a printer named clifford by using
```
 lpr -Pclifford myfile.ps
  
```
The command "lpq" can be used to find out what is currently queued up for a given printer.
Getting help - There are a few main things you can (and should) use for getting help with the CS cluster:
1. man pages - The documentation for most command-line programs can be found using the "man" program. For example, to see the full list of options to "scp", try:
```
  man scp
  
```
  If you aren't sure what program to run, but can think of a word that will appear in a one-sentence summary of the command, try
```
  man -k keyword
  
```
2. info pages - A more modern version of man pages, the info pages are more like the World Wide Web than a text file like the man pages. Check here when the man pages are overwhelming.
3. Google. Google knows everything. In modern times, if you are asking questions of your peers (or worse, your advisor/instructor) without having attempted to find it yourself using Google, you are being terribly rude. PLEASE do not ask questions without trying to find the answer yourself.
4. A good text reference. If you are new to Unix, or don't know as much as you would like to, we really recommend Teach Yourself UNIX in 24 Hours. It is available for $10 - $20, and is worth every penny.
5. Ask someone. People know things. Find the nearest guru, see if they are busy, and ask them. If you find yourself pestering them all the time, buy them a soda or take 'em to lunch sometime to show that you understand that you are using up their time. Its just polite (and no, I'm not saying this out of greed, I'm not one of the gurus that answers questions in person much. *grin*)
6. Email help. For general information questions, feel free to email the general chat / discussion / help list for the CS department general@lists.cs.ucr.edu. To report things that you think are broken, send email to systems@cs.ucr.edu.

3 pm

Programming Stuff

The basic tools that you will probably be using are these:

gcc - The GNU Compiler Collection. Has compilers for many languages, but is generally only used for C (on the command line as "gcc") and C++ ("g++"). If you've never written anything in C++ before, work through some of the labs and assignments from CS 12 when you get a chance, that should bring you up to speed quickly.
gdb - The GNU Debugger. A powerful beast. Remember folks, USE THE DEBUGGER. A brief tutorial is here We will cover this in greater detail tomorrow.
java/javac - A command-line java tool. The compiler is invoked as
```
  javac myClass.java
  
```
Compiled class files are executed in the Java runtime as
```
  java myClass
  
```
(The department generally doesn't focus on Java a lot, but several research projects are being done in Java here, so it doesn't hurt to know.)
Turnin

Secure Server

Your Mission - Before you leave today, you and your partner should implement this in C++. Turn in your work on Turnin under CS 14, OrientationProject.