Scientific Programming 1

Spring 2022

Welcome to this programming course! In the weeks ahead, you’ll use the Python programming language while learning to solve scientific problems from several fields of science. This course is intended for students who have no experience in programming at all. It comprises four modules, wherein you learn about the Python language, but foremost about strategies you can use to solve complex computational problems.


Simon Pauw

Iris Luden

Daan Moll

Martijn Stegeman

If you have practical matters that you would like to discuss, always send an e-mail to the staff via We will answer within a couple of days, if not hours.

Getting started

Your entry to the course is the sidebar, where you can leaf through all modules (levels) that you have to complete.

  1. Read more of the syllabus, below.
  2. Install Python.
  3. Choose one of the level 1 modules (Algorithms or Numbers) to get started!


This course assumes no prior programming experience. If you have already done a course in Python, or if you have extensive experience in another programming language, this course might not be your best option—but we’re happy to refer you to other courses if you’d like!

Other than that, some modules assume high school mathematics or physics, but many do not. If you feel overwhelmed, don’t hesitate to contact the course staff! We can explain the course’s philosophy and requirements, and make recommendations on how to approach problems.


This really is a beginner’s course. We will teach you the basics of Python programming as well as several different ways of solving computational problems. After this course, we envision that you:

  • can transform the description of a simple algorithm into working code by combining basic program elements
  • can apply several scientific programming techniques from different areas of study
  • can use a couple of libraries in your program and know how to find and read documentation on other libraries
  • can make your programs simpler and easier to read by employing a few standard tactics
  • can trace and fix several common programming errors

When you have finished one modules for each level, you might take up Scientific Programming 2, in which we will teach you most of the remaining parts of Python, enabling you to read and contribute to other’s projects, or start your own!

Asking questions

In this course you’ll mostly work on assignments independently. But you’re not on your own! We’re here to help. There are three ways you can get help:

  • Helpdesk (Programmeerbalie): Online or on campus. Book a slot to get help
  • Lab sessions: Only on campus. Work in a classroom together with other students
  • Forum: Only online.

See for more info: Help

Passing the course

The course’s final result will be “pass” or “fail”, which means that no grades are assigned. You pass the course by:

  1. submitting sufficient coursework
  2. passing the exam


Sufficient coursework means submitting a working solution to each problem from at least four modules of your own choosing, keeping in mind that you need to finish one module per level.

You may not re-submit (variations of) solutions that you wrote for any other course’s problems. In case you have done similar assignments before, discuss with the course staff whether this is the right course for you.


Deadlines for each level are listed below. The deadlines are our recommendation. If you follow these deadlines you’ll have all the assignments finished in time for the corresponding examination moment. You can occasionally diverge a bit from the deadlines, but if you notice that you’re structurally behind please contact us (

The deadlines depend on the period in which you start the course (4, or 5) and at what pace you’re following it (4, 8 or 16 weeks).

Start block 4 (7 Feb 2022)
Finish course in: 4 weeks 8 weeks 16 weeks
Level 1 Fri 11 Feb 2022 Wed 16 Feb 2022 Tue 01 Mar 2022
Level 2 Thu 17 Feb 2022 Tue 01 Mar 2022 Fri 25 Mar 2022
Level 3 Wed 23 Feb 2022 Mon 14 Mar 2022 Thu 22 Apr 2022
Level 4 Tue 01 Mar 2022 Fri 25 Mar 2022 Wed 20 May 2022
Practice exam   Wed 30 Mar 2022  
Exam Wed 30 Mar 2022 Thu 2 Jun 2022 Thu 2 Jun 2022
Start block 5 (4 Apr 2022)
Finish course in: 4 weeks 8 weeks
Level 1 Fri 08 Apr 2022 Thu 14 Apr 2022
Level 2 Thu 14 Apr 2022 Thu 28 Apr 2022
Level 3 Thu 21 Apr 2022 Tue 17 May 2022
Level 4 Thu 28 Apr 2022 Wed 25 May 2022
Practice exam    
Exam Thu 2 Jun 2022 Thu 2 Jun 2022


The exam for this course is a programming exam. You’ll make a number of smaller programming assignments in a controlled setting. This will take about 3 hours.

  • There is one exam for the courses Scientific Programming 1 and 2. If you decide to only do Scientific Programming 1, but not follow Scientific Programming 2, please contact us to plan the examination.
  • If you do Scientific Programming 1 in 8 weeks there is a practice exam at the end of block. It s highly recommended to take this exam.
  • There is an exam at the end of each bock (block 1, 2, 4, and 5).
  • You can only participate in the exam if you finished al the assignments! If you did not finish the final assignment before the exam date, you’ll have to take the exam at the next occasion.

The dates for the exams: Wed 30 March, Thu 2 June


Programming is like writing. You can gradually learn to write programs that are more beautiful, functional, short, elegant or simple. To learn this, you’ll need some feedback, and it’s mostly up to you to get it. You can show your programs in class to fellow students or your teacher; you can post a fragment of your code on Ed and ask for advice on improving; or you can send the staff an e-mail and we’ll have a look (this might take a while though!).


No books are required for this course. Embedded in some of the modules are parts of the book Think Python by Allen Downey. If you’d like, you can read the remainder of the book on its website.

Doing your own work

This course’s philosophy on academic honesty is best stated as “be reasonable.” The course recognizes that interactions with classmates and others can facilitate mastery of the course’s material. However, there remains a line between enlisting the help of another and submitting the work of another. This policy characterizes both sides of that line.

The essence of all work that you submit to this course must be your own (unless explicitly stated otherwise). Collaboration on problem sets is not permitted except to the extent that you may ask classmates and others for help so long as that help does not reduce to another doing your work for you. Generally speaking, when asking for help, you may show your code to others, but you may not view theirs, so long as you and they respect this policy’s other constraints. Collaboration on the course’s test and quiz is not permitted at all.

Below are rules of thumb that (inexhaustively) characterize acts that the course considers reasonable and not reasonable. If in doubt as to whether some act is reasonable, do not commit it until you solicit and receive approval in writing from the course’s heads. Acts considered not reasonable by the course are handled harshly.


  • Communicating with classmates about problem sets’ problems in English (or some other spoken language).

  • Discussing the course’s material with others in order to understand it better.

  • Helping a classmate identify a bug in his or her code at office hours, elsewhere, or even online, as by viewing, compiling, or running his or her code, even on your own computer.

  • Incorporating a few lines of code that you find online or elsewhere into your own code, provided that those lines are not themselves solutions to assigned problems and that you cite the lines’ origins.

  • Reviewing past semesters’ quizzes and solutions thereto.

  • Sending or showing code that you’ve written to someone, possibly a classmate, so that he or she might help you identify and fix a bug.

  • Sharing a few lines of your own code online so that others might help you identify and fix a bug.

  • Turning to the course’s heads for help or receiving help from the course’s heads during the quiz or test.

  • Turning to the web or elsewhere for instruction beyond the course’s own, for references, and for solutions to technical difficulties, but not for outright solutions to problem set’s problems or your own final project.

  • Whiteboarding solutions to problem sets with others using diagrams or pseudocode but not actual code.

  • Working with (and even paying) a tutor to help you with the course, provided the tutor does not do your work for you.

Not Reasonable

  • Accessing a solution to some problem prior to (re-)submitting your own.

  • Asking a classmate to see his or her solution to a problem set’s problem before (re-)submitting your own.

  • Decompiling, de-obfuscating, or disassembling the staff’s solutions to problem sets.

  • Failing to cite (as with comments) the origins of code or techniques that you discover outside of the course’s own lessons and integrate into your own work, even while respecting this policy’s other constraints.

  • Giving or showing to a classmate a solution to a problem set’s problem when it is he or she, and not you, who is struggling to solve it.

  • Looking at another individual’s work during the test or quiz.

  • Paying or offering to pay an individual for work that you may submit as (part of) your own.

  • Providing or making available solutions to problem sets to individuals who might take this course in the future.

  • Searching for or soliciting outright solutions to problem sets online or elsewhere.

  • Splitting a problem set’s workload with another individual and combining your work.

  • Submitting (after possibly modifying) the work of another individual beyond the few lines allowed herein.

  • Submitting the same or similar work to this course that you have submitted or will submit to another.

  • Submitting work to this course that you intend to use outside of the course (e.g., for a job) without prior approval from the course’s heads.

  • Turning to humans (besides the course’s heads) for help or receiving help from humans (besides the course’s heads) during the quiz or test.

  • Viewing another’s solution to a problem set’s problem and basing your own solution on it.

In all cases we follow the directives regarding fraud and plagiarism of the University of Amsterdam and of the Computer Science BSc programme. Find them here in English and Dutch.


This course has been designed by Martijn Stegeman, Simon Pauw and Ivo van Vulpen.

It is partially based on many great programming resources that have been published as Open Courseware under a Creative Commons license. The resulting work itself is also published under the Creative Commons License Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. Feel free to re-use! If you would like to use the work commercially, please send an e-mail for arranging a license.

We have had lots of help from students as well as teaching assistants who tried the course or added ideas of their own. We especially thank:

  • Jelle van Assema (assignments and checkpy)
  • Tim Doolan (revisions)
  • Wouter Vrielink (revisions)
  • Natasja Wezel (videos, revisions)
  • Iris Luden (video)
  • Marianne de Heer Kloots (revisions and testing)
  • Maarten Inja (DNA assignment)
  • Quinten Post (translations)
  • Marleen Rijksen (revisions)
  • Huub Rutjes (films)
  • Vera Schild (test automation)
  • Luca Verhees (artwork “semester of code”)

We have used materials from the following sources: