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, two quizzes, 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 is quite important: our in-class time will be spent building on concepts presented in the reading, and trying to complete a worksheet or assignment without a good understanding of the corresponding reading will likely be difficult. The concepts presented in the readings will be tested through quizzes and assignments.
There are two quizzes in each module. The first quiz of the module should be completed on your own time before the first day of the module, and tests a basic understanding of the readings (e.g., definitions and big ideas) that will be necessary to follow the in-class discussions and worksheet. The second quiz of the module will take place during in-class time, and is designed to test a deeper understanding of the module concepts that will be necessary for the assignment.
All quizzes are timed and “closed book” (including the one you do on your own). You are expected not to use any outside help or resources during a quiz. All students of this course are bound to the Olin College Honor Code, and are expected to adhere to this trust when taking quizzes.
Missing a quiz will result in no credit for that quiz. However, if you know in advance that you will miss a quiz, it may be possible for us to release the quiz to you at a reasonable time before your absence. Please contact us if you want to take a quiz in advance.
After the quiz deadline, we will spend in-class time to go over the solutions and to answer any lingering questions.
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” because they are rather restricted in scope: we may spend time going over the answers to quiz 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. While worksheets are not graded, they 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.
We anticipate that each module’s in-class time will be spent as follows:
Module Day 1
- Discussion of Module Quiz 1 solutions and lingering questions
- Worksheet problem/discussion
- (on occasion) Live demo/“lecture”
Module Day 2
- Module Quiz 2
- Discussion of Module Quiz 2 solutions and lingering questions
- (on occasion) Live demo/“lecture”
- Open hours to wok on Assignment
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 six assignments in the course, as well as an introductory assignment.
Assignments are released on the first in-class day of the module and are due six days afterwards. Since assignments typically contain five problems and deadlines are at the beginning of class, this gives you approximately one day per problem. We strongly recommend starting early and at least understanding what each problem is asking you to do, as some of the problems can be quite challenging.
Your work on assignments will be assessed not only by correctness, but also on style and a self-assessment. 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 our sample solutions, you will have the opportunity to reflect on your work through the self-assessment (even for problems you did not complete). Your self-assessment is worth a quarter of the assignment grade, and due within two days.
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 three projects, which last for one, two, and three weeks, respectively. These projects 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 an additional task, such as assessing your peers' code, presenting your work to your classmates, or presenting your work to the broader community.
Each project has a slightly different topic. Project 1 focuses on computational techniques in biology (specifically, in analyzing genetic material to find proteins). Project 2 focuses on web scraping and data science. Project 3 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 expected to have read this document before the first day of the project, and we will start our in-class time on the project answering questions about any information contained in the description document. Projects 2 and 3 will have brainstorming sessions about potential project topics, as well as midpoint check-ins. Additionally, Projects 2 and 3 can be done in a group of two or three students (Project 1 must be completed individually).