Fall 2019
Syllabus and Course Website: https://facultyweb.cs.wwu.edu/~wehrwes/courses/csci141_19f
| CRN | Lecture | Lab (CF 162) |
|---|---|---|
| 40372 | MWF 9:00–9:50am AH 004 | M 10:00–11:50am (Kirsten Basinet) |
| 40373 | MWF 9:00–9:50am AH 004 | M 12:00–1:50pm (Rory Little) |
| 40374 | MWF 9:00–9:50am AH 004 | T 10:00–11:50am (Kirsten Basinet) |
| 40828 | MWF 9:00–9:50am AH 004 | T 12:00–1:50pm (Rory Little) |
| 41648 | MWF 1:00–1:50pm AW 210 | M 8:00–9:50am (Kirsten Basinet) |
| 41649 | MWF 1:00–1:50pm AW 210 | M 2:00–3:50pm (Eric Slyman) |
| 41650 | MWF 1:00–1:50pm AW 210 | T 2:00–3:50pm (Joseph Tully) |
| 41651 | MWF 1:00–1:50pm AW 210 | T 8:00–9:50am (Rory Little) |
Timing of office hours and mentor hours is also shown in calendar form below.
The CS mentors program provides free peer tutoring for students in the premajor classes, including CSCI 141. The mentors are available every weekday during the quarter M-F from 4:00-7:00pm in CF 162/164. Getting help from your peers can be hugely valuable, so we highly recommend checking it out!
Intended for students majoring in computer science. Basic concepts of computer programming using an object oriented programming language. Topics covered: introduction to the development environment, introduction to algorithms, elements of a programming language, including data types, packages, control structures, procedures and functions, basic input and output, arrays and records, text files, strings, variant records. Algorithm development, problem solving and software engineering are emphasized. Programming is required in implementation of concepts. Lab.
On completion of this course students will demonstrate:
We will use the following free online interactive e-textbook as a reference:
How to Think like a Computer Scientist: Interactive Edition
Grades will be calculated as a weighted average of scores on the following course components, each of which is described in more detail below:
The standard letter grade ranges apply (i.e., 90–100% is an A, 80–90% is a B, and so on). The calculated raw percentages may be curved at the instructor’s discretion, but any such curve used will not lower anyone’s grade. “+” or “-” cutoffs will be decided at the instructor’s discretion. Students who demonstrate mastery of the material will get grades in the A range, and it is my goal to give as many A’s as possible.
Approximately 5 programming assignments will be given to provide hands-on practice with the programming concepts introduced in the course. The level of sophistication in the assignments increases as the quarter progresses; later assignments will be more involved and will take most students more time to complete. Please keep this in mind when planning your time: start working on the assignments early and seek help promptly if you get stuck to make sure you have enough time to complete the assignment by the deadline. Assume each assignment will take significantly longer to complete than the previous one. To ensure you have sufficient time to complete it, the last assignment’s deadline is the Monday of the last week of classes.
The midterm exam will be in-class on Friday, October 25th and will test material covered through Monday, October 21st.
The final exam will be cumulative, but more emphasis will be placed on material covered since the midterm. Per the University Academic Policies, a student who fails to take a final examination without making prior arrangements acceptable to the instructor receives a failing grade for the course. Finals take place the same classroom as regular lectures. The final exams are scheduled as follows:
Please see the official finals schedule for authoritative details.
A great deal of pedagogical research suggests that the use of frequent, low-stakes assessments, often called “formative assessment”, is a highly effective way to improve learning outcomes. This makes sense - it gives both student and instructor the chance to check in on the student’s understanding, long before a high-stakes assessment such as an exam, so that any gaps can be addressed. We will have two types of low-stakes formative assessments in this course, detailed below.
In lectures, I will sporadically pose poll questions. These will typically be short multiple-choice questions that you’ll be given 1-3 minutes to think about. You may also be invited to discuss your answer with a neighbor and resolve any disagreements. Because some of these exercises may be difficult to do in your head, I strongly recommend that you have a writing implement and some paper to write on.
We will be piloting a system called Socrative (counter-intuitively pronounced soh-CRA-tive) to support these in-class poll questions. To answer a question, you’ll use a smartphone, laptop, or other wifi/internet-enabled device to log into socrative.com or the Socrative app and submit your answer. If you don’t have access to a smartphone or laptop that you can bring to class for this purpose, please contact me after the first lecture (this will also be announced in class). ATUS has some devices that it can lend out to students who need a device to participate in Socrative activities.
In-class polling questions will be graded on participation only - you’ll get full credit as long as you answer the question, regardless of whether you’ve answered it correctly. There is no way to make up participation credit for missed poll questions, but up to 3 days of missed in-class poll questions will not count against your grade.
After each lecture, a Question of the Day will be released as a Canvas Quiz, and you will be expected to submit your answer before the start of the next lecture. I will go over the question at the beginning of class, so no late submissions will be accepted. Half credit will be awarded for submitting an answer; the remaining credit will be based on the correctness of your answer. You are encouraged to work with your peers on these questions - the goal is to give you the opportunity to stay on top of the material and check your understanding frequently.
QOTD scoring will based on a mixture of participation (whether you submitted an answer) and correctness (whether your answer was correct). Typically, each QOTD will be worth 6 points, with 2 or 3 for participation and the remaining 3 or 4 for correctness. Your lowest 3 QOTD scores on will be dropped from consideration in your grade calculation.
Labs will provide hands-on experience in topics related to the course with the support of a TA. To get full credit for a lab activity, you must both attend lab and hand in the deliverable by the deadline (typically Friday at 10pm the week that the lab takes place). Missing a lab or attending a lab section other than the one you are registered for requires my permission, so please contact me ahead of time in case of extenuating circumstances. Barring case-by-case exceptions, if you miss lab but submit the deliverable on time you will receive half credit (i.e., your graded lab score will be multiplied by 0.5). No late labs will be accepted without explicit permission.
The Schedule section of this page will be updated as the quarter progresses with topics, links to lecture slides, code examples, readings, and links to assignment and lab handouts. I suggest bookmarking this page; if you forget the URL and need to find your way back here, you can use link on the Syllabus page in Canvas.
The CS department maintains a set of Computer Science computer labs separate from the general university labs.
CS Accounts
To log into the machines in these labs, you will need a separate Computer Science account, which you’ll need to create unless you’ve taken another CS course already. Your username will be the same as your WWU username, but you will need to activate your account and set a new password by visiting http://password.cs.wwu.edu. Note that you’ll need to do this before your first lab, since you’ll be unable to log into the computers to access a web browser until you’ve done this. An announcement about this will be made in the first and second lecture to remind you.
Lab Locations and Access
The following rooms in Communications Facility are CS Department labs: 162, 164, 165, 167, 405, 418, 420. These labs are open to all CS students (that’s you!) any time except when scheduled for a class or other activity. The complete of CS labs and their schedules can be found on the CS Support Wiki. CF 405 is never booked, so it’s always available. Labs are open 24/7, although the building locks at 11pm so you won’t be able to enter later than that.
We will use Canvas for announcements, grades, and submission of assignments and labs. Lab and assignment writeups, will be linked from both the course webpage and the corresponding assignment on Canvas. Lecture slides and readings will be posted on the course webpage only.
It is your responsibility to make sure that you promptly become aware of Canvas Announcements as they are posted; Canvas should be configured to send you an email notification by default, but if you are unsure, please come see me in office hours.
Exams will be graded and returned to you via an online tool called Gradescope. You will receive an email when midterm grades are released inviting you to log into an account that has been created for you and set a password. Thereafter, you will access your graded exams by logging into your account on http://www.gradescope.com. If you have trouble accessing Gradescope after exam grades are released, please come talk to me in office hours.
Note: The following instructions will be presented in the second lecture; you don’t need to do this ahead of time.
To log into Socrative to answer in-class poll questions:
9AM141 for the 9AM lecture section1PM141 for the 1PM lecture sectionwehrwes).This schedule is tentative and subject to change without notice. Slides, assignments, readings, etc. will be posted here throughout the quarter.
| Date | Topics | Lab | Out | Due | Suggested Readings |
|---|---|---|---|---|---|
| 9/25 | Introduction, logistics, Hello World (slides, hello.py) |
No Lab | |||
| 9/27 | Computers, Algorithms, Pseudocode (slides) |
||||
| 9/30 | Types, Function calls, Variables (slides, print_input.py, types.py) |
Lab 1 | A1 | 2.1–2.4 | |
| 10/2 | Variables, Operators, Expressions (slides) | 2.5–2.8 | |||
| 10/4 | Order of ops, Binary, Floating point (slides) | 2.9–2.11 | |||
| 10/7 | Boolean logic (slides) | Lab 2: bad_code.py, faulty_code.py broken_caluclator.py | A2 | A1 | 7.1–7.5 |
| 10/9 | Conditionals (slides, if.py, ifelse.py) | 7.4–7.7 | |||
| 10/11 | Conditionals, continued (slides, ifelse.py, sections.py, sections_elif.py, sections_refactored.py, sections_conflict.py) | 7.7–7-8 | |||
| 10/14 | While loops (slides, balance1.py, balance2.py, double.py, count.py, never.py) | Lab 3 | A3 | A2 | 8.3 |
| 10/16 | random module, For loops (slides, sum_inputs.py, rand_avg.py) | 4.1–4.3, 5.1–5.4 | |||
| 10/18 | For loops continued, turtles (slides, ranges.py, dice.py, square_for.py) | 4.4–4.7, 8.2 | |||
| 10/21 | More Turtles, Functions 1 (slides, for_quirk.py, two_turtles.py, hello_fn.py) | Lab 4 | A3 (10pm 10/21) | 6.1 | |
| 10/23 | Functions 1.5; Midterm review (slides, rectangle.py, pi.py) | ||||
| 10/25 | Midterm Exam curve.py | ||||
| 10/28 | Functions 2 - Parameters and Scope (slides, multiline.py, turtle_square_fn.py, add2.py) | Lab 5 turtleshape_test.py | Lab5 Handout; 6.2, 6.3, 6.5–6.10 | ||
| 10/30 | Functions 3 - Return values; Tuples (slides, add2.py) | A4 sierpinski.py sierpinski_test.py | Chapter 6 | ||
| 11/1 | A4; Functions 4; Tuples slides | Chapter 6; 10.26–10.28 | |||
| 11/4 | Strings 1 (slides, worksheet, remove_vowels.py) | Lab 6 (see Canvas) | 9.1–9.4, 9.6, 9.10–9.12 | ||
| 11/6 | Strings 2 (slides, worksheet, remove_comments.py) | 9.5, 9.7–9.9, 9.13–9.20 | |||
| 11/8 | String methods, comparisons, A3 review slides | 9.8, 10.1–10.7 | |||
| 11/11 | No class (Veteran’s Day) | ||||
| 11/13 | Lists (slides, fib_list.py, blackjack.py, bale.py) | A4 | 10.7–10.11, 10.16 | ||
| 11/15 | Dictionaries (slides, worksheet, worksheet.py) | 10.12–10.14, 10.17–10.25; 12.1–12.3 | |||
| 11/18 | Mutability and implications (slides, worksheet) | Lab 7 lottery.py | A5 cancer_classifier.py train test | 12.3–12.4; Chapter 10 | |
| 11/20 | Mutability and Functions (slides, worksheet, copy_list.py, z1.py, z2.py, z3.py) | ||||
| 11/22 | File Input/Output (slides, file_read.py, file_read_write.py, test.txt, test_short.txt) | Chapter 11 | |||
| 11/25 | Searching and Sorting (slides worksheet, search_sort.py) | ||||
| 11/27 | No class (Thanksgiving Break) | ||||
| 11/29 | No class (Thanksgiving Break) | ||||
| 12/2 | Evals / review quiz (slides, review_quiz.py) | Lab 8 plot_earthquakes.py earthquakes.csv earth.png words.txt | A5 | ||
| 12/4 | Review and advanced topics slides | ||||
| 12/6 | Review and advanced topics slides | ||||
| 12/9 | Final Exam (9am lecture section) 10:30am – 12:30pm | ||||
| 12/10 | Final Exam (1pm lecture section) 3:30pm – 5:30pm |
It is expected that everyone will promote a friendly, supportive, and respectful environment in the classroom, labs, and project groups. Everyone’s participation will be equally welcomed and valued.
Lecture attendance is not tracked explicitly, but no credit will be given for missed in-class poll questions. Up to 3 days of missed in-class poll questions will be excluded from your grade calculation. Lab attendance is required; if you finish the lab before the end of the lab period, you may leave early after showing your work to the TA.
You have three “slip days” that you may use at your discretion to submit programming assignments late. Slip days apply only to programming assignments and can not be applied to any other deadline. You may use slip days one at a time or together - for example, you might submit each of three assignments one day late, or submit one assignment three days late. A slip day moves the deadline by exactly 24 hours from the original deadline; if you go beyond this, you will need to use a second slip day, if available.
After your slip days are exhausted, a penalty of 10% * floor(hours_late/24 + 1) - that is, 10% per day late, will be applied.
The time of your submission will be recorded when you submit it on Canvas, so other than submitting your assignment late, you do not need to take any action to use a slip day. Your grading feedback will include a note of how many slip days have been applied.
Your programs will be graded on correctness, clarity, and efficiency (in that order).
A correct program is one that always produces the correct output for a given input. Also, a correct program does not produce unintended side-effects. The most effective way to ensure that your program is correct is to test, test, test. Test each component as you introduce it; once you are confident that a component works you can use it in other routines. Try to break your program in testing, and if you succeed, locate the bug and fix it. The better you test your program, the more likely it is to be correct - the more likely it is to be correct, the more likely you’ll earn a good score. Most of your grade will depend on the correctness of your code.
The easier it is to read and maintain your code, the easier it is to locate and remove bugs. Your program should be well organized, appropriately commented, and easy to maintain. To have a well-organized program, design your program thoughtfully and modularly. Think before you code: hacking away blindly leads to ugly, difficult-to-read code. If you do hack away, producing a functional but ugly wall of code, try to clean it up a bit. Make sure that your cleaning does not introduce new bugs.
As for comments, please follow these simple guidelines proposed by Emeritus Professor Osborne:
Your code should be efficient, in the sense that the programs you write in this class should run in a few seconds or less. If you continue on in CS, the definition of and standards for efficiency will get more rigorous; for now, just make sure your programs aren’t doing a lot of unnecessary work.
Individual programming assignments are to be completed independently. Students are welcome to discuss assignments with each other on a conceptual level, but each student should be writing their code independently and without direct help from fellow students. Sharing your code with others or looking at someone else’s code is an explicit violation of this collaboration policy. The best way to be absolutely sure you are collaborating appropriately is follow these two rules:
Automated tools will be used to check your code for plagiarism at the push of a button. They are not fooled by tricks such as changing variable naming and whitespace: in fact, hiding plagiarism is harder than doing the assignment.
All University-wide policies apply to this course, including those outlined at http://syllabi.wwu.edu. These policies cover issues including:
