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.
Professor
Professor Michael Guerzhoy
Michael Guerzhoy (pronounced “GER-joy”, with a hard “g”, and with the “j” pronounced like the “s” in “measure”) is teaching both ESC180 and ESC190 this year. He graduated with an honours bachelor of science from the University of Toronto in computer science, mathematics, and statistics. He went on to earn a master’s degree in both computer science and statistics. Following this, Professor Guerzhoy remained at the University of Toronto to teach several courses, before moving to Princeton University where he worked as a lecturer in the Center for Statistics and Machine Learning. In 2021, he returned to U of T to teach computer science in Engineering Science.
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 some programming competitions hosted by Prof. Guerzhoy!
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 professor will explain programming concepts and go through example code. Ensure that you attend every lecture, because there will be multiple 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 are 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 track a fictional person’s physical activity and happiness levels or 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 on Gradescope 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 arrays 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.
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.
Python is a very popular language and there are countless free resources to help you along. In addition, Professor Guerzhoy posts his lectures on his 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.
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).