CSCI 103 Fall 2017: Introduction to Programming
We are using the textbook C++ for Everyone by Cay S. Horstmann. It has been ordered to the USC bookstore, or you can order it online. Reading this book is mandatory: lectures will reinforce the material it covers, but we will assume you already have basic familiarity each week with the chapters that are required reading.
The following books ARE NOT required or directly related to our class. But we recommend them if you are looking for more reading to increase your breadth of knowledge.
- In Pursuit of the Traveling Salesman, the history, people, theory and applications for a key problem in computer science
- Logicomix, a graphic novel about computer science's history as developing from mathematical logic
- Coders at Work, a series of frank interviews with famous and historically significant programmers
- Effective Programming: More Than Writing Code, a collection of essays from a founder of StackOverflow.com
- Alan Turing: The Enigma, the authoritative biography of a key figure in early computer science
- In The Beginning, There Was The Command Line, a short book (or long essay) on open-source and corporate culture, by Neal Stephenson of Cryptonomicon fame
You need to have a laptop capable of running the class virtual machine image. Any relatively modern Windows, Mac, or Linux machine should work.
Install the virtual machine as soon as possible. See here for details.
You will need to bring your laptop to lab each week.
Bringing a laptop to lecture may be helpful but is not required (any work can be done with a partner).
If you don't have a laptop, notify your instructor.
Upon completion of this course, students will be able to:
- Understand the key hardware components in a modern computer system and how software is mapped to the hardware.
- Develop simple algorithms to solve computational problems.
- Implement key algorithms within the field.
- Understand and determine the computational complexity of simple algorithms.
- Write computer programs using conditional and iterative structures, and functional decomposition.
- Select an appropriate basic data structure (e.g. arrays) and access methods (e.g. pointers).
- Understand functional decomposition and recursion.
- Understand basic object-oriented principles.
- Create programs that utilize input/output to perform data analysis.
- Utilize Linux development tools needed to write, compile, and debug basic C++ programs.
CS 109 or EE 109 must be taken concurrently with this class, or before it.
Course website: http://bytes.usc.edu/cs103
Piazza (Q&A, discussion): https://piazza.com/usc/fall2017/csci103l
- You can ask questions, see other questions and answers, and help your classmates. There are no stupid questions!
- If you have a question about your code, don't post your code publicly on Piazza. (See Academic Honesty below.) Even privately, diagnosing code remotely is awkward. We recommend visiting office hours in-person when you think you need to show your code to course staff: this is faster and easier than trying to send us your code.
- You must use Piazza for coursework questions instead of posting to external sites like StackOverflow, Quora, etc.
Blackboard (grades for coursework will be posted here): http://blackboard.usc.edu
GitHub: we use GitHub as our login provider for this website. Please carefully and fully follow these instructions: GitHub Signup. You will demo your ability to login to this website and Piazza no later than the second lab session.
Course Components, Grading
All coursework is to be completed individually. See Academic Honesty below for more information.
|5% Homework||Short questions that serve to reinforce the reading.|
|10% Labs||Activities that take place every week and which you demonstrate Friday in your assigned lab section.|
|30% Programming Assignments||Longer tasks involving problem-solving and more complex compositions. You will submit several files that we will grade and return to you.|
|55% Exams||We will weight the better of your written and programming midterm as 20% and the worse as 10%. The final will be worth 25%.|
|94: A||82: B||70: C||56: D|
|90: A-||78: B-||64: C-||<56: F|
|86: B+||75: C+||60: D+|
No rounding of percentages will be performed. We may lower the scale if the distribution is lower than expected.
The course has the following exams.
- Written midterm exam during a quiz section (Thursday 7:00-8:30PM, 10/5)
- Programming midterm exam during a quiz section (Thursday 7:00-8:30PM, 11/2)
- Written final exam during the University final exam period (Monday 4:30-6:30 PM, 12/11)
These are short automatically-graded exercises to complement the reading. You are meant to do these while reading the textbook and to submit them before lecture to gain basic familiarity with the material. These will take place more frequently at the start of the term.
- Deadline and late policy: For full credit you must complete the homework before 11:59 PM on the indicated day. You can get half credit if you submit them late.
A lab will be posted near the beginning of each week. You will demonstrate it to a CP/TA in your assigned Friday lab section.
- Labs are not to be started in lab, rather they are to be started as early as possible on your own and then either demo'ed or debugged in the lab section.
- Deadline: We expect you to be done when there are 45 minutes remaining in your lab section, or earlier. Demo it to a TA/CP when it is complete. After everyone else has performed their first demo, you can re-demo it if time allows. No re-demos are allowed after your lab section ends, i.e. there are no late submissions.
- Office hours: You are always allowed to demo your code earlier in the week at the office hours of a TA/CP.
- Absentee policy: If you can't attend your assigned lab, demo it at office hours (see above).
- Grading: We will drop your lowest lab score. There are no late submissions.
Programming assignments are larger, more comprehensive tasks that should challenge you to integrate several programming concepts. They will be graded by course staff, based on correctness as well as style.
- Deadline and late policy: An assignment between 1 minute and 24 hours late will lose 25% of the maximum points. An assignment between 24 and 48 hours late will lose an additional 25%. After 48 hours we won't accept it. We will give each student two "grace days" (free late days) for the semester, but they may not be used to extend the 48-hour limit. (This is because of grading logistics.)
- You don't need to tell us if you use a grace day. The system figures it out automatically.
- Advice: Save the grace days for when you really need them (including travel or when other classes keep you busy). Contact us if you become very ill.
Occasionally, we make mistakes. To request a regrade: write a brief note indicating the perceived mistake by the grader, attach it to your graded work, and return it to the grader within 1 week of when the graded work was returned. After 1 week, no regrades will be accommodated.
Learning programming is a challenging and unique task. But that's why you're here. There is copious help available, make use of it!
- The People page shows the office hours of the instructors, teaching assistants, and CPs. You can go to any TA or CP office hours. We would ask that you visit your respective instructor's office hours.
- If you have a question, then probably someone else does too! We encourage you to post questions to the course Piazza forums (see link above). Someone from the course staff will answer it. Additionally, you can answer other students' questions. Other students will benefit from seeing your questions and answers. Or you can create posts that are hidden from other students.
- Feel free to send email to an instructor if need be.
All USC students are held to a high degree of academic honesty: this is to be fair to all students, but mostly, so that you actually get the intended benefits of the activities designed for you in the course.
All coursework that you submit (homework, labs, programming assignments, midterm and final exams) must be your work and yours alone. You may freely copy-and-paste any parts of the textbook and course materials when composing your work, so long as you cite them as sources. Here is a sample citation:
// next 2 lines adapted from p157 of textbook while (cin >> input) total = total + input;
You must not copy anything from other sources into your work. Additionally,
- you must not show or give your work to any student who might take CSCI 103 in the future
- you must not leave your work in a public place (website, shared folder, bulletin board, etc)
- you must not seek others' solutions (whether by internet search or asking a friend)
- you must not read any solutions (if you see one by accident, close it and report it)
- you must not lead any other student step-by-step through any coursework
- and, these restrictions continue to apply after you are finished with the course.
There are restrictions in a couple of special cases:
- If you are getting help from a CSCI 103 alumnus or a tutor, they must not be looking at their own old code while helping you. This is because we don't want you to learn at a superficial level.
- You must use Piazza for coursework questions instead of posting to external sites like StackOverflow, Quora, etc.
However, discussing the course materials with other students is encouraged when it is of a general nature, so long as the work of one student is never shared with another. For example, you may:
- discuss material from the book or lecture slides
- discuss questions of a general nature, e.g. "what is the difference between static and dynamic memory?" or "what are the parts of syntax of a for loop?"
- discuss strategies for developing and debugging, e.g. "how do you figure out what caused a segmentation fault"? (answer: use gdb)
- explain error messages, e.g. "what does the not declared in this scope error mean?" or "what is an invalid read of size 4 error in valgrind?"
- discuss the tools used throughout the course, e.g. "how do I enable debug information during compiling"?
- clarify wording in the homework, labs, or programming assignments, or draw diagrams to explain a concept
- discuss test cases, strategies and algorithms, as long as it is kept at the level of general descriptions/pseudocode rather than step-by-step instructions. E.g., "does it matter if we use static or dynamic memory?"
To repeat for emphasis, you must never show any other CSCI 103 student your code, even "just for debugging" or "just as an example," nor may you look anyone else's CSCI 103 code. Only show your code to course staff (or people who have already taken CSCI 103).
We use software that automatically searches for similarities in submitted code. It is very good at identifying when one student has copied and modified another student's code. Anything it flags will be inspected manually in detail.
Violations of the course syllabus will be reported to SJACS. Sanctions include 0 on an assignment, F in the course, and stricter punishments for repeat offenders or cheating on exams. Additionally, USC's policy is that SJACS-violating students must stay enrolled in the course and CANNOT withdraw from the course until the issue is settled.
If you have a question about what is allowed or not, ask us!
Statement for Students with Disabilities
Any student requesting academic accommodations based on a disability is required to register with Disability Services and Programs (DSP) each semester. A letter of verification for approved accommodations can be obtained from DSP. Please be sure the letter is delivered to your instructor as early in the semester as possible, and no later than two weeks before any exams.