Moshe's Meta Mind

CISC 3110 Lecture 3 Notes: More on Terminal and Unix, Style, Grades and More

Today Professor Weiss continued his discussion of Unix and file operations. We started by copying the program from the Lecture02 directory to the Lecture03 directory. The command to copy a single file on Unix is:

$> cp source-path destination-path

The problem is that this won’t work on directories. To copy the contents of an entire in a directory, use

$> cp -r source-path destination-path

The r stands for “recursive”. Professor Weiss explained “recursive” as doing something until you can’t do it anymore. For example, when climbing a flight of stairs, you climb one stair. Now, you still have a flight of stairs to climb, but you’ve climbed the first stair already. To keep repeating this process is execute the process recursively. Climb one step. There are more, so keep climbing. Climb again. Still more… Climb again. Until you hit the top step. In other words, to “recurse” is keep repeating a process.

Now, talking about copying from one user’s directory to another, we want to copy with as little pain as possible. We can start with an absolute path

/home/student_weiss/

or a relative path

~/student_weiss/private/Lecture02/*

If the local directories are the same, you can use the current location to avoid long paths. (Professor Weiss didn’t specify them, he said we should look into it.) Professor Weiss points out the arrow keys as “history” to bring up the previous commands to make changes to typos.

Some Terminals act like vi, with insert and normal mode, and some act like Windows in that you can use the arrows and edit at the same time. CLI is “Command Line Interface”, useful acronym to know about.

Now, we’re finding the smallest value in an array. The wrong way to do it is to find a large number and start that as the maximum value. The correct way to find this value is to start with the first value in the array. It’s a “working” value, although not necessarily the smallest value. This is akin to running through a deck of cards and starting with the first card. If a card that we find is smaller, we throw away the first card and take the new smaller one. Here’s what this looks like in code:

int min(int arr[], int n){
       int result = arr[0];
       for(int i=1;i < n;i++){
          if(arr[i] < result) result = arr[i];
       }
}

There's a bug here, more on that soon.

Professor Weiss notes the way he indents the if statement. "Real Estate is expensive, especially if you live in NY". On the subject of style, Prof. Weiss just said that he won't take points off from his assignments because he doesn't give points on assignments! When code is handed in, he'll check the output. Freeze dates...

Professor Weiss is correcting a typo with vi.

:.1,29s/theMin/result/g

In English, the above expression is "begin, end, search, slash, search pattern, replacement pattern, global". We start on the current line.

As we mentioned, there's a bug in the above function. Professor Weiss is explaining arrays. "Imagine if I asked you to declare variables for 10 numbers. Now you declare int n1, n2, n3, n4 etc. Now go do it for 1,000 variables." In C++ an array of integers is essentially just a list of numbers. Contrast this with Java, where arrays know about themselves. (Particularly, their length.)

In C++, if you go outside the bounds of your array, it's like accidentally going into someone else's property. You may get your head blown off. If you put data out of bounds of an array, you're potentially destroying data that someone else put there. It's meaningless to you.

It could be that you're outside the bounds of your array, but still inside your program. You're just destroying your own variable. The other possibility is that this is "the end of my ranch and the neighbor put a minefield there". You could blow up. The system makes sure that you never go out of your program, but you can still easily overstep the bounds of your own array. If I say a[0] = 15; and `a` is part of Microsoft Word while it were running in memory, you can crash Word. If you're working on a term paper and a program at the same time, you'd possibly break your term paper. Therefore, the operating system takes care of this for you.

Is it worse when your array is "at the edge" of your program, or somewhere "inside" your program? The "middle" is worse, because you don't necessarily get immediate feedback when you try to overstep your bounds. You end up running in some broken state, liable to do more damage later. (In Prof. Weiss' CISC1110 class, he therefore teaches to terminate when weird errors occur.)

Moving back to our program, "garbage in, garbage out". We need a way to return no value when the array has no values in it. Unfortunately, we can't return -1 or 0, because those values are technically valid input. For now, we're leaving it at is. Now, we're covering there "conditional operator" (also called "ternary operator").

int years = ...;

int weeksVacation;

if(years < 5){

weeksVacation = 2;

}else{

weeksVacation = 3;

}

Here's to "talking boolean", which is thinking in terms of true and false at a much more interesting value. Here is how to change the above code to use a single conditional operator:

weeksVacation = years < ? 2 : 3

This has two symbols and three operands, hence the term "ternary", as opposed to a "binary" operator. Professor Weiss says that not knowing ternary operators is like not knowing fractions. Heh. Unlike and an if statement, you must have an else when using a ternary operator. Also, Professor Weiss says that he believes that the two sides of the colon must be of the same type. Makes sense, since we're often using it in the context of assignment.

We're editing some code, so back into vi. (Capital J is a vi-ism for "Join".) We're modifying our print function so, here's the old one:

void print(int arr[], int n) {
  cout << "{";
  for (int i = 0; i < n; i++) {
    cout << arr[i];
      if (i < n-1) cout << ", ";
    }
    cout << "}";
}

Here's what it becomes:

void print(int arr[], int n) {
  cout << "{";
  for (int i = 0; i < n; i++) {
  cout << arr[i] << (i < n-1 ? ", " : "");
  }
  cout << "}";
}

That's it for ternary. Now we're writing a function to clear out the contents of an array. Can we get a value that has no value? We discussed this earlier. Java has it. We're going to use a zero, but for future reference, we should declare a constant.

Fun fact: Heinz has 57 flavors of ketchup.

Now Professor Weiss is writing a reverse function. Let's see if I did this correctly. Okay, I did it wrong, but there's going to be a problem here... We want to swap a[n-i-1];.

// TODO: Put array reverse here,
//waiting for Prof Weiss to change the permissions

Professor Weiss now shows how to move entire blocks of lines. (:start,end,"t or m", destination line). Now here's the gotcha. The reverse function reverses, but it reverses too much. So the array will look exactly the same when you're done as when before you started. The fix is fairly simple. Here's the change:

Bash stands for "born again shell" (I wonder if this has to do with Bjarne Stroustrup, creator of the C++ language.) When your shell starts running, it runs an initialization file. It's either .profile or .bashprofile. In there, you can set the default permissions. Apparently the default or Professor Weiss' .profile has permissions set to restrict us from reading new directories.

Professor Weiss was going to show us to change permissions, but we ran out of time.

Homework: Take the array functions and make it work for an array of strings. No deadlines yet. Use the cheatsheet.

Hints: You can't average strings. You can take minimums. What about a class called "employees"? How do we compare custom data types?