lab00 : Getting started

num ready? description assigned due
lab00 true Getting started Mon 03/30 12:00AM Sun 04/05 11:59PM

Introduction

Before you start this lab, make sure that you’ve followed the instructions in Lecture 1 about getting a terminal on your machine. You have several options, and this lab write-up assumes that you’re connecting remotely to a UCSB lab machine—you can totally use your own machine instead, though.

This lab must be completed individually. In the subsequent labs you are encouraged to work with a programming partner if you’d like (via Zoom or some other method that allows you to share screens).

Get setup with the tools for this course

Create a CoE account if you don’t have one already

To connect remotely to a UCSB lab machine, you will need a College of Engineering account. You can create an account online at https://accounts.engr.ucsb.edu/create.

If you are enrolled in any CoE course this quarter (including CS24), you can create your account immediately. If you are not, you will need to contact the ECI Help Desk at help@engineering.ucsb.edu.

Get setup with github

We will be using github.com in this course. We have created an organization called ucsb-cs16-s20-nichols on github.com where you can create repositories (repos) for your assignments in this course. The advantage of creating private repos under that organization is that the course staff (your instructors and TAs) will be able to see your code and provide you with help, without you having to do anything special.

Get setup with github and adding yourself to our organization

To join this organization, you need to do the following:

  1. If you don’t already have a github.com account, create one on the “free” plan. Visit https://github.com/

  2. If you don’t already have your @umail.ucsb.edu email address associated with your github.com account. It’s important that it’s your @umail.ucsb.edu and not your @ucsb.edu—the sign up tool won’t work otherwise. Go to “settings”, add that email, and confirm that email address.

  3. Visit our Github Sign Up Tool at https://ucsb-cs-github-linker.herokuapp.com/, login with your github.com account, click “Home”, find this course (CS16-S20-Nichols), and click the “join course button”. That will automatically send you an invitation to join the course organization on github. If this step doesn’t work for you, ask your TA to add you to the organization manually.

  4. There should be a link to the invitation for the GitHub organization for this course (https://github.com/ucsb-cs16-s20-nichols). Click on the invitation link and accept it. You can also go straight to https://github.com/ucsb-cs16-s20-nichols and see the invitation there (if you’re logged in). Accept the invitation that appears in your browser (from step 3) or log into your account on https://github.com/ to accept the invitation.

Get setup with gradescope

We will use gradescope to grade all your homeworks, exams and lab/programming assignments. You should have received an email notification with instructions about logging into gradescope. If you weren’t invited to gradescope for some reason, give your TA your name, email and perm number, and they can manually add you to the class.

Log into our class site on https://www.gradescope.com/: CS 16 Spring 2020 (Nichols) and navigate to the lab00 assignment. Keep this page open to submit your code at the end of the lab

Implement and submit a simple C++ program

Note: If you’re using your own machine and don’t want to connect remotely to a UCSB lab computer, you can skip to Step 3. Make sure you know how to use SSH, though—you’ll need it for CS 24

Step 1: Open a Terminal and write a “Hello World” program

The first step in every assignment will be to open a terminal window, which will be the environment you use to write, compile, and run your programs.

If you are working on your laptop, whether Windows, Mac or Linux, the instructions below will tell you how to connect to csil-02.cs.ucsb.edu specifically, but you can connect to any of the following machines. Pick your favorite number so that there aren’t a bunch of users on the same machine:

Step 2a: Opening a Terminal on a Phelps or CSIL Lab Machine

  1. Log in to the machine using your CoE account credentials (i.e. your username and password) created in Step 1.

  2. Find the Activities menu, which is in the top-left corner of the screen. Click on it to open the menu.

  3. Next, type “shell” in the search box. Then click the “Terminal” application which appears.

  4. You should now see a terminal window open. You can open more tabs or windows from the Terminal application’s menu. Skip to Step 3 and read the other steps later when you attempt to log in remotely

Step 2b: Connecting to CSIL via SSH on Mac OS X or Linux

To get started on Mac OS X or Linux, you first need to open a terminal program. This involves slightly different steps on either OS.

  1. Find the search menu. It appears at the top of the Unity bar:

Ubuntu Search Menu

  1. Click on that icon to open the search menu. Then type “terminal” and click on the “Terminal” application which appears:

Ubuntu Terminal Application

On Mac OS X:

  1. Open the “Terminal” application. It is found inside the Applications folder of your main drive, inside the Utilities subfolder. The icon looks like this:

Mac OS X Terminal Icon

You can also find it using Spotlight by typing “terminal” and pressing ENTER.

Once you have a terminal window open on your machine, you next need to connect to the CSIL server remotely.

You will do this using a UNIX command (an internet protocol, really) called SSH (short for Secure Shell).

Type the following command in your terminal, replacing USERNAME with your CoE username:

$ ssh USERNAME@csil-02.cs.ucsb.edu

SSH will first ask you a question which looks like this:

The authenticity of host 'csil-02.cs.ucsb.edu (128.111.43.14)' can't be established.
RSA key fingerprint is 90:ab:6a:31:0b:81:62:25:9b:11:50:05:18:d3:1a:b5.
Are you sure you want to continue connecting (yes/no)?

Type yes and then ENTER to continue. It will next ask for your CoE account password. When you type it in, nothing will show on the screen (not even dots). However what you type is still being sent and once you are finished with your password, you can press ENTER to login.

You should now be remotely connected to CSIL! You can make sure by typing the following command (which will tell you what machine you are currently issuing commands to):

$ hostname

This should show csil-02.cs.ucsb.edu. You can now do anything you could normally do in a terminal window in CSIL or the Phelps lab (except run graphical programs).

Extra Note: Graphical Forwarding

This is not required or necessary to use CSIL remotely, so if you are not interested, go ahead and skip this part.

If you have an X windows system installed you can get graphical applications running by forwarding X from CSIL to your machine. To do this, add the -X option to the SSH command like this:

$ ssh -X USERNAME@csil-02.cs.ucsb.edu

X windows is almost always installed on graphical Linux, and can be installed on Mac OS X as XQuartz (which can be found at http://xquartz.macosforge.org/landing/).

Step 2c: Connecting to CSIL via SSH on Windows with PuTTY

To connect remotely on Windows machines, we recommend using a program called PuTTY. This program is a well-known and widely-used SSH client for the Windows OS.

First, download the program from http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html. You only need the executable file putty.exe, but feel free to download any other programs that you want. The page includes portable versions and a version with an installer. Always make sure to download PuTTY from this site, so that you can make sure it is the correct program.

Once downloaded, run PuTTY like you would open other programs. If you just download the putty.exe file, you can open it from your downloads folder directly. You can also move it to any other location on your machine and open it from there. If you used the installer, open PuTTY from the Start Menu.

When PuTTY opens, you should see a window that looks like this:

Empty PuTTY window

Type csil-02.cs.ucsb.edu into the box labeled “Host Name (or IP address)”. Leave the “Port” setting at 22 and leave the “SSH” button checked. The window should now look like this:

Completed PuTTY window

Then click on the “Open” button to connect. PuTTY will then show a prompt which looks like this:

PuTTY Host Key Prompt

Click “Yes” to accept and have PuTTY remember CSIL’s key.

Once a connection is made, CSIL will ask for both your username and then your password. Type in your CSIL username and password. The password will not be shown on the screen, but the characters you type are being used. This step will look something like this (with your username instead of “username”):

PuTTY Login Prompt

Once you have logged in successfully, you should be connected remotely to the CSIL server. Run the following command to make sure (this command shows the full host name of the machine you are logged in to):

$ hostname

This command should output csil-02.cs.ucsb.edu. You can now do anything in this terminal window that you could do on a CSIL machine or a Phelps lab machine, except run graphical applications.

If you want to run graphical applications, instead of using puTTY, you can use other programs, such as MobaXterm.

Step 3: Create cs16 and lab00 directories

Now that your environment is set up, you next will need to create a directory (a folder is also called directory in Linux) that will contain all your work for the course. Then, inside that directory, you will need to create another directory to contain your work for this assignment.

To create your CS16 directory, use the mkdir command. Type the following in the terminal and press enter:

$ mkdir cs16

The $ represents the terminal prompt; you won’t type this character. Whenever you see it, that means that the following command is intended to be typed into the terminal window and run by pressing enter.

You can see list of files and directories in the current directory with ls command. Type the following in the terminal and press enter:

$ ls

You should be able to see the directory you just created i.e. cs16

Now move into that new CS16 directory with the cd command as follows:

$ cd cs16

And create and move into a lab00 directory:

$ mkdir lab00
$ cd lab00

At any time, you can check what directory you are current in with the command pwd. It will output the full path of the current directory. For example, if you are inside your lab00 directory, you might see:

/cs/student/yourcsilname/cs16/lab00

Knowing how to navigate a UNIX environment and issue UNIX commands is VERY valuable to computer scientists and engineers. To learn more UNIX commands, there are lot of cool Web resources and books on the topic. This is one website I found that’s a good introductory page: Useful unix commands

Step 4: Editing text files for programming

Let’s take a little detour on how to best create and modify text files. These will carry all the code (regardless of computer language) that we want to assemble, compile, and execute.

You are surely all familiar with Microsoft Word as a widely-used “word processor”, but please DO NOT USE MS WORD TO WRITE PROGRAMS!!! :)
Instead, for programming, you have access to a very large number of excellent text editors - most of them are free to use! I will introduce you to just 4 of them below. If you already have a favorite editor and know how to use it well, then you don’t have to change and use something else, just for this class.

In fact, AND PLEASE NOTE THIS, no one editor is necessarily “better” than another. It is a matter of your preference. This is a great time for you to explore multiple options and then pick one. Once you pick an editor of choice, STICK WITH IT!

As you progress in your Computer Science education and, subsequently, your careers in CS, make sure you end up learning how to use more than one editor. You can still have a “favorite” that you excel at using, but at least have a working familiarity with others.

emacs for UNIX-based OS

emacs is a very popular editor that’s available on just about every UNIX machine (including the ones that you’re using in the CS labs) and UNIX-based machines (like MacOS computers).

To run emacs on a UNIX machine or a MacOS machine, open up a terminal (see above for how to do that on Macs) and type:

$ emacs

To edit a file (let’s say it’s called “filename”), you’d type:

$ emacs <filename>

Go ahead and edit a file named “hello.cpp”

In the editor type a few comments on the first line as follows:

	// hello.cpp
	// Your name
	// Your perm number

Note that in C++, you can insert comments by preceding the comment with //

To save the file, press Ctrl-x, Ctrl-s. To exit emacs and return to the unix shell, press Ctrl-x, Ctrl-c

To learn how to use emacs, there is no substitute for PRACTICE!!! Of course, there are multiple online resources that you can look at (especially given emacs’ popularity) and here are some of them:

vim for UNIX-based OS

vim (or sometimes called vi) is another popular editor that’s also available on just about every UNIX machine (including the ones that you’re using in the CS labs) and UNIX-based machines (like MacOS computers).

To run vim on a UNIX machine or a MacOS machine, open up a terminal (see above for how to do that on Macs) and type:

$ vim

To edit a file (let’s say it’s called “filename”), you’d type:

$ vim <filename>

To customize your vim environment for a better coding experience with C/C++, let’s add the following lines to a .vimrc file in your home folder (make sure to use this exact filename, since it is a system file, there are no spaces in ~/.vimrc).

Let’s dive in! Open the file:

$ vim ~/.vimrc

Look at the bottom of the vim window to check if you are in the “Insert” mode (if you are not, then type i). Either copy/paste (by right-clicking using the mouse, if you are using the terminals in the lab) or type the following four lines into the file:

set nu
syntax on
set autoindent
set cindent

Exit the “Insert” mode by pressing Esc key on the keyboard, then type :wq to write and quit the file (the colon : is important! Don’t leave it out!).

Again, to learn how to use vim, there is no substitute for practice!!! Here are some more vim hints to refer to. We don’t expect you to be experts in vim this quarter, but you should definitely pick up “survival” skills. A little later this quarter, we will confirm that you know how to do the “basic eight” (vim: basic eight).

  1. Visual Studio Code for Windows OS and MacOS X — see the product website (it’s a program that you’d have to download)

  2. Sublime Text for Windows OS and MacOS X — see the product website (it’s a program that you’d have to download)

  3. Notepad++ for Windows OS — see the product website (it’s a program that you’d have to download)

Step 5: Create and edit a file containing a C++ program

Now it’s time to write the program! If you’re comfortable with one of the reviewed text editors, then go ahead and use one. Otherwise, here are some emacs hints and some vim hints.

This assignment only needs you to write a program that prints out two lines on the display, and nothing else. The output should look exactly as follows (no space before or after each line, except the 2 newlines):

Hello, world!
I am ready for CS16!

Start with a “skeleton program” (or template) that contains the necessary structure but that does not do anything:

#include <iostream>

using namespace std;

int main() {
    // Your printing code should go here

    return 0;
}

Go ahead and type this in to the hello.cpp file. Alternatively, you can copy and paste it directly from this page.

Next, you will need to replace the comment with code to print out the expected output. Comments in C++ are lines that start with // or text between /* and */. The second type can span multiple lines.

Important note: For students familiar with Python, remember that lines starting with the # character are not comments in C++. Rather, they are important include lines that allow your program to use the input and output functionality. Make sure to copy those lines in your program as well. Only // or /* create comments in C++.

To print out text to the terminal, you can use the cout stream. To output something use the << operator as shown below:</p>

cout << "This will be printed out to the terminal" << endl;

The endl command will cause a newline (i.e. a carriage return) to be printed and the next print to go on the next line.

You can adapt this line to achieve the objective of the assignment. Remember that we need to print two lines, each with a newline at the end. You can do this with one or two statements.

Step 6: Compile the Code

Now that the code is written, we need to compile it. This will be done using a special program called a compiler.

Before moving on, make sure you save your code and close the text editor. The following step will be done in the terminal.

For C++ code we will use the g++ compiler that’s built-into many UNIX machines (it even works on most MacOS terminal programs). You can compile the hello.cpp file into an executable called hello with the following command:

$ g++ -o hello hello.cpp

This will compile your code and make an executable version of it. Specifically, it will tell the compiler to take the source code file hello.cpp and compile and link it to an executable called hello.

If the compilation is successful, you won’t see any output from the compiler, but if you issue a UNIX ls command, you should see a new file has appeared: one called hello. You can then use the following command to run your program:

$ ./hello

Which means “in the current directory, as represented by the . character, run the program hello”. You should then see the program output the two expected lines.

The other possibility is that the program may not compile successfully. What to do then?
If you run the g++ command and are unsuccesful with your compilation, then you might see an output that looks like this:

hello.cpp: In function ‘int main()’:
hello.cpp:10:1: error: expected ‘;’ before ‘}’ token
 	}

The compiler will try to give you hints on the line (in this case, it’s complaining about line 10) where the error occurs, and also about what the error is (in this case a missing semicolon). You will also note that, in this case, an output executable file is not produced.

If you encounter an error, use the compiler hints and examine the line in question. If the compiler messsage is not sufficient to identify the error (which happens more than sometimes), you can search online to see when the error occurs in general. Once you have fixed the error, run the compilation command again. De-bugging a program code is a necessary ritual in almost all programs written (even those written by expert coders). More on that in a later class.

Step 7: Submit your program for grading

Once you are satisfied that your program is correct, then it’s time to submit it.

Log into your account on https://www.gradescope.com/ and navigate to our course site: CS 16 Spring 2020 (Nichols). Select this assignment. Then click on the “Submit” button on the bottom right corner to make a submission. You will be given the option of uploading files from your local machine or submitting the code that is in a github repo. For now choose the first option and follow the steps to upload hello.cpp to gradescope. We will use the second method later on in the course.

You should receive 50/50 for a correct “Hello World “ program

Congratulations on completing your first C++ program!

If you are in the Phelps lab or in CSIL, make sure to log out of the machine before you leave. Also, make sure to close all open programs before you log out. Some programs will not work next time if they are not closed. Remember to save all your open files before you close your text editor.

If you are logged in remotely, you can log out using the exit command in UNIX:

$ exit