DS210 Course Overview

About This Module

This module introduces DS-210: Programming for Data Science, covering course logistics, academic policies, grading structure, and foundational concepts needed for the course.

Overview

This course builds on DS110 (Python for Data Science). That, or an equivalent is a prerequisite.

We will cover

  • shell commands
  • git version control
  • programming languages
  • computing systems concepts

And then spend the bulk of the course learning Rust, a modern, high-performance and more secure programming language.

Time permitting we dive into some common data structures and data science related libraries.

New Last Semester

We've made some significant changes to the course based on observations and course evaluations.

Question: What have you heard about the course? Is it easy? Hard?

Changes include:

  1. Moving course notes from Jupyter notebooks to Rust mdbook
  2. Addition of in-class group activites for almost every lecture where you can reinforce what you learned and practice for exams
    • Less lecture content, slowing down the pace
  3. Homeworks that progressively build on the lecture material and better match exam questions (e.g. 10-15 line code solutions)
  4. Elimination of course final project and bigger emphasis on in-class activities and participation.

Teaching Staff and Contact Information

See B1 Course Staff.

Course Logistics

See Lectures and Discussions.

Course Websites

See welcome email for Piazza and Gradescope URLs.

  • Piazza:

    • Lecture Notes
    • Announcements and additional information
    • Questions and discussions

  • Gradescope:

    • Homework
    • Gradebook

  • GitHub Classroom: URL TBD

Course objectives

This course teaches systems programming and data structures through Rust, emphasizing safety, speed, and concurrency. By the end, you will:

  • Master key data structures and algorithms for CS and data science
  • Understand memory management, ownership, and performance optimization
  • Apply computational thinking to real problems
  • Develop Rust skills that transfer to other languages

Why are we learning Rust?

  • Learning a second programming language builds CS fundamentals and teaches you to acquire new languages throughout your career
  • Systems programming knowledge helps you understand software-hardware interaction and write efficient, low-level code

We're using Rust specifically because:

  • Memory safety without garbage collection lets you see how data structures work in memory (without C/C++ headaches)
  • Strong type system catches errors at compile time, helping you write correct code upfront
  • Growing adoption in data science and scientific computing across major companies and agencies

More shortly.

Course Timeline and Milestones

  • Part 1: Foundations (command line, git) & Rust Basics (Weeks 1-3)
  • Part 2: Core Rust Concepts & Data Structures (Weeks 4-5)
  • Midterm 1 (~Week 5)
  • Part 3: Advanced Rust & Algorithms (Weeks 6-10)
  • Midterm 2 (~Week 10)
  • Part 4: Data Structures and Algorithms (~Weeks 11-12)
  • Part 5: Data Science & Rust in Practice (~Weeks 13-14)
  • Final exam during exam week

Course Format

Lectures will involve hands-on practice. Each class includes:

  • Interactive presentations of new concepts
  • Small-group exercises and problem-solving activities

Because of this active format, regular attendance and participation is important and counts for a significant portion of your grade (15%).

Discussions will review and reinforce lecture material through and provide further opportunities for hands-on practice.

Pre-work will be assigned before most lectures to prepare you for in-class activities. These typically include readings plus a short ungraded quiz. The quizz questions will reappear in the lecture for participation credit.

Homeworks will be assigned roughly weekly before the midterm, and then longer two-week assigments after the deadline, reflecting the growing complexity of the material.

Exams 2 midterms and a cumulative final exam covering theory and short hand-coding problems (which we will practice in class!)

The course emphasizes learning through practice, with opportunities for corrections and growth after receiving feedback on assignments and exams.

More course policies

Let's switch to the syllabus to cover:

  • grading calculations
  • homeworks
  • deadlines and late work
  • collaboration
  • academic honesty
  • AI use policy discussed after class activity
  • attendance and participation
  • regrading
  • corrections

In-class Activity

AI use discussion (20 min)

Think-pair-share style, each ~6-7 minutes, with wrap-up.

See Gradescope assignment. Forms teams of 3.

Round 1: Learning Impact

"How might GenAI tools help your learning in this course? How might they get in the way?"

Round 2: Values & Fairness

"What expectations do you have for how other students in this course will or won't use GenAI? What expectations do you have for the teaching team so we can assess your learning fairly given easy access to these tools?"

Round 3: Real Decisions

"Picture yourself stuck on a challenging Rust problem at 11pm with the midnight deadline looming. What options do you have? What would help you make decisions you'd feel good about? What would you do differently for the next homework?"

AI use policy

You are allowed to use GenAI (e.g., ChatGPT, GitHub Copilot, etc) to help you understand concepts, debug your code, or generate ideas.

You should understand that this may may help or impede your learning depending on how you use it.

If you use GenAI for an assignment, you must cite what you used and how you used it (for brainstorming, autocomplete, generating comments, fixing specific bugs, etc.).

You must understand the solution well enough to explain it during a small group or discussion in class.

Your professor and TAs/CAs are happy to help you write and debug your own code during office hours, but we will not help you understand or debug code that is generated by AI.

For more information see the CDS policy on GenAI.

How to Do Well in the Course

  • All the usual advice about attending lectures and discussions, engaging, etc..

Insiders tips on how to do well in this particular course:

  • Do the pre-work/pre-reading before lecture so you are seeing the concepts for a second time in the lecture.
    • Actively engage in the pre-reading... try executing the code and making changes
  • Do as much Rust coding as you can.. preferably 15-30 minutes per day
    • Learning a programming language is like learning a human language, or learning and instrument or training for a sport... you need to practice regularly to get good at it.
    • Exams are paper and pencil, so you need to write code quickly from memory.
  • Use in-class activities and homework to practice for the exams... try to do as much of it as possible without autocomplete and AI assistance.

Intro surveys

Please fill out the intro survey posted on Gradescope.