LING/CMPS 80G: Introduction to Unix

Summer Session II, 2003 Lectures: Social Sciences I #110 MWF 1-3:30pm Lab Sections: Social Sciences I #135 TTh 3-4:30pm & 4:30-6:00pm This course satisfies a T2 general education requirement. (Here's more on requirements met by this course.)

Instructors: Patrick Davidson pacd@ucsc.edu Afton Lewis afton@ucsc.edu

Overview and topics covered

LING/CMPS 80G is first and foremost a computer literacy class, but with a difference. Where some people (and some software companies) would have you believe that what makes a competent computer user is being able to manipulate applications (say, point 'n' click productivity tools like word processors, or spread sheets, or certain mail programs), this course takes the literacy in computer literacy seriously. What counts from our point of view is being able to express computing needs directly and powerfully to a computer. The computers we have in mind are those that run a variety of Unix, and these are everywhere. Computers running Unix are very frequently the backbones of university computing networks, PCs often have Linux or a variety of BSD installed, and since the advent of OS X, Apple Macintoshes all run a form of Unix too.

If expressing yourself to these types of computers sounds suspiciously like it involves language learning, you're exactly right: we are going to examine and gain proficiency in two languages.

[This does not mean, however, that we expect you to be a budding computer scientist (although if you are, you should consider taking the course for the following reasons, but with the following proviso). On the contrary, we assume no computer experience at all, just the willingness to practice these languages, and by that we mean allowing yourself to goof up, learn from mistakes, and try again (and again...). Just like you need to when learning any natural language.]

The two languages, and how we'll proceed:

1. We'll have a look at basic HTML - the language of web pages - since:
   • the web is a central part of academic life,
   • pages are easily stored on and browsed from UCSC's Unix system: setting up a web page (as you will do in the course) is an excellent way to start learning your way around UCSC's installation of Unix on the unix1 and unix2 servers. (Note: these are the machines we'll generally use for demonstration and practice. Using them requires getting and knowing how to use a cats account.) In setting up web pages we'll examine how file systems are set up, and how to manipulate them, as well as the crucial tool the text editor, e.g., pico, vi or emacs.
2. Much more extensively, we'll take up the language of the 'C Shell', which we'll call Cshellese. (In fact, we will have already started learning it by learning about file systems when considering HTML.)

   The C shell is one of the command line interpreters that is installed on all Unix systems: 'shells' act as the interface between you the user and the Unix operating system, and thus the machine and the information stored on it. We'll look at the following topics in learning Cshellese:

   • Essential commands: creating, copying, listing, moving and removing files and directories; accessing the contents of files: editing, viewing (from the top, from the bottom), counting lines and words.
   • Stringing commands together, part 1: using conjunctions (do this AND this), using primitive conditionals (do this ONLY IF this works properly); sending the output of one command to a second command.
   • More advanced commands:
     • pattern matching (e.g., discover all the instances in a file (say a 'dictionary file') of words with all the orthographic English vowels in them);
     • automated editing based on pattern matching (e.g., turn every instance of 'Bob' into 'Bill', but only if it's not at the beginning of a line, or, e.g. remove all the HTML code in a web page, leaving only (and all!) text behind.)
   • Using variables: setting their values, recovering their values.
   • Stringing commands together, part 2: using 'control structures': control structures are simple devices that allow you to be extremely precise about the conditions under which you want certain commands to be executed.
     • conditionals: if some condition is met (e.g. a file with a certain name exists), do the following (this can be an arbitrarily long list of commands),
     • loops: perform some set of commands over and over again. These are controlled (i.e. stopped) in one of two ways:
       • by exhausting a list (the 'foreach' loop).
       • by failing a condition (the 'while' loop).

   In fact, having strung these commands together, and placed them in a file (so you can easily reuse them, unlike the primitive conditional), you have a program. Just like that, after about three and a half weeks of instruction!

   More generally, these methods of stringing commands together are, in fact, the central tools of any computer language at all: you'll be well placed after this class to take on learning more complex languages (you will find that they are elaborations on the basic techniques we discuss).

   The best and summary reason to study Unix is this: you should be in charge of the computer, not the other way around. We'll start you well down the path of reaching that goal.

Requirements met by this course

For all students: Linguistics 80G / Computer Science 80G satisfies a T2 general education requirement: it counts as a topical course in the Natural Sciences & Engineering area.

For Computer Science and Computer Engineering students: No requirement in these majors is fulfilled by 80G, but if you do not yet have experience with any member of the Unix family of operating systems (Solaris, Linux, NetBSD, etc.), then you will be enormously advantaged if you take this course first, before launching into the preparatory courses (the CMPS and CMPE 12x series and so on). Those courses generally assume that you will pick up Unix use and general knowledge as needed, rapidly, in your spare time, without much instructor help. This course teaches Unix use specifically, and provides access to an array of sophisticated techniques that will be of enormous value later when you are writing programs.

For Linguistics and Language Studies students: Linguistics 80G is an ideal way for you to meet one of your T2 general education requirements (take it early), and it is a terrific help to have done 80G if you end up taking Linguistics 160, Computational Linguistics. However, although the Department of Linguistics is in the Division of Humanities, Linguistics 80G does not satisfy a Humanities general education requirement. It also cannot be counted as one of the electives in the Linguistics or Language Studies majors.

Lab sections

Lab section attendance is required. Sections provide your main opportunity to interact with the instructor who will be responsible for guiding you through the course and evaluating your assignments (which are mandatory if you want to pass). One-on-one help cannot be provided in the lectures; although we will certainly entertain (many) questions in class, they cannot be very specific or personal, they must relate to the work at hand, and they can only be answered briefly. The lab section times are as follows:

• TTh 3:00pm - 4:30pm
  Social Sciences I #135
• TTh 4:30pm - 6:00pm
  Social Sciences I #135

You will need to be logged in to the UCSC Unix server unix.ucsc.edu (a.k.a. unix1 and unix2, i.e. the machines on which you have a cats account) for several hours each week, and not just during the lab sections. It will be best for you to have expert guides available to help you if you get stuck, and at the lab section times at least, you will have those guides. If you attempt to get your work done for this course at other times, it will be at your own risk, although it is certainly possible. It is your responsibility to keep in touch with the instructor responsible for your section.

Books

A reading packet for this course (a collection of detailed handouts and lecture notes) will be on sale at the Bay Tree Bookstore. In addition the following books will prove extremely useful, the first one being an essential reference work for the course.

Unix in a Nutshell: System V Edition, Third edition, 1999, by Arnold Robbins. O'Reilly & Associates, Sebastopol, California. ISBN 1-56592-001-5.

A well-organized, serious desk reference work to keep permanently. Compact, authoritative, easy to use, cheap by today's standards. You need this book.

Learning the Unix Operating System by Grace Todino, John Strang, and Jerry Peek. Fifth edition, 2001, O'Reilly & Associates, Sebastopol, California. ISBN 1-56592-060-0.

Required for all absolute beginners (you should be able to make do without it if you already use the campus Unix systems). This book is very up to date (only a few months old), and, among other things, the brief introduction to the X windowing system is particularly useful.

Requirements and expectations

The following list is not exhaustive, but includes some of the most important requirements and expectations for students in the class.

• Have a CATS Athena account. Without it you simply cannot participate in the class at all, and until you do, you will not be officially in the class. If you need an account or don't know how to access the one you think you have, check the CATS website for detailed instructions.
• Select a section and send electronic mail to the instructor who will be leading that section, when that is announced. (The announcement will come in the opening sessions of the class.) Give your full name, section choice, and a brief description of your prior computing experience.
• Attend lectures regularly. It will be assumed that every student is at every lecture; the assumption will be that if something is announced in one of the lectures, then everyone knows it.
• Attend lab sections and participate. The assumption will be that every student attends every meeting of her section.
• Do ten homework assignments. There will be two each week, announced (at the latest) on Monday, and on Wednesday. They will be due by the beginning of Wednesday's and Friday's class respectively (so the assignment that was announced on Monday will be due on Wednesday, and the assignment that was announced on Wednesday will be due on Friday).
• Read e-mail daily. This will be the primary method of communication outside of class.
• Maintain regular contact with instructors as necessary.
• Sit at least five in-class quizzes or exams. These will quite often be on Fridays, so approximately every week, but are not definitely scheduled. These and other in-class spot quizzes may be (and probably will be) given without notice.
• Complete a final project to be turned in during exam week. The nature of this course is such that progress can far better be evaluated by assigning a final project exercise instead of an examination. But the quality of that final project will be important.

There will be no make-ups for assignments, quizzes, or exams. Instead, your worst assignment of the course will be disregarded in writing your evaluation, and your lowest quiz or exam score will be disregarded in deciding whether you pass the course.

A cautionary note

The level of this course is genuinely introductory. You should not take 80G if you are already browsing directory structures and customizing your .cshrc and printing Postscript files; it'll be old stuff and you'll hate yourself and you'll get bored with us and (worse) we'll get annoyed with you. What we are looking for is students who have no idea what a .cshrc might be but are prepared to learn if it is serious and important.

It should be stressed that although this course is really introductory, it is not a snooze-through way of getting five easy credits. People do fail this course. It is not possible to pass it without regularly using the Unix system, staying in touch with your instructors, attending classes, spending many long hours at the keyboard, turning in assignments, passing in-class quizzes, and doing some hard thinking.

It is a vital thing about courses in languages that you cannot just learn up factual material for quizzes and leave it at that. If you don't exert yourself, use the language, interact, make mistakes, get involved, and try to incorporate it into your behavioral repertoire, a language course is close to useless to you. You cannot possibly become a French speaker by avoiding class participation and doing night-before cramming to squeak a pass in quizzes. You don't even start to be a French speaker until you get out there and embarrass yourself in conversation with French people. You have to make mistakes, recover from them, keep on trying to get communication going in French, and ultimately make French forms of expression a part of your life. It changes you. And so will learning Unix. But only if you use it, try things out, log in every day, use the reference books, and exert yourself. If you do this course in a minimalist way, it will be of no value. If you do it in a whole-hearted way, it will start to be fun, and it will be of permanent value.

A further note on Unix

Unix is technically a trade name, but also (rather like "Xerox" or "Frigidaire" or "Coke") gets used as a generic name. So "Unix" is used in a general way to refer to a family of powerful operating systems, some proprietary and some open source (given away free), including those of most of the centrally-maintained machines on which CATS gives accounts to UCSC students. It is on all the many Sun workstations around the campus (in a form called SunOS) and it runs (in a freely distributed form called NetBSD) on many of the IBM PC-compatible microcomputers in the computer labs. It is also found (in a form known as Irix) on the Silicon Graphics workstations in some of the campus labs. The freely distributed form known as Linux is found on many of the machines in several departments (Linguistics, Physics). The operating system (OS X) which ships with Apple Macintosh computers uses a variety of BSD-based Unix.

While Unix comes in many flavors, what we will actually be studying for the most part will be the C shell command language (to which in this course we traditionally give the whimsical name "Cshellese") as implemented in the software making up the SunOS operating system that runs on the the machines unix1 and unix2. To a large extent the material covered will be highly adaptable to many other systems, including non-Unix systems; for example, material on files, directories, and pathnames is of immense importance in dealing with any kind of computer system (even though directories are sometimes called folders and pathnames are sometimes not referred to as such). But just occasionally there will be points of difference and detail, and there it will always be the version of SunOS installed on unix1 and unix2 that is definitive for purposes of this course (found under the address unix.ucsc.edu or unix.ic.ucsc.edu). For this reason, all work should be checked, if not done, on these machines. If you want to work on your own version of Linux or FreeBSD, that's fine, but make sure that you check to make sure that your work gives the same results when logged into unix.ucsc.edu [If this paragraph makes no sense to you, don't worry. It doesn't need to. After a week or so into the course it will make plenty of sense, and from then on you should remember it.]