Course Activities #
This course consists of six modules and three projects. A module is a week-long deep dive into a set of topics on Python programming language, software design, and tools related to software engineering (such as version control). Each module consists of a set of readings, an in-class worksheet, and a take-home assignment. Each project consists of a single, larger programming assignment that builds on concepts from the modules. For projects, you are expected to write not only code, but also tests and documentation, as you might with a real-world software product.
Below, we describe the various course activities in more detail.
While there is no “course textbook”, we will draw heavily from Think Python by Olin College’s very own Allen B. Downey. You can purchase a hard copy of the book, but it is also free to read and download in various formats linked from the book’s webpage.
For material on Git, we will mainly use the first chapters of Pro Git by Scott Chacon and Ben Straub. Like Think Python, this book is free to read and download in different formats, as found on the book’s webpage.
On occasion, we will also link to various online articles. For these articles, we will provide copies in various formats and make them available for download through Canvas.
There is a set of readings for you to complete prior to each module. Doing the readings before coming to class, or at least skimming them, is quite important: our in-class time will be spent building on concepts presented in the reading, and if you haven’t done the reading at all, you may not be able to follow the discussion (e.g., if you missed a term defined in the reading). To help you get a sense of what to know in the reading before class, we may have some reading quizzes due along with the reading.
In-Class Time and Worksheets #
In-class time is a synchronous session with everyone that is designed to solidify your understanding of course concepts. This will be done through “lectures”, in-class problems, and small-group discussions. We do not take attendance in class, but you are strongly encouraged to attend, as synchronous interaction with the teaching team and your classmates is a key part of solidifying your understanding of the course concepts.
We use the term “lectures” (in quotes) because they are rather restricted in scope: we may spend time going over the answers to assignment questions, demonstrating the use of certain software tools, or doing live coding while fielding questions. We expect that these activities will be relatively short in time, and the majority of in-class time will be spent doing problems and having discussions.
In each module, we will go through a worksheet in class, consisting of problems and discussion prompts. Students will be divided into small groups and collaborate on a worksheet. Worksheets are graded on engagement/completion, and will often contain problems that highlight common techniques or mistakes in programming and software design, and will be useful in thinking about problems in the assignments. Typically, we will go through a worksheet together, taking some time to work on a problem and then regrouping to discuss thoughts on the prompt.
Each module contains an assignment that tests your understanding and application of the module concepts. These concepts are not limited to technical topics - an assignment may test your understanding of proper coding style, function or program design, or the context and ethics of computing. There are seven assignments in the course, as well as an introductory assignment.
Your work on assignments will be assessed not only by correctness, but also on style. After you submit an assignment, we will run some automated tests on your code to check for correctness and style. Given these test results, your submitted code, and CA feedback, you will have the opportunity to reflect on your work and resubmit if necessary.
To help you assess your work before submission, we will also provide rubrics for each assignment that outline in detail how we calculate your score on the assignment. Where applicable, we may also provide tests to run on your code, but be aware that during grading we may run additional tests (thus passing all of the tests does not mean your code is correct).
This course has two projects (the midterm project and final project), which last for two and three weeks, respectively. These projects can be tackled in teams of 2-3 students and focus on building a single large software product that can be used and maintained in the real world. Accordingly, your project involves writing code, documentation, and tests. Each project also involves sharing your work with others through a written component (a report and website) as well as a presentation. The midterm project focuses on web scraping and data science. The final project focuses on interactivity in computing.
Before beginning a project, we will distribute a description document containing the topic, requirements, and grading criteria of the project. You are encouraged to read this document before the project kickoff class meeting to brainstorm ideas, find project partners, and to plan out your work on the project. Each project will also have intermediate check-ins to help you scope and assess your work early.