Paths to Computer Science

CMSC 198C, 198D, 198E - University of Maryland, Fall 2015

This course provides a path for students with a broad diversity in backgrounds to learn programming and computer science, including those considering a computer science major. Students will learn at their own pace with a combination of technology-based and face-to-face class structure. Students will use a problem-driven approach to build complex, interactive software systems. The course includes an introduction to a wide variety of issues relating to software, including design, problem-solving, development processes, and broader issues such as security, performance, and ethics.

Syllabus: This is the course syllabus.

Restriction: Must not have completed any courses from the CMSC131-499 course range.

Prof. Ben Bederson - <my last name>
4120A McKeldin Library

Office Hours:

Prof. Bederson
4120 McKeldin
  Thursdays, 2-4pm (mostly)
Sign up here
TA Tak Yeon Lee
2118G Hornbake Library, South Wing (E-discovery lab)
  1. Enter Hornbake south wing (not library)
  2. Go through glass doors in front of elevator on 2nd floor
  3. Turn left for room 2118G
  Tuesdays, 2-4pm
Fridays, 2-4pm
No sign up necessary
TA Halley Weitzman
1112 AVW
  Mondays, 12-2pm
Wednesdays, 12-2pm
No sign up necessary
TA Nick Aversano
  On demand - email to request

Course details:

  • Enrollment limited to 100 students
  • Wednesdays, 5:45-8:15pm
    All three sections (CMSC198C, D & E) meet here at the same time and same place. Students will be grouped with other students based on where they are within the courses.
  • 1100 CCC (Cambridge Community Center)

Technology Requirements: You must bring a laptop to every class. If you would like to take the course, but do not have access to a laptop, please contact the instructor before the semester starts.

Piazza Forums: We will be using Piazza for class discussion. The system is highly catered to getting you help fast and efficiently from classmates, the TA, and myself. Rather than emailing questions to the teaching staff, please post all your questions on Piazza. You can use Piazza to post your questions publicly (which I encourage so everyone in the class can help answer), anonymously, or privately to me. Please do not use ELMS messaging which I find slow and burdonsome.

Textbook / Resources:


This is an introduction to computer science for non-majors. There are no pre-requisites except for a willingness to try something new.

This will be a problem-driven course. In this class, we will build a simulation with virtual creatures that interact with the changing environment. By building these creatures, you will learn about basic programming concepts, and about how programs interact with the real world (your creatures will be able to text you, and more!) You will learn about how computers can process textual data, simulate complex environments, and how even how computer programs can access databases and interact with the network with "client-server" systems.

You will program in Python, a widely used computer language. You will write programs that run locally on your computer, and on a server so you can interact with your programs on the web.


This class is an experiment with a new kind of course structure. It is "Mastery Based" - which means that you will need to excel at each level (by demonstrating mastery) before moving on to the next module. Thus, you will learn at your own pace.

The course is broken into three 1-credit units (one credit per course number). You must decide up front whether you want to register for 1, 2 or all 3 credits. Even though all 3 courses are listed at the same time and place, you will actually do the work sequentially. But the more credits you register for, the less time you will have per credit.

Each credit is broken up into 4 modules. Students will work at their own pace, only being allowed to move on to subsequent modules when you have mastered the current one (i.e., earned at least an A-).

Students work at their own pace. To support this, the course will be "flipped". The lectures are recorded and must be watched online before class. The class time will be for discussion, working on homework, classroom activities with other students, exams, etc.

At the end of the semester, students will have the option of getting the grade that they have earned up to that point, or taking an an incomplete with a grade penalty, and having the opportunity to continue the coursework the following semester.

These are the 3 credits, broken into 4 modules each:

CMSC 198C - Introduction to functional Python Programming CMSC 198D - Introduction to Object-Oriented Python Programming CMSC 198E - Introduction to Client Server Python Programming
1. Intro to Python 5. Classes 9. Text Processing
2. Variables and conditions 6. Interaction 10. Going Public
3. Creature Movement 7. Inheritance 11. Web Apps
4. The 2nd Dimension 8. AI Search 12. Putting it all together
Earn 1st Credit Earn 2nd Credit Earn 3rd Credit
Homework and Exams: Each module will include written homework that must be completed and mastered (i.e., earn an A) before a student can have their work for the next module graded (see "Grading" below). Each course (i.e., each credit consisting of four modules) will also include a more substantial project, weekly assessment, and an in-class mid-term that must be similarly mastered. The assessments and mid-terms are private and must not be shared or discussed outside of class in any way.

Regular exams (for the first 3 modules of each credit, except module 1 which does not have an exam) are offered every week. Midterms (for the last module of each credit) are only offered on the following dates, so plan accordingly:

  • October 7 (Updated 9/19: was Sept. 30)
  • October 21
  • November 4
  • December 2
  • December 16 (Finals week)

Special class dates:

  • Sept 24: Class optional (Yom Kippur - Professor Bederson will not be there)
  • Nov 25: Class cancelled (evening before thanksgiving)
Paper dates:
  • Oct 28 (5pm): Paper first draft due
  • Nov 4 (5pm): Peer reviews due
  • Nov 11 (5pm): Paper revision due

Collaboration Policy: You are free to talk to others, to use the web (except see below), and to ask others to help you with your homework. This is a very flexible collaboration policy because I believe that one of the best ways to learn is to do so with others. But at the same time, I want to make sure that each student understands their work. So, while it is ok to give or receive help from others in some ways, you MUST follow the following restrictions or I will consider you to be cheating and will apply the rules of academic honesty as described further below. The restrictions are:

  1. You must do all of the typing yourself. I.e., it is acceptable for other students to look at your work and give advice, but other students may not touch your computer to type, run, debug, etc. your work.
  2. You may not post your code or allow others to copy your code onto their machine.
  3. You may look at other student's code, but you may not copy it.

Exams are closed-book, but students may bring in one 8.5x11" two-sided sheet of paper with personally hand written original notes. Your name must appear prominently on the paper, and you will be expected to show the paper to the exam proctor. Because students will be doing work at their own pace, exams will be offered each class period. Exams are considered private, and may not be shared or discussed. Exams will also be designed to have variations so each student will see slightly different versions of the exam.

Grading: All grades will be posted on ELMS.

This course is structured around "mastery", which means that students can not go on from one module to the next until they have demonstrated that they have truly learned the material, which will be measured by earning at least an A- for that module's homework and exam. Similarly, students will not be able to move from one course to the next unless they have earned at least an A-. If student's work is not at an A- level, feedback will be given, and the student will be expected to refine their work responding to the feedback and resubmit. Homework will be graded and returned as quickly as possible (with a goal of 48 hour turn-around) so that students are not delayed, except that re-grades (on refined work) will be returned one week after the earlier grade.

Much of the "content" of the course will be available online through recorded video and exercises. However, attendance in class is required for discussion, working on homework, classroom activities with other students, exams, etc. In addition, students must meet with the instructor in small groups for 30 minute sessions at least once during the semester.

CMSC 198C will be graded as follows:

  • 10%: Participation
  • 5%: Meet with Instructor or TA
  • 5%: Quizzes
  • 50%: Homework
  • 30%: Exams

CMSC 198D & CMSC198E will be graded as follows:

  • 10%: Quizzes
  • 55%: Homework
  • 35%: Exams

Incompletes: At the end of the semester, you will by default get the grade you have earned to date in any of the credits (CMSC198C, D or E) for which you are registered. Alternatively, you can take an incomplete ("I") for any of those credits and continue working independently on the material up to, but no later than May 31, 2016.

If you take an incomplete, you will receive a penalty of 1% per week (computed addititively) until the credit is completed. Example: If you take an incomplete on 2 credits and complete the first credit 5 weeks after finals end, and complete the second credit 12 weeks after finals end, you will be given a 5% penalty on your course grade for the first credit and a 12% penalty on the second credit.

Writing: This course involves writing (both code and prose). You will be graded on your writing quality as well as your writing content. Good writing conveys ideas more clearly than poor writing, and the process of writing down your thoughts often helps to clarify them. Thus it is to your advantage to make the effort to organize your thoughts and write well.

Any writing that comes from anyone but you must be clearly and explicitly cited. That is, if you quote a web page, article, person, source code, or anything that you did not write yourself, you must indicate which text is a quote, and where that quote comes from.

Attendance policy: Students are required to attend the weekly 2.5 hour class session. If a student will miss class for a non-medical reason, then it must be discussed with the instructor in advance, and the instructor will make a decision on a case by case basis.

For medically necessitated absences, the student must make a reasonable attempt to inform the instructor of his/her illness prior to the class. Upon returning to the class, the student must present their instructor with a self-signed note attesting to the date of their illness. Each note must contain an acknowledgment by the student that the information provided is true and correct. Providing false information to University officials is prohibited under Part 9(i) of the Code of Student Conduct and may result in disciplinary action. The self-documentation may only be used for 1 class meeting. Any student who needs to be excused for multiple class meetings must provide written documentation of the illness from the Health Center or from an outside health care provider. This documentation must verify dates of treatment and indicate the timeframe that the student was unable to meet academic responsibilities. In addition, it must contain the name and phone number of the medical service provider to be used if verification is needed. No diagnostic information will ever be requested.

Academic Honesty: Please visit the webpage of the Student Honor Council for a detailed explanation of what constitutes academic dishonesty. Note that it includes not only cheating, fabrication, and plagiarism, but also includes helping other students commit acts of academic dishonesty by allowing them to obtain copies of your work. You are allowed to use the Web for reference purposes, but you may not copy any significant amount of code from any website or any other source (i.e., a line or two is acceptable, but a full function is not). In short, all submitted work must be your own.

Cases of academic dishonesty will be dealt with harshly. Each such case will be referred to the University's Office of Judicial Programs. If the student is found to be responsible of academic dishonesty, the typical sanction results in a special grade "XF", indicating that the course was failed due to academic dishonesty. More serious instances can result in expulsion from the university. If you have any doubt as to whether an act of yours might constitute academic dishonesty, please contact the instructor.

Course Evaluations: Your participation in the evaluation of courses through CourseEvalUM is a responsibility you hold as a student member of our academic community. Your feedback is confidential and important to the improvement of teaching and learning at the University. When it is announced, please go directly to the course evaluation website to complete your evaluations. By completing all of your evaluations each semester, you will be able to see the evaluation reports for the thousands of courses for which 70% or more students submitted their evaluations.

Disability Support Services: Any student eligible for and requesting reasonable academic accommodations due to a disability is requested to provide, to the instructor in office hours, a letter of accommodation from the Office of Disability Support Services (DSS) within the first two weeks of the semester.

Copyright: All course materials that exist in a tangible medium, such as written or recorded lectures, presentation slides, handouts and tests, are copyright protected. Students may not copy and distribute such materials except for personal use and with the instructor's permission. Course materials may also be marked copyrighted (© 2015 Bederson).

The following technical topics will be covered throughout the three courses, and will be folded in to the above modules as needed to support the simulation problem that we will build up throughout the course:

  • Programming in Python
    • Syntax
    • Basics: variables, operators, expressions, statements, functions
    • Types: Boolean, int, float, string, list, dictionary
    • Conditionals
    • Iteration
    • Functions, return values (multiple return values)
    • Classes
    • Libraries / APIs
      • Text processing, math, data structures
  • Program Design
    • Avoiding duplicated code
    • Coding style
    • Commenting
    • Variable, function names
    • Right-sizing functions
    • Separation of concerns
  • Problem solving
  • Software development
    • Debugging
    • Testing
    • Source code control
    • Collaborative development
      • Pair programming
      • Code review
  • Programming Models
    • Event-driven programming
    • Client/Server (networks, the web)
  • Software Issues
    • Security
    • Performance
  • Other
    • History
    • Ethics
    • Current events