All CPSC 3xx Courses Review

• CPSC 304: Introduction to Relational Databases (Rachel Pottinger/ Fall 2021)
• CPSC 310: Introduction to Software Engineering (Elisa Baniassad/ Fall 2020)
• CPSC 312: Functional and Logic Programming (Steve Wolfman/ Fall 2021)
• CPSC 314: Computer Graphics (Michiel van de Panne/ Fall 2022)
• CPSC 317: Internet Computing (Alan Wagner/ Fall 2020)
• CPSC 320: Intermediate Algorithm Design and Analysis (Patrice Belleville/ Fall 2020)
• CPSC 322: Introduction to AI (Jordon Johnson/ Fall 2022)
• CPSC 340: Machine Learning and Data Mining (Mike Gelbart/ Fall 2021)

Note: Its funny that I took all of these classes in the fall term—almost as if I didn’t go to school for any of the spring terms. But I was most definitely probably just on co-op or taking CPSC 4xx courses.

As usual, I try to make these as objective as possible by keeping my opinions in the Experience section, but as an additional disclaimer, everything is based on my personal experience and opinion, so ymmv.

Also just for fun, I wanted to summarize all my ratings for these courses by some means, and what better way than making a big buble chart? This graph shows my ratings of all the classes in terms of their respective Interest (X), Difficulty (Y) and Workload (bubble size). I also added a few non-third year courses for comparison.

Note: I was reading Factfulness by Hans Rosling at the time, which inspired me to make this

Note: The size of the bubble represents the 3rd dim->workload

CPSC 304: Introduction to Relational Databases

Introduction

All things database related, including entity-relationship/ER models (diagrams that define the data stored in relational databases), database design and normalization, relational query language, SQL, data warehouses and data mining.

The course also includes a project in a team of 3, where you you design a database schema for a real world entity (e.g., school, library), from drafting the database schema diagram, to creating the tables and inserting dummy data, to creating a backend to query the database.

Lecture Topics

• ER diagrams
• database schema normalization, functional dependencies
• relational algebra
• SQL queries
• data warehousing and data mining

Coursework

• database project with 6 milestones
• 2 midterms + final exam
• in class exercises

Project

The project was only worth 25%, and accordingly, it’s not a big or difficult portion of the class, but it does take some time to complete and discuss with your team.

We began by choosing a real-world database application, for example a library management system that keeps a books catalogue, users, each users’ borrowed books and due dates, etc. This also included drawing the ER diagram, where the entities and relationships of the system are modelled. Then we mapped the diagram to tables, which included deciding on keys and normalizing the tables to a standard format to reduce redundancy. Finally, we created the tables in SQL, and populated them with dummy data. I think this part of the project took the longest simply because of the number of tables and relationships.

The end product was a webpage, which allows the user to do some sample queries on the database, for example, “Insert a new book into the library”, or “Select the average cost of all the books in the library”. The backend portion consisted of creating the SQL connection and executing the queries. The webpage also has a simple HTML/CSS frontend for the user to enter a few details of their query, like the name of the new book to be inserted, and see the printed table contents after the query. This coding portion was very minimal, and mostly copying pasting from a provided template and then modifying the contents.

Tech stack

• Database: Oracle DB
• Database access: SQL plus
• backend/SQL connection: Java/JDBC or PHP
• frontend: HTML/CSS

Experience

Personally, I found the course material to be very theoretical (such as creating very complicated ER diagrams for no reason) for a course that I thought was going to be more practical. I also have a hunch that this course material may be very old and slightly outdated. With the introduction of cloud databases in AWS or Azure, I feel like Oracle DB is declining in popularity (except maybe in government and military organizations where security is a concern), and I would like to have learned about setting up a database with popular open source options like MySQL or PostgreSQL that can be deployed to the cloud.

If you already know how to do SQL queries like I did from my previous co-op, then there’s not much additional/useful/interesting takeaways from CPSC 304, and don’t think that you are obligated to take it because everyone else takes it, or says that databases skills are employable (unless you would like to be a DBA of course). Personally I found that the course clarified a few concepts of SQL queries that I found confusing previously, like complex SQL queries, but for me it wasn’t worth a whole term. But if you don’t know anything about SQL or databases, then it may be worth learning.

CPSC 310: Introduction to Software Engineering

Introduction

This class is distinctly divided into a theory and project part. The theory portion formalizes software engineering principles and methodologies; this material is covered in lectures and tested in midterms and the final exam. On the other hand for the project portion, you and your partner create a courses and rooms data query engine for UBC, written in TypeScript. The project is split into 4 checkpoints with respective deadlines, and is scored against autobot tests.

Lecture Topics

• Testing
• Development Methodology (Agile/scrum)
• User requirements/stories
• Refactoring
• REST
• Object Oriented Design Principles & Patterns (Factory, Singleton, Visitor)
• Ethics

Project

Overview

The application you build takes a query from the user and returns a list of either courses or rooms at UBC matching the query criteria. Specifically, it allows user to add datasets of either UBC courses or rooms, and then proceed to make some query like “show me all courses with an average > 60” or “show me all rooms with < 30 seats”. The program then returns a list of all courses or rooms matching the criteria. The project is done in partners, and split into 4 checkpoints: (1) writing tests, (2) backend for adding dataset and parsing query, (3) adding more advanced backend – support for rooms and transformations, (4) adding the web server and UI. Scores are evaluated by a set of tests that are automatically run on your project for each merge onto the master branch.

Tech stack

Mostly TypeScript for the backend (TypeScript is JavaScript plus object oriented features), and requests and results are in JSON. Tests are written with Mocha and Chai. The web server is written with the REST server library restify, and the frontend is in vanilla JavaScript.

Recommendations

• Start each checkpoint early if you think you need help. Piazza/office hours get really busy close to the deadline.
• A reliable partner is pretty important for this class. I thought the project workload was pretty heavy, and was barely able to finish my portion of the work on time.
• Read up on some TypeScript/JavaScript if you’ve never used a functional language before. It’s quite different from Java, Python or C/C++.

Experience

Lectures are pretty optional, since most of the information is on the slides. Midterms are true/false questions, which makes it easy if you’ve looked at the slides.

My portion of the project (add dataset) consisted of mostly asynchronous code, using promises. Considering I have no experience in neither JavaScript nor async code, this was a very difficult and daunting task in the beginning. I had no clue what I was doing with promises and TypeScript. After writing lots of code, I still had no clue I was doing, but the code works.

Overall, the project was lots of work (and will be difficult if you don’t know JavaScript or promises), but the lecture material is super easy and straightforward.

CPSC 312 Functional and Logic Programming

Introduction

This course provides an overview of 2 languages: Haskell (functional) and Prolog (logical), which are both very different from object oriented lanaugages like Java or Python. Though the emphasis is mostly focused on how to write code with these languages, the course also includes the underlying details of how they work and their potential use cases/strengths.

There is also a group project (2-4 people) where we chose either Haskell or Prolog, and created anything we’d like really, as long as it incorporates something that we explorered by ourselves that wasn’t taught in class.

Lecture Topics

• Haskell—first half of the course
• Prolog—second half of the course

Coursework

• 7 Bi-weekly quizzes ~65%
• 1 project ~20%
• no exams/midterms

Experience

Most of the course weight was on the bi-weekly quizzes, which contained either M/C questions or very short coding questions with autograder tests. Overall, these were fairly straightforward, and the course itself is not too difficult. However, I did find it hard to adjust to the way of thinking of Haskell and Prolog, and was frustrated at times because “I would be able to do this way easier in Python”, simply because I wasn’t accustomed to the properties of these languages. In retrospect, these languages are actually quite intersting as they compel your brain to think in a completely differently way about coding.

The project is much more unstructured than regular computer science class coding assignments, and more like a Hackathon project, but you can only use Haskell or Prolog. Though I was skeptical at first, I think our project turned out okay, and our team was able to build something interesting with Prolog (a grammer checker bot).

Resources

• CPSC312 W2021 Course Website

CPSC 314 Computer Graphics

Introduction

Computer Graphics are images created by computers (obviously), but these 2D computer generated images are actually constructed by manipulating 3D models of objects and then rendering them in two-dimension. For example, in video games where your character is constantly changing positions, this strategy of creating images is very useful–in fact, video games render images in real-time.

To do this, we start with our object represented as many small triangles (or rather the geometric coordinates of these triangles), and call a series of operations: 1) transform/rotate/scale the object into the desired location/orientation/size, 2) project the object onto a 2d coordinate system, 3) clip any parts of the object that lie outside our camera’s field of view, and 4) interpolate color for each pixel in a triangle via rasterization. The result is a color value for each pixel in the final image, and this process is referred to as the graphics pipeline.

Of course, there are many subtle complexities in the graphics pipelines, including when you have many objects in a scene, and need to calculate which object is closer and therefore will cover all objects farther than it in your 2d image, referred to as occlusion. In addition, simulating lightning (i.e., adding a light source like the sun) is also challenging because light can be reflected, transmitted, or bounced off objects depending on their material. One solution for global illumination is ray-tracing, which traces light paths from the eye backwards into the scene.

Lecture Topics

• Transformations and coordinate systems
• Projection transformation
• Culling, clipping, and visibility
• Rasterization
• Texture mapping
• Lighting
• Animation (briefly)

Coursework

• ~7 assignments: 2 math, and 5 coding
• 2 quizzes
• final exam

Experience

Computer graphics mainly utilizes math topics like linear algebra and graphing to manipulate and transform scenes into images, and accordingly, the course has a lot of math. BUT the math is not very hard at all, and I think the more challenging part is actually understanding the computer graphic algorithms.

The coding portion is very fun and not too challenging either. The technologies used is three.js, WebGL, and javascript, and you get to create a scene following the assignment prompts/instructions. There are a lot of detailed instructions so its easy to follow, for example, “shade the teapot with the phong shading model”, or “rotate the skybox cube to the right orientation”. The fun part of course is watching your scene develop as your implement each step in the code.

If there is one thing I didn’t like about this course, it would be that the lectures felt kind of scattered and it can be confusing at times what is happening in class. The lecture slides are also not very helpful in the sense that they focus more on how to do the actual math, and misses the context of what the math is actually used for and where it fits within the computer graphics process. So if you miss the very brief verbal explanation in the beginning (which I probably do since I’m always late), you will be very lost the entire class what the math you are doing is actually doing.

Resources

Course website (2023)

CPSC 317: Internet Computing

Introduction

Mostly theoretical course on how the internet works, the 5 layer protocol stack, and its respective protocols, including ethernet, IP, TCP/UDP, DNS, SSH, etc. Also analyzes performance in regards to network metrics like bandwidth and latency, and covers internet security via encryption and possible cyber attacks. Includes three coding assignments related to server, client and socket programming.

Lecture Topics

• Internet Design
• IP layer (networking addressing, routing packets)
• Link layer (ethernet frames/addressing, local area networks, DHCP, ARP)
• Transport layer (TCP/UDP) and Domain Name System (DNS)
• Calculating network performance (bandwidth, latency, delay)
• Reliable data transfer (acknowledgements, sliding window and pipelines)
• Security

Coursework

• 3 programming assignments
• Weekly canvas quizzes
• 4 bigger quizzes
• Weekly tutorials

Experience

Very interesting course since I had no prior knowledge of the internet, and mostly theoretical like CPSC 313. The programming assignments are on par with CPSC 313 assignments (but there’s only 3). The coding itself is pretty straightforward, but most of the time there’s quite some ambiguity and underspecification, so I usually like to wait until others have clarified the task on Piazza to start the assignment.

Overall easy assignments, light workload and mostly theoretical material. Good course for anyone that would like to know more about the internet and server/client programming.

CPSC 320 Intermediate Algorithm Design and Analysis

Systematic study of basic concepts and techniques in the design and analysis of algorithms, illustrated from various problem areas. Topics include: models of computation; choice of data structures; graph-theoretic, algebraic, and text processing algorithms. Source: UBC SSC

I too, have no idea what this course description is saying, so putting it into words that are more understandable:

Introduction

A math and theory heavy course that focuses on algorithm design—for a problem, give a brute force solution, then create a good algorithm, and analysis—prove that your algorithm is correct, and determine the run time. We also analyze some common problem topics, such as greedy algorithms, graph problems, divide and conquer, and memoization/dynamic programming. No real programming involved, only pseudo code in coming up with algorithms, and a heck of a lot of proofs. Overall, the course provides a good starting point for more advanced leet code or interview problems. HOWEVER: even though the course covers some of the same problems in technical interviews, the aim of this course lies more in a mathematical and proof approach to solving these problems, rather than writing a working piece of code to pass your interviews.

Lecture Topics

• Designing and analyzing algorithms general steps
• Solving problems via Reduction
• Graph problems (BFS, DFS)
• Greedy Algorithms
• Divide and Conquer Algorithms, Master’s Theorem, recurrence trees
• Memoization and Dynamic Programming
• NP-completeness (reduction and proofs)

Coursework

• 5 written assignments in Latex
• 2 take home tests
• Weekly tutorials

Experience

I took this course in the online term (2020W), and it seems like it was made a lot harder than previous in person sessions. They made the midterm so difficult that the average was 18/35 or ~52% (the final was not much better). Other than the absurd difficulty of the tests, this class has a pretty light workload.

Classes contain no teaching, rather its alternating periods of you working on a worksheet in a breakout room, and the professor going over the answers. The worksheets are mostly straightforward, while the assignments take a bit more effort, though it seems like I either understand it, or not, in the latter case I proceed to write some random stuff, and hope for a lenient TA and part marks. There are also textbook readings and quizzes, but those can be done with a very quick skim.

Overall, good professor (Patrice), very difficult exams, mostly easy workload except assignments are slightly more work.

Resources

For my year, everything was on the course website.

CPSC 322: Introduction to AI

Introduction

If you’re looking for a course to learn about all the HOTEST, LATEST, AND TRENDIEST AI TECHNOLOGY, then let me tell you this course is EXACTLY THE OPPOSITE OF THAT. The Al that this course teaches must be made in the 1950’s before AI was even invented, because its essentially based on search algorithms, probability and logic. However, if you like funky search algorithms, this might be right up your alley.

If you want to learn about modern AI that is not ancient, you’re much better off taking CPSC 340 (think neural networks, although its slightly ironic that neural networks were invented in the 1940’s). I have a hunch that the lecture topics in this course is nowhere near anything slightly related to modern popular AI/machine learning technology from the last ten (or perhaps even twenty) years.

Note: I know I said opinions will be in the experience section, but I felt that this should be in the introduction very strongly.

Lecture Topics

• Search algorithms (DFS, BFS, IDS, LCFS, BestFS, A*, Branch and Bound, IDA*, Memory-bounded A*)
• Constraint satisfaction problems
• Local Search
• Planning
• Logic (propositional logic, datalog, unification)
• Probability theory (Bayesian networks, independence)
• Decision theory

Coursework

• 5 written assignments: 20%
• midterm: 30%
• final exam: 48%
• clickers: 2%

Experience

To be very honest, I found that the lectures for this class are fairly boring because the pace is pretty slow and the topics are kind of dull. In fact, I ended up not going to any of the lectures because I was so bored in class, which made it slighly challenging for me during exam week. The assignments are pretty easy and directly based on topics taught in class. There were a few search algorithms that I found pretty interesting (e.g., branch and bound, backtracking), and you get to go into depth about different search algorithms. However this course actually has a LOT of information/topics covered for some reason. Overall, its a moderately easy, slow-paced course, but contains a lot of topics/information, albeit not very useful ones.

CPSC 340 Machine Learning and Data Mining

Introduction

In this class, you can expect to learn about and implement machine learning models mostly from scratch (with provided skeleton code of course), including classifiers such as decision trees, K-means, and Naive Bayes, linear regression with different loss functions and regularization, minimization algorithms (gradient descent) and neural networks. Lectures provide the theory as well as pseudo algorithms, while the assignments are using Python to build machine learning algorithms. This course does have a lot of math, including matrix operations, taking derivatives (of matrices), statistics (probabilities, distribution), and linear algebra.

Lecture Topics

• Supervised learning: decision trees, Naive Bayes, KNN
• ML process and principles (training, testing, validation, hyperparameters)
• Unsupervised learning: K-means, Outlier detection
• Linear regression (least squares, regularization) and linear classification
• Latent factor models, principal component analysis (PCA)
• Neural networks and convolutions

Coursework

• 6 assignments in Latex—mostly code to implement and submit, ~30%
• midterm + finals

Experience

I found that this class was THE most interesting and fun 3rd year CPSC course at UBC. Lectures were great to attend because the topics are interesting and Professor Gelbart delivers them well.

Assignments are done in partners, and mostly consists of code (in Python) to implement the various ml algorithms. It also includes short answer questions, as well as math derivatives/calculations sometimes. I spent a lot more time on the earlier assignments, especially the math parts, but the assignments seemd to get easier, or maybe I got used to writing ml code, as we progressed into the course.

I think CPSC 340 is great because 1) interesting topic, 2) amazing slides, 3) great professor, 4) we got to implement parts of the machine learning models ourselves, within the provided skeleton code.

Bottom line: Would recommend 100%, even though you might not be doing ml in the future. It’s cool to see what it’s about, write some machine learning models, and learn about the applications. However you might not like this course if you don’t like theortical topics or calculus, and you should definitely be prepared to take some derivatives!

Resources

• Complete lecture recordings from 2017