URL http://www.cs.hmc.edu/~keller/cs60             Link to Instructor Feedback Form 

Harvey Mudd College, Spring 1998

Computer Science 60

Principles of Computer Science

Home Page and Reference Card

Worksheets: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ( 10 ) keywords | examples | rex | Java | HTML | RCS | Prolog | ( ISCAL )
Assignments: 1 | 2 | 3 | 4 | 5 and 6 | 7 | 8 and 9 | 10 | (11) Slides: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | Formatted
Course Goals | Catalog Description | Texts Errata | On-Line Text | problem solutions
Grading: Course | Assignments Personnel | Sample Exams
Honor Code Standard (read carefully) How to submit assignments | Late Policy
Your Directory ~/cs60: Programming Help Topic Outline

Course Personnel and Contact Information (see this web page for latest info)

Role Name Location Hours phone email
Instructor Robert Keller 242 Olin 4-5 p.m. MTuW or any
time I'm not busy
18483 keller@cs.hmc.edu
System Administrator (for
help setting passwords, etc.)
Quay Ly 101 Beckman 8-5 M-F 73485 quay@cs.hmc.edu
Secretary Nancy Mandala 240 Olin 1-5 M-F 18225 nancy@cs.hmc.edu
CS60 Help       Mail CS 60 questions to: cs60help@cs.hmc.edu
System Help (passwords, etc.)     Mail system questions to: help@cs.hmc.edu
Tutor/Grader James Benham 102 Beckman 7-11 Tu   jbehnam@cs.hmc.edu
Tutor/Grader Shantanu Bhattacharyya 102 Beckman 7-11 Mon   sbhattac@cs.hmc.edu
Tutor/Grader Kris Jurka 102 Beckman 7:30-12 Wed   kjurka@cs.hmc.edu
Tutor/Grader Levi Scoggins 102 Beckman 7-11 Thurs   lscoggin@cs.hmc.edu
Tutor/Grader Ian Weiner 102 Beckman 6-9 Wed
6-8 Sun
  iweiner@cs.hmc.edu

If none of these hours work for you, please let me know: keller@cs.hmc.edu.

Room 102 Beckman is where the X terminals connected to our machine turing are. If you don't wish to use an X terminal, you may telnet to turing.cs.hmc.edu to use it. Get acquainted with turing is a good idea, since some software we use will not be available on other machines.

Catalog Description

Introduction to principles of computer science. Algorithms, complexity analysis, data structuring, data and procedural abstraction, grammars, correctness, logic principles, processor organization, operating system concepts, programming languages, basic automata theory, and theoretical limitations.

Course Goals

To learn and apply basic principles of computer science, including software construction, hardware organization, and limitations of computers.

Texts

Lectures

The lecture period will not be devoted exclusively to lecturing. There will be worksheets and quizzes. You are encouraged to bring in questions and problems you are having.

Grading Weights

Here is how your overall grade is determined: The target isis a total of 1000 points, so each point is 0.1% of your grade. If it turns out that 1000 points are not available, each point is multiplied by a scale factor representing the ratio available/1000. This is for reference only. If you base your strategy on understanding rather than point acquisition, the points will follow.

If your final total is in the range of points your grade is
900-1000 A
850-899 A-
800-849 B+
750-799 B
700-749 B-
650-699 C+
600-649 C
550-599 C-
500-549 D+
450-499 D
400-449 D-
0-399 F
Here is how the points are approximately divided:
Assignments 500 points: individual assignments may range from 25 to 150 points
Final exam 250 points
Midterm exam 100 points
Participation, which includes worksheets, quizzes, and presence in class 150 points

The examinations are closed-book, except that, you are allowed one sheet of paper (double sided) containing your own notes. The exam emphasize conceptual understanding, rather than memorization of fine details.

Assignment Grading

There will be approximately nine graded assignments, most entailing programming. Programming assignments help drive home key working concepts and principles. Assignments vary in difficulty and will not be equally weighted. There will also be some assignments which you will not submit, but should do anyway because they will help you with other assignments. The languages for the graded assignments will probably be two in rex, three in Java, one in Prolog, and one in assembly language (ISCAL, for a simulated machine). Sufficient information about the languages will be provided to enable you to complete the assignments; you do not have to know these languages when you enter the class; however you should have some background in an imperative language such as Java, C++, or Pascal.

Here is the nominal point breakdown we use on assignments. This may vary somewhat, depending on the emphasis of the assignment.

We're sorry, but programs which do not compile will not receive any points.Thus it is always better to submit a compilable partially-correct solution than an ostensibly fully-done solution which does not compile. You are advised to work from a compiling solution toward a final solution by gradually adding features.

Remember, you can always ask about things before you submit your actual product. There is no reason to lose points on most of the above. You also lose no points or esteem for asking.

Honor Code Standard (Please read this carefully.)

Although discussion of problems with others is encouraged, programming in CS60 emphasizes individual learning, not group projects. We observe the following Standard: "You may discuss the assignment with other students. You may not share [i.e. give or receive] written work of any kind, inside or outside the course". Elaboration: In the case of programming assignments, we consider "written work" to include email, computer files, fragments of files, and printed output. In developing code for a programming assignment, you can discuss ideas with others, but discussion of ideas must not involve wholesale examination or transcription of the actual working code of others, with the exception that you may use any code explicitly provided by the instructor.

If you have any doubts about whether a form of interaction constitutes a violation of this standard, it is incumbent upon you to ask the instructor prior to the issue.

If you get significant, but legitimate, help from another, you should acknowledge it on your submission. You do not lose credit for this. It is only proper to acknowledge the other person.

How to submit assignments

To submit an assignment, run, on turing.cs.hmc.edu (and not some other machine)
cs60submit filename 

where filename is the file containing the assignment to be submitted. The file should be an non-encoded ascii file with at most 80 characters per line. The program will ask what assignment this is (a number), and then submit the assignment properly. Shortly thereafter (usually a few seconds), you will receive on turing by e-mail an exact copy of what was submitted. You must either read mail on turing or have your mail forwarded in order to get this response. You will notice that some headers are attached, containing certain essential information. These headers are commented out so that compilation of the program is not affected. If what you receive is not acceptable (e.g. becomes MIME encoded because it is more than 80 columns or contains control characters), you are responsible for noticing this immediately, correcting the file, and re-submitting it. All submissions will be kept for archival purposes, but only the latest submission before the time deadline will be graded.

To you have your mail on turing forwarded to another machine, create in your top-level directory file

.forward

which contains the address to which you wish the mail to be forwarded. If you want it forwarded and also wish to retain a copy on turing, include immediately after that address and on the same line:

, \your-login-id-on-turing

where your-login-id-on-turing is to be replaced with your login. Note that there is a comma there, and a backward-slanting slash; a forward slanting slash will not work. Do not create mail-loops by having another machine forward to turing when turing is forwarding to that machine. This eats up system resources and may cause the loss of your account.

Late Assignment Policy

Submissions are done by following the instructions above, which also establishes the time of submission. The due dates on assignments should be noted carefully. The work of an assignment should be conducted in the week or weeks before, not on the last day when there is no space for the necessary thinking. Help will be available throughout the week and is much harder to get on the last day because there are so many people who ignore this recommendation.

Amazing Grace

There is an automatic, fixed, one-day grace period on all assignments. In other words, if the due date states day N, then the assignment must be turned in before midnight on day N+1 to receive any credit. After midnight on day N+1 work you spend on the problem is for your own edification only (which is not to say that it isn't worth doing or required; you just don't get points for it then). It is best to plan to get the assignments in on the stated due date.

Your Directory ~/cs60: Getting Programming Help

You should have a directory ~/cs60 which has group access by group cs60. If not, the system administrator will create one for you. Access to this directory will thus be by you, the instructor, and the tutors, but preferrably no one else. When properly setup the directory listing, obtained by ls -l, for this directory should look like:

    2 drwxrwx--- 2 yourid cs60 512 Sep 8 20:32 cs60/

If it does not, you should execute the following command from your home directory:

    chmod 770 cs60

The purpose of this directory is to be able to get help on programs without mailing the program. Simply indicate the file name to the instructor or tutor. He or she can connect to the directory and write things there. It is not necessary that you keep all of your work accessible there, just the things on which you are currently working.

CS 60 Topic Outline

The lectures will roughly follow this outline. The progression is at the rate of about one of the numbered topics below per week. I should say that this is what I would like to do. Depending on background, some of the topics expand to longer than allocated, with the result that other topics get jettisoned or fall off the end. Please keep up on the reading without it being explicitly assigned. The notes generally expand on the lectures and discussions. But the lectures may also expand on the notes or introduce new material. More often than not, several threads will be interwoven in the lectures over a period of time, in part to emphasize the commonality of concepts from different vantage points.The actual lectures will determine points of emphasis.

1 Information structures List notation. Trees and Graphs. Abstractions. S expressions.
2 High-level functional programming Higher-order functions. Anonymous functions. Equivalences
3 Low-level functional programming Rewrite rules. Recursion. Mutual recursion. Depth-first and breadth-first search of trees and graphs. Caching.
4 Implementation of information structures Linked lists. References and pointers. Polymorphic lists.
5 States and Transitions Computation problems and models of computation. Assignment-based programs. McCarthy's transformation. Turing machines. RAM model. Arrays. Linear addressing principle.
6 Object-oriented Computing Object-orientation and data abstraction. Java objects. Inheritance. Applets. Event handling. Translating rex to Java.
7 Grammars Inductive definitions, grammars, syntax. Parsing. Evaluation.
  Mid-Term Examination Date of Mid-term: Wed., March 25, 1998 during class period
8 Proposition Logic Proposition logic and applications. Gate realizations. Physical bases for computation. Minterm expansion. Boole/Shannon expansion. Logic simplification. Hypercubes. Karnaugh maps. "Don't care" situations.
9 Predicate logic Programming in logic. Databases. Backtracking. Program specification, correctness, and verification.
10 Complexity Runtime measures. Profiling. Growth-rate comparisons. Upper bounds. "O" notation. Examples from sorting: Heapsort, radix sort. Empirical measurements. Amdahl's law. Set abstraction examples. Bit-vectors. Weighted graphs. Shortest paths.
11 Finite-State Machines Finite-state machines. Sequential logic design. Physical basis for memory. Regular expressions and finite-state machines. Computer components. Registers, buses, multiplexors, etc.
12 Stored-Program Computing Stored-program computer structure. ISC (Incredibly-Simple Computer). ISC Assembly language. Low-level implementation of recursion.
13 Parallel Computing Parallel computation. Processes. Multi-threading. Networking.
14 Limitations of Computing Finite-state limitations. Lower bounds. Incomputability. Intractability and NP-completeness. The glitch phenomenon.
  Final Examination Date of Final: Monday, May 11, 1998, 2 p.m. (per registrar)