Oregon State's Online Post-Baccalaureate Computer Science Degree Program Review
I’m continuously updating this post as my schedule allows
For my first blog post ever I thought I’d take an opportunity to reflect on my experience in Oregon State’s Online Post-Baccalaurate Computer Science Degree program and review it all from the application process through graduation.”
Overview
Oregon State’s Post-Baccaluarate Computer Science Degree program is a condensed Bachelor’s degree program targeted at people who are looking to make a career change into any of the fields related to computer science and who already hold a Bachelor’s in a different discipline. The program consists of 60 total credit hours and has core classes covering discrete math, data structures, algorithms, operating systems, and more while also offering a decent spread of electives. The program is very accomodating to working professionals as the curriculum allows students to take as many as four courses per quarter (1-year completion track) or as little as one course per quarter (4-year completion track).
Application Process
The application process was very straightforward and sparked the nostalgia of being a senior in high school all over again. You’ll be asked to provide transcripts from your previous undergrad and even write a short essay, about 200 words long, about how being admitted to the program will be beneficial to you. It’s hard to say how much the essay actually matters, but show some ambition and have a friend or spouse proofread it and you should be fine. After a small application fee your application is on its way to Admissions for review.
Acceptance
I received my acceptance via email about 3 weeks later, with an actual letter arriving shortly after. I accepted and immeidately had to take a math assessment administered by the ALEKS corporation. OSU uses your score from this test to determine if you’ll need some additonal review before jumping into CS225 Discrete Math. The good news is that you only need to score a 61% to pass, the test only covers material up to Calculus I, and if you happen to fail, you can study modules provided by ALEKS in the areas you’re deficient in before taking another attempt at the exam.
Luckily enough for me, I had been doing MIT’s OCW Calculus I course for about 3 months before applying so I was decently refreshed on math that I hadn’t done in nearly a decade otherwise. I scored an 85% and waited for the final step before being able to register for classes: an online meeting with my academic advisor. After your meeting, where you’re given a general program overview, you’re given a pin and are finally able to sign up for classes.
Classes
I knew ahead of time that I wanted to complete the program in 2 years as I was going to be eligible for new orders about two and a half years after I began the program and thus needed to complete 2 courses in the fall, winter, and spring quarters and only 1 course during the summer. What follows is a quarter-by-quarter breakdown of the courses I took and my thoughts on them.
Spring 2018
CS161 - Intro to Computer Science I
This was your typical introductory class where you’re learning the ins-and-outs of a particular programming language (in this case C++), but the emphasis is mostly on the programming principles. The syllabus walked me through using the different basic data types and structures, control flow using logical operators, switch statements, and loops, object-oriented programming principles, and then on to some more complex programs where you’re programming command line versions of Battleship and Tic-Tac-Toe. A lot of these assignments weren’t terribly difficult for me because I had experience coding in C from my first undergrad degree, but for someone who has never touched code before this class would be a great introduction as it gently guides you through the shallow end of the pool as opposed to a full-on push into the deep end.
Additionally, there was one week about midway through the quarter where we were placed into groups of four and had to analyze the other members’ code for the previous week’s assignment. Despite it being a bit awkward having to critique the assignments of people you’ve likely never met face-to-face, this was a great exercise because it exposed me to new ways to solve a problem.
Also, the instructor I had for this course was great. He was incredibly helpful to the students who needed it, often staying up until the deadline (mdinight PST) to answer students’ questions about the assignment or help them troubleshoot their code.
Course rating: 8/10
CS225 - Discrete Structures in Computer Science
Welcome to most math-intensive course in the entire program, but worry not, you won’t be doing any calculations more complex than the quadratic formula. While this is very clearly a math course, it’s mostly a lot of writing proofs like the one below:
That all may look like gibberish to you (honestly it even took me a little bit to decipher everything as I’m writing this post), but the lectures and textbook do a great job of introducing the concepts to you and giving you a lot of inspiration for how to write a proof. The instructor is also a very fair grader in general. I can recall for the midterm that I was writing a proof and couldn’t remember the exact name of a logical principle, so I wrote something like this:
By the definition of a principle that I can’t remember the name of, x is in y because…
I still managed to receive full credit for that proof despite my memory lapse. Anyway, a lot of people have trouble with this course because it’s not just math, but also having to write about math. If you can get used to the process of breaking logical statements down into their components, which comes with taking good notes and doing your homework, the proofs will become a lot easier to write. That said, this course required the majority of my attention between the two this quarter. I think this was also the course I took the most notes for in the entire program, so that likely played a role.
Course rating: 8/10
Summer 2018
Summmer quarters are shorter than all of the other quarters, 8 weeks vs 10 weeks, and thus course selection is important. The workload for summer courses get condensed timelines, but assignment requirements staying roughly the same with maybe one or two that are dropped from the syllabus. Depending on the timeline you’re running on for the program, you’ll either choose to take two courses (like me), one course, or skip the quarter altogether. If you choose to take two courses, then you can reference course information published by Oregon State to determine which courses’ workloads would make them ideal pairs during a shortened quarter.
CS162 - Intro to Computer Science II
Pre-course preparation: Microsoft’s Intermediate C++ on edX. This was recommended to help with learning about pointers which is covered in the first module. I found it to be sufficient and I’d also recommend to other who have never heard of a pointer before or need review before starting the course.
CS162 picks up where 161 left off, by diving head first into the dreaded pointer. I think the topic of pointers gets overhyped to a lot of coding newbies. Yes, the concepts of passing by reference vice passing by value can be a little tricky to understand at first, as well as managing your new and delete statements for dynamic memory allocation, but if you have good attention to detail and a solid understanding of scope you’ll be able to manage just fine. Speaking of dynamic memory allocation, you’ll become very familiar with valgrind and use it to detect memory leaks in all of your assignments. In fact, you can expect to lose a significant amount of points for any detected memory leaks when the TAsPre-course preparation: run your programs.
You’ll mostly be dealing with object-oriented programming principles, like inheritance and polymorphism, but the programs begin to scale significantly as the quarter goes on. Also, the workload takes a large jump from 161 as you’ll have weekly labs, bi-weekly projects to include group and final projects, and four tests. If you were a procrastinator before this course, this would be the time to drop the habit.
As for the instructostyle=”max-height: 285px;”r, they were completely absent the entire quarter Thankfully there was a cadre of TAs that picked up the slack and were incredibly helpful.
Course rating: 7/10
CS290 - Web Development
Pre-course preparation: Colt Steele’s Web Developer Bootcamp on Udemy. Once again, highly recommended by other students who had taken the course. Tip: This udemy course, like all the rest, can regularly be had for about $10. Don’t pay full-price for any Udemy course.
I’m finally starting to branch out from command-line programs written in C++ and venture into the exciting world of web development with HTML/CSS and Javascript! The name of the course makes it sound more exciting than it actually is, as the assignments are mostly building static web pages to demonstrate different Javascript concepts, like manipulating the Document Object Model (DOM). There is no back-end development in this course, you’ll have to wait until you get to Databases to learn about that. Regardless, it’s an introductory course meant to provide the confidence needed to branch out into more robust web applications, so naturally it only scratches the surface of building a website.
I personally didn’t care for this course too much for two reasons:
-
The lecture materials provided inadequate information for understanding some of the concepts. Often times the most simple example of a concept was provided and then the assignments would ask for a much more complex problem to be solved. The topic of closures still irks me to this day for that reason. I was left with more questions than answers trying to parse useful information from the lecture video and accompanying notes.
-
The above wouldn’t be so bad if the instructor was ever around to answer questions. Unsurprisingly, this course was also being “taught” by the same instructor I had for CS 162.
I don’t want to discount the utility that this course provides in learning Javascript, but I might’ve been better served relying only on the $10 Udemy course and not paying tutition.
Course rating: 5/10
Fall 2018
CS261 - Data Structures
Now that I had cleared the introductory courses and got a couple of the 200-level courses out of the way, I finally was able to start diving into actual Computer Science with a Data Structures course. This course was taught by the same professor I had for Discrete Structures, and the syllabus was structured very similarly with homework, quizzes, and exams. I was under the impression that this course would be more theory intesive however, in addition to learning about the different types of data structures, their associated operations and time complexity, my homework assignments dealt with implementing these concepts in C.
One notable quirk of the course was that the homework assignments were actually group projects. I joined a group of guys that I had interacted with on the unofficial Slack for the program. There were 5 of us in total and one of the members had written a python script to randomly divide the homework problems among group members, with one person being tasked with the aggregation and submission of the assignment each week. Overall this was a good setup, helped in large part by our combined efforts to complete our work on time and understanding of the time commitments needed for our assignments in other courses during the quarter.
The material in general was very straightforward and not terribly difficult, however the “textbook” is really just a collection of PDF files that were written by an instructor in the program for each type of data structure, complete with crude illustrations of some of the data structures and operations being performed on them. For instance, this is the illustration for a “bag” data structure:
Additionally, a hurdle for most is learning the subtle differences of using C instead of C++. With all of this in mind, the course is run well and I felt very confident in my understanding of data structures afterwards.,
Course rating: 8/10
CS271 - Computer Architecture and Assembly Language
Pre-course preparation: Crash Course: The CPU This video series was recommended on the OSU Slack to aid with understanding how CPUs function, vital to understanding the ins and outs of assembly language. It’s free and breaks, an otherwise complex system, down into something that’s easy to understand.
Another course, another language to learn, this time however I’d be learning a low-level language, Micrsoft Macro Assembler (MASM), a type of assembly language. Assembly languages exist in-between binary and higher-level languages like C, C++, or Java. While higher-level languages are more akin to telling a computer what to do in English, low-level languages are more like telling the processor which pieces of memory to load into which registries and which operations to perform to achieve a specific result. Below is a picture of a portion of one of my assignments:
As you can see, it’s hard to determine what is going on with this program as it’s just a series of commands that load values or memory addresses into CPU registers and perform arithmatic or logical operations on the values. Thankfully you’re provided with the textbook “Assembly Langauage for x86 Processors” by Kip Irvine to help you learn what’s going on. The textbook gives you everything you need for learning the laguage, however the lecture videos are also a sufficient replacement. In fact, these lecture videos are the best you’ll find in the program. The instructor who recorded these videos explains everything in such clear detail and provides many examples to emphasize the learning objectives.
Every week you’re given a reading assigment and some lecture videos to watch, with a culminating “Summary Exercise” to complete that tests the concepts you learned. The summary exercises aren’t terribly diffcult and you can take them more than once, though the question banks are large so you likely won’t get the same questions each time. The assignments a bunch of command line programs written in assembly, and even offer extra credit with one notable caveat not found in any of the other courses: you can get additional extra credit for adding features that range from “simple” to “amazing”. At times these features can be pre-defined in the assignment specs, other times it’ll be up to the students to come up with creative features to throw in.
While I didn’t use assembly again during the program, this course provides a solid understanding of how processors and the memory stack and heap work during program execution and function calls. It’s good to know information for any programmer, but anyone looking into prenetration testing or cybersecurity would do well to pay extra attemtion as it’s beneficial for understanding buffer overflow attacks.
Course rating: 9/10
Winter 2019
CS325 - Analysis of Algortihms
Pre-course preparation: Grokking Algortihms by Aditya Bhargava Good book that helps break down the material you’ll cover using using explanations that are much less dense than CLRS, the textbook for the course, and what most might consider an essential read for any computer scientist.
As the name suggests, the goal of the course is to learn how to analyze algorithms based on their time and space complexity. This is all done with the help of the course’s textbook, Introduction to Algorithms, by Cormen, Leiserson, Rivest, and Stein or CLRS as it’s most commonly known. The book is an absolute behemoth, and while it can be rather expensive I’d recommend purchasing a copy for yourself. The workload for the class was a little on the heavier side, with multiple hour-long lecture videos to watch each week, followed by a weekly group discussion assignment that required students to make 2 posts in their respective group’s forum about the material covered that week. In theory these discussion assignments presented a great opportunity to gain some insight or truly discuss the material, but more often than not it was a last minute submission by the group members that were grasping at straws to post something that would count for full credit.
Additionally, there were weekly homework assignments that were a mix of programming and the logical proofs covered in Discrete Structures. Often times the assignment would ask for a proof outlining how to solve a problem, followed by a psuedo-code representation and analysis of the runtime in Big-O notation. The largest chunks of the final grade are the midterm and final exams, and they’re rather tough (only reasons why I ended up with a B+, and not an A). That said, the course material was very interesting and finally made me feel like a “Computer Scientist” as opposed to a coder. Some of the other topics covered include memoization, graphing algorithms, linear programming, and P vs. NP. That last topic was one of the most interesting in the course, and for the uninitiated this video does a good job explaining the finer points.
Overall, this was a good course, loaded with a lot of great information. The only complaint I have is, once again, instructor-related. The professor who made the lecture videos teaches at a snail’s pace. I mentioned that the lecture videos were an hour long most times, but that was with the playback speed set to 2x. About 45% of the videos were dead air, where they were apparently reading their notes before speaking again.
Course rating: 7/10
CS340 - Intro to Databases
This course picks up where Web Development left off, and is centered around a group project involiving building a website with Create, Read, Update, and Delete (CRUD) functionality using a SQL database, specifically MongoDB. During the first week of the course we were tasked with selecting a partner for the group project. Most times students will make arrangments with another student ahead of time on the unofficial Slack, as was my case. My partner had asked for a partner to make a beer review website with and, being that I enjoy beer, I was more than happy to join forces with them.
The course material was modeled after designing a website from scratch, where the first assignments were focused on outlining the purpose of the website, required functionality, and the datbase schema. Once our idea for a website was approved, we then began writing code for the frontend and adding the CRUD functions for each endpoint week-by-week. If there were any changes to the original plan, we simply had to explain it in our weekly project reports. In addition to our main group project, we were also placed into groups of 4, at random and not in the same groups as our project partners, to review the progress of other students’ projects.
The lecture material gives you everything you need to score 100% on the project, and the instructor also provides a GitHub repository with example code. Overall this course isn’t terribly difficult nor is it a walk in the park, it’s reliant on the diligence of your project partner. If you pick a good one then you should have few problems, otherwise you might overwhelmed if you’re lacking web development experience.
Course rating: 7/10
Spring 2019
CS344 - Operating Systems
CS361 - Software Engineering I
Summer 2019
CS362 - Software Engineering II
CS372 - Intro to Computer Networks
Fall 2019
CS370 - Intro to Security
CS493 - Cloud Application Development
Winter 2020
CS467 - Online Capstone Project