UCR CS 61: Computer Organization & Assembly Language
Winter quarter, 2004
Lecture Schedule  
Lab Schedule  
Turnin  
Previous CS61's  
In this course we start with transistors, logic gates, latches, logic structures,
and memory circuits. We cover the von Neumann model of computing, and then use all
these tools to understand thoroughly the Instruction Set Architecture of a simple
computer, the LC-3. This leads on to assembly language programming of the LC-3.
Catalog description :
Lecture, three hours / week; laboratory, three hours / week.
Prerequisite: CS10
Class web site:
www.ilearn.ucr.edu
Enrolling in this course gives you automatic access to the
UCR "ilearn" site: your login id is the name part of your ucr
student email address, and your initial password is your Student
ID (no dashes or spaces).
ALL communication with the class (announcements, assignments,
handouts, etc.) will be via the ilearn site.
Some communications may be made only via the
ilearn site, so you are expected to check it regularly.
Instructor :
Dr. Brian Linard (blinard@cs.ucr.edu)
Office hours: Tuesday 10:00 am to 6:00 pm (by appointment)
Office:
Surge Bldg. 340.
Teaching Assistants and office hours:
Asheq Khan kasheq@cs.ucr.edu
Shalendra Chhabra schhabra@cs.ucr.edu
Kin Fai Kan kkan@cs.ucr.edu
Ya-Lee Tsai ytsai@cs.ucr.edu
Office hours held in
Surge Bldg. 282.
Lectures:
Section 001: MWF 10:10 to 11:00 am
Section 002: MWF 11:10 to 12:00 am
SPR. 2340
Labs:
Lab attendance is mandatory. Plan to stay in the lab for the entire
lab session, working on material related to this course.
Section 021 W 2:10 to 5:00 pm S171
Section 022 R 8:10 to 11:00 am S171
Section 023 R 11:10 am to 2:00 pm S171
Section 024 R 2:10 to 5:00 pm S171
Text Book:
Introduction to Computing Systems , 2nd edition, by Patt & Patel (McGraw-Hill)
ISBN 0-07-246750-9
Course grading:
Letter grades are assigned (approximately) according to the usual
90/80/70/60 scale out of 100 total course points, with 90 and
above corresponding to an A, 80 and above to a B, 70 and above to a
C, 60 and above to a D, and less than 60 to an F. +/- grades will
likely be given. A+'s will be given to students in the high 90's who
also have turned in all required material and many of the challenge
Lab excercises. The course is divided into two grading components,
combined as a weighted sum to total 100 points:
65: Theory component:
20: Quizzes/homeworks (expect a 10 - 15 min. quiz, and a
homework set, each Thursday)
20: Midterm
25: Final
35: Practical component:
10: Lab programming exercises and attendance
5: Lab practical exams
20: Take-home programming assignments (5 assignments x 4 points each)
To ensure minimum competency in successive courses requiring a
C- or better in this course, the following grading scheme will be used:
a C- minimum in both components is necessary to achieve a C-
minimum for the final course grade, regardless of the components'
weighted sum; otherwise, the final course grade will be no greater
than a D+. For example, a B in the practical component and a D in the
theory component might yield a weighted sum of a C, but would instead
result in a final course grade of D.
Approximate Time Requirements:
This is a four-unit CS course. As such, you should expect to spend
the following approximate amount of time:
3 hours/week in lecture
3 hours/week in lab
5 to 10 hours/week doing individual study (readings,
homework, programming, lab preparation, etc).
Please don't underestimate the time you will need to spend on this
course. These are real time amounts spent by average successful past
students. Computer Science and Engineering are challenging disciplines
requiring extensive time to master.
Subject to change as the quarter progresses.
Read the book before lecture! Reading ahead is one of the most effective
ways of doing better in class -- you'll be amazed how much more
comprehensible and useful the lectures will be.
- Week 1: Introduction to concepts of Computer Organization
and LC-3 Assembly language (Chap 1)
slides
             
Homework 1 Due: start of class Monday 1/12, hard copy
             
Programming assignment 1
Due: Thursday 1/15, 11 pm, electronic turnin
- Week 2: Binary arithmetic & data types (Chap 2)
slides
             
Homework 2 Due: start of class Wednesday 1/21, hard copy
             
Programming assignment 2
Due: Friday 1/23, 11 pm, electronic turnin
- Week 3: Logic operations, Boolean algebra (Chap 2)
slides
             
Hardware basics: transistors, logic gates (Chap 3)
slides
             
Homework 3 Due: start of class Wednesday 1/28, hard copy
             
Programming assignment 3
Due: Friday 1/30, 11 pm, electronic turnin
- Week 4: Logic circuits & Memory (Chap 3)
slides
             
Homework 4 Due: start of class Wednesday 2/4, hard copy
             
Programming assignment 4
Due: Saturday 2/7, 11 pm, electronic turnin
- Week 5: von Neumann model & the Instruction cycle (Chap 4)
slides
             
Homework 5 Due: start of class Wednesday 2/11, hard copy
             
Programming assignment 5
Due: Friday 2/13, 11 pm, electronic turnin
             
Midterm
- Week 6: LC-3 Instruction Set in detail; LC-3 data path (Chap 5)
slides
             
Homework 6 Due: start of class Wednesday 2/18, hard copy
             
Programming assignment 6
Due: Saturday 2/21, 11 pm, electronic turnin
- Week 7: Assembly Language programming: the process (Chap 7)
slides
             
Homework 7
             
Programming assignment 7
Due: Friday 2/27, 11 pm, electronic turnin
- Week 8: Assembly Language programming: i/o, traps to os, subroutines (Chaps 8/9)
Ch8 slides
Ch9 slides
             
Homework 8 Due: Wednesday 3/3, hard copy
             
Programming assignment 8
Due: Saturday 3/6, 11 pm, electronic turnin
- Week 9: Creating a Stack data structure (Chap 10)
slides
             
Homework 9
             
Programming assignment 9
Due: Friday 3/12, 11 pm, electronic turnin
- Week 10: Using Assembly language to inplement some HLL functionality (Chap 14)
slides
             
Miscellaneous & Review
Subject to change as the quarter progresses.
- Week 1: Lab 1 (9/25 to 10/1):
Basic systems intro; Assembly language tools; Turnin
- Week 2: Lab 2 (10/2 to 10/8):
Using LC-3 registers; adding integers
- Week 3: Lab 3 (10/9 to 10/15): Memory addressing modes; loops
- Week 4: Lab 4 (10/16 to 10/22): Storing and retrieving data
- Week 5: Lab 5 (10/23 to 10/29): Subroutines
- Week 6: Lab 6 (10/30 to 11/5): Bit manipulation
- Week 7: Lab 7 (11/6 to 11/12): Practical 1 & Character arrays
- Week 8: Lab 8 (11/13 to 11/19): Tables
- Week 9: Lab 9 (11/20 to 11/26): Tables (continued)
- Week 10:Lab 10 (12/1 to 12/5): Practical 2 & Miscellaneous
- Material covered: Lectures do not necessarily cover all required material:
some appears in the course books and may be covered only in the
lab sessions.
- Academic dishonesty: cheating will be strongly punished
(typically with an F in the course). You can report cheating anonymously
at:
https://www.cs.ucr.edu/cheating/. Assignment submissions must
represent your original work. Copying from any sources (web, other
books, past or current students, etc.) is strictly prohibited --
learning to program requires you to learn to solve programming problems
by yourself; using existing code and other resources becomes important
later on in your studies. While discussing assignments together is
encouraged, team coding (even of pseudo-code) or letting others
see your code are specifically not allowed. Be aware that
programs are automatically compared to the current and prior quarter's
programs for plagiarism, using a sophisticated code-comparison tool
that ignores insignificant differences (like whitespace and variable
names). If you're smart enough to fool the instructors, TAs, and
code-comparison tools, you're more than smart enough to do the programs
on your own!
A couple more notes. Be aware that a subset of exams may be photocopied,
for comparison with exams submitted for regrades. Also, be aware that
lying to an instructor in order to be able to makeup a missed exam
or in other ways to obtain a better grade can be treated as academic
dishonesty. During exams, cell phones must be stored away in a
place not visible (e.g., inside a backpack).
- Final Exams are scheduled by the University, not by the
instructor, and are correlated to the course sections. What that means is
that you must take the final exam scheduled for the section you are
enrolled in.
- Regrade policy: regrade requests must be submitted in
writing and within one week of the distribution of the graded
material. The entire exam/assignment may be regraded, not just the
problem in question, so the grade may go up or down. Thus, think your
regrade requests through carefully. Grade-database errors should also
be pointed out within one week of posting.
- Final grades: Per university policy, changes to your final
grade will be made only in the event of a clerical error.
Asking your instructor how far you were from a cutoff and what
extra work you can do to improve the grade is not appropriate.
- Switching/adding/dropping lab and lecture sections: all
add, drop, and section changes of all lower division Computer Science
courses, after the period when students can do so electronically is over,
are done through the College of Engineering's Student Affairs
office. Neither the instructors nor the CS department itself can sign any
add/drop forms, nor can they arrange for section changes. Please go to
Student Affairs, Bourns Hall A159, for any such changes.
- Communicating with the instructors and TAs: when sending
electronic mail to the instructors or TAs, please include your
full name, student ID number, and UCR email
address, so that we may properly identify you (remember, many
students have similar names). Also, please try to be polite and
use reasonable grammar and formatting.
- Cell phones: During lectures and lab sessions, please
turn off your cell phone.
- Homework and lab reports: All turned-in assignments
will be turned in electronically.
Each file should be headed with your name, student id, email, lab
& lecture section numbers.
Also, you must include a section explaining the
design, structure, etc of your program and how it works. Comments in
source code are important, but they are
not a replacement for an explanatory section. Please
remember that successfully writing a computer program that compiles and
runs correctly is not something anyone can do in just a few minutes,
even when it looks easy. Debugging typically takes three times
longer than figuring out how to write your program. So don't leave
your programming assignments to the last minute!
- Reading: Read the current book sections before coming
to lecture, and attend all lectures in their entirety. To encourage these
important college study habits, we may give a few simple pop quizzes
during the quarter, at any time during lecture.
- Students are required to stay the full three hours of lab session
every week. You'll have Lab exercises, discussions, and possibly
practical exams. Work ahead or on extra course-related material if you
finish early.
- During lab discussion time, students should not use the computers.
Ideally, students would move their chairs to the whiteboard area.
- Prepare for lab before arriving.
- To reduce disruptions and provide for the best educational
environment, all persons in lab during scheduled lab time
should be formally registered in that section. In general, no
swapping sections and no unregistered people in the lab are allowed,
even if there are extra computers.