CSE 374 22sp Intermediate Programming Concepts & Tools
Information and Syllabus

Logistics and Contact Information: See the main course web site www.cs.washington.edu/374/. Look there for information about the course including meeting times, staff, office hours, communications, etc. The CSE 374 Canvas pages will only be used to store lecture recordings, for links to zoom meetings (particularly office hours), and for gradebook record keeping. All other material is on the main website.

Communications: A discussion board is linked to the course home page so we can keep in touch outside of class meetings. Please participate.

You should use private messages on the discussion board to contact the staff about anything that is not appropriate for a public message, including specific questions about your assignment solutions or any personal issues that you need to discuss with the course staff.

Goals: Successful course participants will:

Prerequisite: CSE 143, i.e., intermediate programming in Java or a similar programming language up to and including implementation and use of linked data structures, including single- and double-linked lists, queues, and binary search trees.

Approximate Topics (subject to change): We will do almost all of the following, but not necessarily in this order.

  1. Files, processes, and shells (6 classes)
    1. Command-line utilities
    2. File editing
    3. Shell scripting
    4. String processing; regular expressions
    5. Web basics (http, html)
    Note: For consistency, we will all use Linux and bash. The concepts are similar for other operating systems and shells. We will use UW CSE Fedora Linux as our reference system in the few situations where it matters.

  2. C Programming (6-7 classes)
    1. Memory model
    2. Pointers
    3. Arrays
    4. Manual resource management
    5. The preprocessor
    6. Idioms for safe programming

  3. Programming tools (6 classes)
    1. Debuggers
    2. Profilers
    3. Linkers
    4. Compilation managers
    5. Version-control systems

  4. Software-engineering issues (2-3 classes)
    1. Multiperson programming
    2. Specification
    3. Testing
    4. Code-reuse patterns

  5. Concurrency (2-3 classes)
    1. Threads
    2. Races and deadlocks
    3. Locks and Transactions
    4. Message-passing

  6. Other topics as time allows

Lectures: For times and location, see the course website or the UW Time Schedule. Lectures will be recorded on using panopto. See the course canvas page for links.

Although lectures will be recorded, this class is not a distance-learning or hybrid class. Recordings are intended for review, or to help when unavoidable absences such as illness occur, not to replace class attendance. Recent experience has shown that significant numbers of students who regularly miss class struggle with the material, find it hard to keep up, and do not do as well in the course. You should plan to attend class regularly.

Text: There are two books listed for the course. The Pocket Guide is "required" - it is a concise source of information and provides a useful reference to Linux at the level you need for CSE 374 (of course you should not actually memorize all of the details in it, but you should know the main ideas). The Kernighan & Ritchie book is the classic reference on C from the people who invented the language. It is "optional", but has useful explanations and examples beyond the information presented in class or reference information available online.

Both of these books are freely available to UW students through the O'Reilly Safari books online website. See the course resources web page for a link.

See the resource page on the course web site for links to additional information.

Assignments and Computing Environment: This course is designed to give you substantial experience with programming. All of our assignments and exercises assume you will be using the current Allen School Rocky Linux environment with gcc/g++ version 9. There are two ways to do this:

Different linux distributions and linux-like systems (MacOS, for example), while fundamentally the same, have enough subtle differences in libraries and header files that code developed elsewhere has a reasonable probability of failing to work correctly when tested on CSE systems. If you do use a different system for some of your development work, you are still responsible for verifying your code works properly on our supported systems.

Grading and Exams:

In principle, all homeworks contribute equally to the assignment portion of the grade, but larger programming projects will be weighed somewhat more than others. Percentages are tentative and will be adjusted if appropriate.

We will have one midterm exam and a final exam. The dates will be listed on the course schedule, though the midterm date is subject to change (with reasonable advance notice given). The primary purpose of exams is to provide an opportunity to review and solidify understanding of course material, especially concepts that are not covered comprehensively in programming assignments.

You must complete the assignments and do adequately on the exams to be sure of passing the course. This should not be a problem if you keep up with the course and assignments.

Extra Credit Policy:

Therefore:

Late Policy: Deadlines will be given with each assignment. These deadlines are strict. It is exceedingly unlikely that skipping class or being late to class because of homework is in your interest. For the entire quarter, you may have four free "late days". You are strongly advised to save them for emergencies. You may not use more than two for the same assignment. On group projects you may only use late days if all members of the group have them available, and all members of the group will be charged for each late day used. They must be used in 24-hour (integer) chunks. This policy may not be the same as in your other classes. You are responsible for understanding it if you choose to submit late work.

However, the last couple of years have been very unusual and have been difficult for many of us in various ways. We will do our best to work with you if you are having problems, or if unexpected emergencies or illnesses occur. Please contact the course staff as soon as you can if you need help, or advice, or if there are other things we can do, especially if you find it will be difficult to meet deadlines for reasons beyond your control. We'll do what we can to work with you.

Accommodations: Please refer to the university policies regarding accommodations and religous accommodations. Those policies apply in this class as everywhere else at UW. Please contact the instructor, DRS, or the course staff as needed so we can help.

Cheating vs. Collaboration: Please see the separate discussion of Academic Integrity. You are expected to read and understand every word in that document. Ask first if you have any questions.

Collaboration is a very good thing. On the other hand, cheating is considered a very serious offense and is vigorously prosecuted. Vigorous prosecution requires that you be advised of the cheating policy of the course before the offending act.

For this course, the policy is simple: don't cheat. You know it when you're doing it. We'll recognize it when you do it. As an easy example, sharing assignment solution code with each other is cheating, as is copying homework solutions from any source. As another easy example, relying heavily on some resource (e.g., some example code you found on the Web) without attributing it in your turnin is cheating.

That said, collaborating is, for most of us, an effective way to learn. Learning isn't cheating. Helping each other write programs that are not assignments or exercises isn't cheating. Misrepresenting that you've learned something, or done the work that implies you've learned something, almost certainly is.

Reasonableness: No set of rules can apply perfectly in every setting. We will make reasonable exceptions, and in return, we expect you to be reasonable as well.

Advice: This course will expose you to a tremendous number of tools, concepts, and issues. Be warned: