Welcome! CSC 143 is an introductory Data Structures course designed to prepare you for advanced CS courses and early-stage software engineering roles. On paper, this class is intended to cover fundamental programming topics such as classes, interfaces, inheritance, data structures, and algorithm analysis. In practice, this class is designed to teach you to assess computing problems critically and design solutions with benefits and drawbacks in mind.
The Spring 2021 class will be Online (MW Recorded Lecture, Tues 6:30-7:30p Microsoft Teams Meeting).
Office hours are an optional space for you to raise questions; you are not required to attend.
All assignments, quizzes, and exams will be taken online.
Please watch Canvas and Piazza for the latest announcements, schedule, and meeting links. Please note all due dates will be in Pacific Time (PST).
Class policies that have been adjusted for the online-only format will be shown in orange boxes like this one.
| Week | Dates | Description | Readings | TODOs |
|---|
We will be using Piazza as our online course discussion forum. Piazza is a question-and-answer site where you can ask questions and collaborate on answers with other classmates. You should engage with Piazza every day for updates, question-answering, and class announcements. Sign up for Piazza here.
Generally, if you have a project or class question, the fastest way to get an answer is by asking on Piazza first. I will be checking Piazza daily to make announcements and provide support. If the question specifically pertains to you (i.e. grading) you may contact me over email (brian.cui@seattlecolleges.edu) and I will respond to you within 24 hours. If you don't hear back from me, please send me a reminder email.
The class will be graded out of 1000 points. Each point is worth 0.1% of your final grade, for a maximum of 100%. Every point counts!
| Category | Quantity | Value | Total |
|---|---|---|---|
| Projects | 5 | 100 | 500 |
| Exams | 2 | 200 | 400 |
| Quizzes | 20* | 5 | 100 |
| Total | 1000 |
Your grade should reflect how well prepared you are for a programming job or advanced CS courses, and will not be curved. However, there will be several opportunities for bonus points, and more than 1000 points total will be offered throughout the course.
Your final assigned grade (on a 4.0 scale, according to the Seattle Colleges Standard Grading System) is computed as the Excel formula
=ROUND(MAX(0,MIN(4,((A1-600)/10+4)/10)),1)
where cell A1 is your point total. In plain math, roundToTenth((points - 600)/100 + 0.4); 0.05 rounds up to 0.1 (advantaged). The cutoff for an A and A- are 945 and 905 points (includive), respectively. A complete mapping between score to grade can be found here.
Grades for all assignments should be expected on Canvas within a week of the original due date. If there are delays in grading, I will let you know via Piazza announcement.
Starting on the second week of class, there will be a short (typically 5-minute) closed-book Canvas quiz at the beginning of each class that that lectures, projects, or readings. You are welcome to use your laptop or smartphone to take the quiz, but access to notes or any external references are not allowed. To earn credit for the quiz, you must take the quiz in person on time. Late quizzes are not available. *If there are fewer than 20 quizzes throughout the semester, you will receive full credit (free points!) for all remaining quizzes.
Quizzes will be posted on Canvas on the day of each lecture. You may take the quiz anytime until the due date, which is usually a day or so after the quiz is made available. Quizzes will be open-book open-note.
"The readings are for your own good" -- my professor, years ago "I'll just skip the readings" -- me, years ago
Reading is often less interesting than doing when it comes to programming, so I've picked short weekly reading assignments that I hope you will find interesting and useful. Please finish reading assignments prior to the first class of the following week.
The official textbook for this class is Building Java Programs, 4th Edition by Stuart Reges and Marty Stepp. Because textbooks are needlessly expensive, the textbook is optional for the course. You may find it helpful to read the relevant chapters in advance, but I will not ask you questions based on textbook materials.
There are a total of five Java projects you will complete throughout the semester, starting with Project 0. All projects will be due on Canvas at midnight two weeks after they are assigned (except for Project 0, which is due in one week), giving you four class days to ask project questions.
Each project explores implementation and application of topics discussed in class, and are intended to be interesting challenges (instead of frustrating busywork). Every project comes with a jUnit 4 test suite (JARs included) and an autograder script that will determine your project grade, contingent on submission correctness. I reserve the right to adjust your project grade based on whether your code is correct and meets the project specifications.
Java installation and IDE setup information can be found below. The project should work for IntelliJ out-of-the-box, but you can follow these IntelliJ setup instructions if you're having trouble getting the IDE to run the project.
You are welcome to modify the test suite to your liking, however, an unmodified test suite will be run against your program. Detailed instructions for how to submit your projects can be found here.
At a bare minimum, your code must compile and successfully execute the test script to get any credit; most project starter code will not compile out-of-the-box. Submissions that are unchanged starter code do not compile, or run to completion via the run scripts are considered late until they are resubmitted and fixed. I will contact you on Canvas if this is the case.
Late submissions are immediately subject to a flat 25-point penalty, with an additional flat 25-point penalty for every 24-hour window that elapses after the original due date. Submissions over 72 hours late will receive zero credit and not be graded. There are no exceptions to this policy.
There will be two closed-book in-class pen-and-paper exams as posted on the schedule. The second exam is cumulative but will focus primarily on the second half of the course. There is no final exam during Finals period. Exams will focus on knowledge, understanding, and critical analysis, ranging from conceptual discussion to method implementation. Anything on the readings, projects, or lectures is fair game for the exam. Exams are two hours each and will feature a mixture of multiple choice, short answer, and programming.
The best way to prepare for the exam is to experiment within the programming projects. For example, try a new method implementation strategy (i.e. recursive vs. iterative), try implementing one of Java's several native Interfaces like Collection, or try rewriting projects using a different class hierarchy. Doing so will give you valuable insight into what works well and what doesn't.
Exams will be online-only Canvas exams, similar to quizzes. Exams will also be open-note and open-book; you are welcome to reference any and all class materials to assist you during the exam. Exams will have a fixed due date; you can start taking the exam and turn it in any time before the due date. You do not have to complete the exam in one sitting; Canvas will save your progress.
All programming projects in this class will use Java. Specifically, we'll be using Java SE 11 and jUnit 4. You must use the correct Java version for compatibility guarantees, however, you are welcome to develop using any OS and IDE so long as it runs the project test suite. Grading scripts are provided for both Windows (run.bat) and Mac/Linux (run.sh). When searching for Java documentation, make sure to include "11"; most search engines return SE 8 by default.
Test your Java install by running java -version and javac -version from your terminal. You should see something like the following:
briancui@X1:~$ java -version openjdk version "11.0.4" 2019-07-16 OpenJDK Runtime Environment (build 11.0.4+11-post-Ubuntu-116.04.1) OpenJDK 64-Bit Server VM (build 11.0.4+11-post-Ubuntu-116.04.1, mixed mode, sharing) briancui@X1:~$ javac -version javac 11.0.4
Git is a Version Control System for designed tracking software project development. With Git, you can commit, view, and revert changes in your project code over time like a time-travelling backup system, ensuring breaking changes are always recoverable. Furthermore, Git branching encourage experimentation and allows you to compare several active project states at once.
I strongly recommend learning Git, as it will benefit you now and forever onwards. We will explore some command-line Git during the first week of class; there are also several excellent tutorials online that will go further in depth. The GitHub for Desktop application is the fastest way to get Git configured on your machine and offers a simple Git GUI.
Use of Git is optional in this course. Projects submitted with a .git folder and an active commit history will earn +5 bonus points on each submission. Please be careful to store your online repositories as private.
In the Classroom: Be excellent to each other. Don't be afraid to interrupt and ask questions. Electronic devices are permitted for note taking, but do not be disruptive of other students' experiences. If laptops prove too distracting, I may reserve the front rows of the classroom to pen-and-paper only (and tablets, too).
Cheating and Academic Dishonesty: Please don't cheat. If you are caught cheating on any assignment, you and all other parties involved will immediately fail the course. I will be using automated diffing tools to catch potential plagiarism or excessive code-reuse between students. Do your best work and ask for help if you need it. If you don't feel like you're learning what you need to do well, let me know and I can try to improve my teaching.
Reasonable Accommodations for Religion/Conscience: Students who will be absent from course activities due to reasons of faith or conscience may seek reasonable accommodations so that grades are not impacted. Such requests must be made in writing within the first two weeks of the quarter (Seattle Colleges Policy 336).
Course and Instructor Feedback: I welcome any and all feedback you have for the course so I can make it better. You are welcome to e-mail me or speak with me in-person if you have suggestions or concerns about class policies, assignments, or exams. You may also leave anonymous (constructive) feedback on Piazza and I can address the feedback next class.