99 little bugs in the code
99 little bugs
1 bug fixed, run it again
100 little bugs in the code
ESC180 is an introductory computer programming course. The course is taught with the assumption that students have no prior programming experience. Python will be the only programming language used for this course.
You’ll start by covering fundamental programming concepts, including functions, conditional statements, syntax, and loops. You’ll use these basic concepts to create simple programs, ultimately learn more advanced concepts such as Python data structures and recursion and be introduced to features of computers such as memory storage and time complexity. For assignments, you’ll be writing your own code for interesting applications, practicing the skills and theory from class.
For experienced programmers, much of this course will be repetition. For newer programmers with less experience, this course will require regular practice to build a new skill set.
Instructors

Samantha Unger
Samantha Unger is one of the course instructors for ESC180 this fall. She graduated from EngSci in the Biomedical Systems Engineering major, completing a minor in Artificial Intelligence. She is now in the middle of her PhD in Biomedical Engineering, focusing on the design of devices and algorithms for cardiovascular monitoring. She has been involved in this course as a teaching assistant since 2020.

Nhien Tran-Nguyen
Nhien Tran-Nguyen (pronounced “nee-YEN tran win”) is a PhD candidate in Biomedical Engineering and one of the course instructors for ESC180. She graduated from EngSci in the Biomedical Systems Engineering option. She then went on to complete a master’s degree in biomedical engineering, during which she developed computational models of blood flow using medical images to better understand failure in coronary artery bypass graft surgery – which is also the topic of her current PhD research. She has been a teaching assistant for ESC180/190 and other EngSci courses since 2020.
Course Highlights
- Discovering Python is not just a snake – it’s the programming language you’ll be using for this course.
- That eureka moment when your program works after you spend hours debugging it.
- Generating code that solves a big, real-life problem with very basic concepts.
- Figuring out how recursion works.
- Participating in a programming competition.
Life of an ESC180 Student
Lectures
There are typically three hours of ESC180 lectures per week. There are no tutorials, so be sure to pay attention during lecture! The instructors will explain programming concepts and go through example code. Ensure that you attend every lecture, because there will be multiple surprise quizzes throughout the semester!
Labs (Practicals)
There are no tutorials for this course. ESC180 practicals are weekly three-hour slots held in the Engineering Computing Facility (ECF). Here, you’ll work in pairs on assigned programming labs, getting feedback from TAs if needed.
Labs are released weekly, and you have three hours to complete them. You’ll be challenged to program functions that complete specific tasks. The labs can be long and difficult, but they’re very beneficial. Try to complete all of them: it’s the best way to prepare for the midterm and final exam. They’ll give you an opportunity to practice coding and build on your programming skills. All labs are graded by TAs, who are also there to help if you get stuck. Don’t be afraid to ask for help, especially if this is your first-time programming. According to the syllabus, “teams that make their best effort toward completing the lab will be awarded full credit.”
Projects
Projects are longer than labs and are typically assigned 3-4 weeks before the due date. They’re more difficult because their scope is larger. Instead of writing one standalone function, you need to write at least 4-5 functions that accomplish a broader goal. For example, you might need to build a program that predicts its opponent’s moves in a board game. You may choose to work with a partner on projects. Projects will be automatically graded based on many programming test cases.
Midterm and Exam
ESC180 usually has a midterm and a final. In these you’ll be asked both conceptual and programming questions. For questions that require you to write code, you’ll have to use pen and paper. The code you write in the exams will be more conceptually challenging, although it’ll be shorter than code from labs. The challenge is writing it quickly and without external aids. Keeping up with the labs and practicing throughout the semester will reduce your prep time and past exams are a great source of practice problems.
How to Succeed
Quick Tips & Equations
- Know your “if” statements, “for” loops, and “while” loops
- Indexing Python lists starts at 0, not 1.
- For assignments (and programming in general) ensure that you’ve thoroughly debugged and considered boundary cases. If your program produces an error on a boundary case, you’ll likely fail that case, and if your program doesn’t compile at all, you won’t receive any marks for the assignment!
More Details
We recommend starting ESC180 projects as soon as they’re released. They require a lot of thought and iteration; they cannot be completed in one go the night before the due date. You’ll need to brainstorm a solution, try it out, debug, and probably try again. Don’t be fooled by the “simplicity” of the problem statement: even if a function seems easy to write, debugging may take you several hours. While developing your solutions, test them piece-by-piece and try out different combinations of inputs so you’re confident they work.
Some experienced programmers can write their code immediately after seeing a problem. However, we recommend that beginners write an outline in pseudo-code before writing any code. Pseudo-code refers to an informal version of code, written in words explaining what your program does. Plan how your functions will interact and what they need to do to achieve your desired result. This way, you’ll avoid making mistakes, writing unnecessary code, and confusing yourself. Planning and sketching things out on paper is especially important when tackling projects.
Aside from the midterm and the final, you’ll almost always write and practice coding on an Integrated Development Environment (IDE). While you may become very good at writing, debugging and running code this way, solving problems with just pen and paper without being able to test or debug them on an IDE is a completely different experience. During labs, you may get into the habit of writing, running, and debugging code line-by-line; however, during exams, you’ll have to go through the program you have written line-by-line in your head and identify the errors yourself. It’s therefore important to practice without an IDE regularly so you’re better prepared for written assessments along with the labs and projects.
Like any other skill, it’ll take time and practice to become comfortable at programming. You’ll make mistakes and feel frustrated when you don’t know what to do. The key is regular practice. Looking at code will not be as useful as writing code on your computer. Without actual practice, it’s impossible to improve. Experimenting is the best way to learn coding. You’ll learn to use many useful methods and tools by playing around with code. Use the time during lab sessions to stay on track with the course content, rather than trying to catch up right before an assessment.
Python is a very popular language and there are countless free resources to help you along. In addition, lecture recordings will be posted after class. Content from previous iterations of the course can even be found on Professor Guerzhoy’s YouTube channel. You can watch these recordings to make up for missed classes, study for exams, or even to get a preview of what is to come to better prepare yourself. Another helpful tip is to make use of TA support during lab sessions. The TAs usually aren’t very busy in the beginning of the sessions, so they have lots of time to answer questions from things you may have seen in lecture or got stuck on during a previous week.
Beyond First Year
Through ESC180 you’ll learn how to think like a programmer. You’ll be introduced to several programming problem-solving techniques, including:
- Sequential: In basic programming, the computer follows a set of instructions one after the other. By thinking sequentially, the programmer tells the computer what information to save when moving between steps and in what order.
- Functional: You’ll often need several small, independent functions in your program that come together to solve a problem. Thus, you need to think about the individual components of your problem and how multiple smaller functions can be combined to solve it.
- Iterative: By using loops in programming, you can repeat an action as many times as you need to solve a problem. You must therefore understand how to create solutions using these iterative techniques.
- Recursive: In some cases, it’s simply impractical to solve a problem iteratively. That’s when recursion comes in handy. Recursion is a method in which you break down a larger problem into its smallest subproblem that has a direct solution. Since the solution to the larger problem depends on this direct solution of the smaller subproblem, your program breaks down the large problem, and once it finds the smallest subproblem, it works its way forwards with the solutions from each step. You’ve then found a solution!
Programming is one of the fundamental skills in science and engineering today. Many technical courses will either use programming or teach you to program, and you can always use programming to simplify calculations in assignments and labs. Many internships and jobs require programming experience, so it’s great that EngSci provides a solid introduction in first year.
Note: The course code for Introduction to Computer Programming used to be CSC180. You may still see it referred to as such on some websites (e.g. courses.skule.ca).
