In this post: A detailed, step-by-step guide demonstrating the steps I use to solve a problem similar to one encountered in my CS 372 Intro to Networking class.
The “VOIP problem”
You’re given a diagram (you won’t need it) and some values in the form of…
Host A converts analog to digital at a = 40 Kbps
Link transmission rate R = 4.2 Mbps
Host A groups data into packets of length L = 51 bytes
Distance to travel d = 900 km
Propagation speed s = 2.5 x 108 m/s
Host A sends each packet to Host B as soon as it gathers a whole packet.
Host B converts back from digital to analog as soon as it receives a whole packet.
The question asks, How much time elapses from when the first bit starts to be created until the conversion back to analog begins?
Let’s say they want the answer in milliseconds rounded to two decimal places (note: this varies – sometimes the answer has to be in seconds, sometimes they want it rounded to one decimal place – double check your instance of the problem!)
Step 1: Figure out how long it takes to make a single packet
“When the first bit starts to be created” means “when this imaginary machine starts building the very first packet”.
We know how big a packet is: 50 bytes.
We know the rate at which it produces packets: 40 Kbps.
This is the classic L/R (length over rate) you’ve hopefully seen if you’re keeping up with the course materials. We can use L/R here, but we have to turn 51 bytes into bits (multiply it by 8) and we have to turn 40 Kbps into bps (multiply it by 1,000).
We get 0.0102 seconds because the units that R is in determines the outcome. R is in bits per second (bps), so that’s how we know the units we’re looking at here is seconds.
We need this in milliseconds, because we’re going to put everything in milliseconds so that we’re working in the units the question expects. Multiply the seconds answer by 1000 to get milliseconds, like so:
0.0102 x 1000 = 10.2 milliseconds
That’s the time it takes to make one single, complete, ready-to-transmit packet. Save this value for later, we will come back to it in step 4.
Step 2: Figure out the transmission delay
Recall from the course materials that transmission delay is the time it takes to place every bit onto the transmission medium. Transmission delay is not the time it takes to actually send it!
If you like car analogies, consider transmission delay the time it takes to get your car onto the highway. Your car is being placed on the transmission medium, and the time it takes to do that is the transmission delay. (Again, this is not the time it takes to travel the length of the highway! It’s the time it takes to get your car onto the highway.)
We will use the L/R formula again for this step. This time L is the length of the packet (51 bytes) and R is the transmission rate (4.2Mbps). We need both of them in bits, so multiply 51 (bytes) by 8 to get bits, and multiply 3.8 by 1,000,000 to get bps.
Again, the units of R determine what units the result is in, which in this case is seconds (because we had bits per second for our R).
To turn it into milliseconds, multiply by 1000:
0.00010737 x 1000 = 0.10736842 milliseconds
So, what do we have so far? We have the time it takes to make one packet and the time it takes to transmit that packet, both in milliseconds. There is one missing piece: propagation delay.
Step 3: Figure out the propagation delay
Propagation delay is the time it takes a bit to travel the given distance (900 km) at the given speed (2.5 x 108 m/s). The formula for propagation delay is d/s (distance over speed).
To go back to our car analogy, the propagation delay is the time it takes the car to zoom down the highway to its destination.
Like L/R, the d/s result will be in the same units as the bottom number (so, seconds). However, before we proceed, note that the distance we were given is in kilometers and the speed is given in meters per second. We need to convert kilometers to meters when we do our calculation, so multiply that 900 by 1,000.
(900 km * 1,000 / 2.5 x 108) = 0.0036 seconds
Remember to convert that answer to milliseconds:
0.0036 x 1000 = 3.6 milliseconds
Step 4: Add the previous three answers together
Time to generate packet + time to place it on the transmission medium + time for it to propagate = our answer
Step 5: Round to the requested number of decimal places
Since this problem wants the answer rounded to two decimal places, 13.90736842 becomes 13.91
I hope this breakdown of the “VOIP problem” helps someone else!
I have to admit I’m a bit salty this class had us sit through all those lectures, read all those book chapters, and do all those worksheets and couldn’t once be bothered to expose us to even a watered-down or partial version of it before throwing it as us on a graded, timed quiz.
Fortunately, once you’ve mastered solving this problem, a lot of the other “math problems” that CS 372 throws at you in week 1 and week 2 will feel like variations on it.
This post is part of an ongoing series recapping my experience in Oregon State University’s eCampus (online) post-baccalaureate Computer Science degree program. You can learn more about the program here.
Six-word summary: A well-designed and satisfying course
I feel like I sometimes write these recap articles to complain and warn other students of landmines, but CS475 was what every OSU online CS course should be: organized, succinct, and educational. I learned so much and enjoyed the course from start to finish.
CS475 Review
It only runs in the Spring quarters, but it’s worth holding out for! You’ll learn a lot, the material is interesting, the course is well-paced, and the exams felt fair.
I picked this class because parallel programming was something I thought sounded intimidating and was unlikely to be something I would attempt on my own. I’m very glad I chose it! It was way less intimidating than I feared, and now I feel entry-level competent in a subject I formerly knew nothing about.
Class structure
10 weeks
8 programming assignments where you code, run the code, and then write an analysis of it
I spent about 7-10 hours on this class each week, making it one of the lighter workloads in the program
Proctored midterm, proctored final
Weekly quizzes in Canvas (usually 5 questions with a full hour to answer them)
About 1-1.5 hours of video lectures each week (sadly they are without captions, but they are very high quality otherwise)
Some code is provided for you to use, saving time for focusing on what the class is really about
Instructor attends office hours! He’s really approachable, you should go even if you don’t have a specific question!
The instructor is SUPER active! You can get on a video chat with him – he’s just sitting there at pre-announced times, waiting for people to show up to his video chat room! He’ll look at your code! He’ll talk to you 1:1 about topics! I’ve never had such a productive “office hours” experience as I did in this class, and I didn’t even show up with any questions.
Contrast this with how most classes in this program hand you a problem and set you loose on figuring it yourself (via Google, Stack Overflow, old projects posted to GitHub, etc). There’s a time and a place for that, sure, but for $2000 in tuition I’m happiest when the class makes me feel like I learned something from the person teaching it. I want an experience I can’t get from Google and an independent project. I want an intelligent, skilled person to say “here’s what I know, and here’s how I think about it”and that’s how Professor Bailey ran this class.
Prof. Bailey also sends out an anonymous survey at the end of the course asking for feedback on each and every assignment as well as time spent. He genuinely cares about the class.
CS475 Project Structure
Unlike most classes, CS475 hands you some “starter code” for every assignment. You still have to put it in the right place, call it at the right time with the right data, and format and analyze the output yourself, but being provided this “starter code” was great for a few reasons:
Less time spent on things that aren’t the point of the assignment
No super fancy math skills needed (the bezier volume calculation formula is given to you, for example)
Less likely that you’ll go off into the weeds and do something ridiculously wrong and miss the point of the assignment
Less time needed overall for each assignment
This class has you throw nearly 100% of your efforts towards parallel programming related coding and analysis. For those of us with a finite number of hours in a week it was so good to just focus on the subject of the class and skip some of the boilerplate project setup. This class would pair well with another less-time consuming class, if you need (or prefer) to double up.
Most of this class’s projects go something like this: start a new C project, bring in the starter code, refactor/add to it to make it do what you need, write a bash script (or whatever you prefer) to run a loop and pass different parameters to the program each run, get all of the output in your Terminal (some people write it to a file), dump the output into a spreadsheet (I used Google Sheets), create graphs and write your analysis (in response to prompts).
Typical project output – here’s my output from Project 2
Bring these into your favorite spreadsheet software and create a pivot table. Then, generate the needed graphs for your analysis.
Somehow I made it this far in life without ever needing a pivot table. In this class, pivot tables made graphs a cinch.
And that’s pretty much how the assignments go.
I was a bit intimidated by this class before I took it. People say it’s dry and the subject has a reputation for being challenging, so I wanted to show other prospective students what’s actually involved and how approachable it really is.
Tips for CS475
NVIDIA CUDA support is limited on some versions of Mac computers. (For example, Apple just doesn’t support it for OS 10.14 at the time of this writing). If you’re on a Mac, I suggest using the school-provided rabbit server for your CUDA assignments and not wasting hours like I did trying to get it all working on a Mac.
Go to the office hours! Seriously, I went on a whim near the end of the quarter and was surprised to find myself alone in a video chat with the professor. I was just going to lurk but it ended up being a great chance to discuss a bunch of class topics one on one. Another student showed up and he stepped through her previous assignment code with her. You can’t beat the value of having an expert review your code with you!
The exams are straightforward. Some classes in this program use exams as an opportunity to test your speediness and your ability to keep track of registers through multiple iterations of multiple loops, but this class kept it fair and simple: watch the lectures, take notes, study those notes and you’ll do fine! He even gives a generous amount of time for the exams.
Overall, it’s just a high quality course. The lectures were freshly recorded, well-paced, on-topic, and relevant to the assignments and tests. The weekly assignments always looked challenging at first but were ultimately quite doable and enjoyable.
I’ve got just 4 classes left to complete my degree. I’ll be back in the fall quarter for Intro to Networks! See you all then!
This post is part of an ongoing series recapping my experience in Oregon State University’s eCampus (online) post-baccalaureate Computer Science degree program. You can learn more about the program here.
Six-word summary: Group work group work group work
In CS361 you’ll get a high level look at “real world” scheduling methodologies (mostly waterfall and agile) and you’ll work in a group with 3-4 other students to meet weekly milestones designing and implementing parts of some other student’s “Vision Statement”.
CS361 Review
You don’t have to spend long on the OSU CS subreddit to realize that virtually no one likes this class. It’s not awful, but I understand the frustrations people voice on various forums around the web.
The heavy reliance on group work was frustrating more often than not and the course materials felt dated or like they were specific to a certain industry, but I didn’t dislike this class as much as most people seem to. I think it helped that I already have design and software development experience and enjoy writing and making diagrams/mockups, so this class played to some of my strengths.
The materials that introduce common planning and scheduling techniques for software projects were a welcome inclusion – I’m glad this stuff is covered somewhere in OSU’s CS program – but I thought they didn’t go nearly in depth enough to prepare students for the realities of working on an agile team. There wasn’t enough story writing, requirements gathering, pointing exercises, or customer involvement.
I thought the weekly homework assignments were a little lackluster. Working in a group is tough even in the best situations – some parts of the homework depended on other parts being done first, and some people’s schedules didn’t seem to allow for them to start the homework early in the week.
The documents we wrote as a group seemed excessively heavy on diagrams and put too much emphasis on satisfying a very specific set of expectations. For example, there’s a lot of emphasis placed on terminology such as “functional requirements” and “functional definitions”, which I had never heard outside of this class or seen used so religiously, but the concepts they represent were familiar. That describes a lot of this class’s materials: heavy focus on overly-specific methods and terms that probably don’t translate to every industry.
Maybe the course’s materials would be improved by taking a step back from strict terminology and definitions and talking instead about how to write good step-by-step documentation, how to write a good bug, how to write a good feature design that someone else can implement from – skills that can be applied to a variety of specific methodologies, since it’s impossible to predict which ones your future company or team might be using. There are so many skills that have nothing to do with programming that programmers still need to develop, and this class could be a good place to start learning them.
Class structure
In the first week of the class, everyone in the class writes a 2000 word “Vision Statement” for a software product that solves some lofty real-world problem. Forget about making a simple app to solve a simple problem, your idea for this vision statement should be utterly epic. They are surprisingly strict about the 2000 word count, but you should be able to hit that easily by showing off your design skills and covering every topic imaginable in relation to your app idea. You really can’t write too much, and no topic is too trivial to not write a page about. (I thought I’d covered security pretty well with the half page I wrote on it, but I got got dinged for not writing enough on the topic. I got the feeling the TA had to find something wrong with my document and if it wasn’t that, it’d have been something else.)
In the second week of the class, everyone votes on which ideas they think are best.
It doesn’t matter what you vote for. Your voting has no bearing on what project you get assigned. But you should vote anyway to help lift decent-sounding projects to the top, so that nobody has to work on the duds.
Expect to be assigned to a project you didn’t vote for because you thought it sounded stupid or impossible (or both).
You’ll then get grouped with 3-4 classmates based on absolutely no criteria whatsoever, so expect clashing schedules/mismatched interests/time zone incompatibilities. The instructor says this is part of life, and I agree (and every single software team I’ve been on has had an off-shore counterpart on the other side of the globe), but don’t expect your teammates to be so understanding. My group insisted that the only time we could meet was what was usually my bedtime, which sucked for me.
You’ll get to know these people very well as you meet 1-2 times a week (probably over a voice chat if your group is keyboard-phobic or generally unavailable at any time of day outside of the specific meeting window)
Every week you’ll work with these people to produce a lengthy document in response to a lengthy prompt. It will require diagrams and lots and lots of writing.
This assignment will be graded by a TA who might have limited English skills or a general lack of interest in reading 12+ pages of rather dry writing. We lost points on things that were present and the TA missed and we lost points on things that were never part of the requirements in the first place.
The last two weeks of the term are spent coding a small portion of the stuff you designed thus far; your group members may or may not participate in this process depending on whether they’re dirtbags or not
The final is made up of rather vague questions, but you should review the slides anyway to scoop up whatever points you can here
CS361 Tips
Vision statement tips
The grading requirements on the vision statement draft are really vague, but you can get full credit by writing a ton on every design topic you can think of and meeting the 2000 minimum word requirement.
Some ideas of what to include (beyond what the assignment suggests):
What differentiates your app from similar ones – do some market research and write comparisons. Someone’s probably already made a product like the one you’re imagining. What makes yours better?
User profiles – Imagine some hypothetical users for your app and write about them. Are they young? Old? Tech-savvy? Tech-illiterate? How is your app designed to appeal to them and meet their needs?
Accessibility features – imagine how your app might work on a screen reader or to someone with limited vision and write about how accessibility concerns are addressed in your app.
Security features – I wrote like half a page on security, which wasn’t enough according to my TA. Maybe you can do better!
Work on the journal regularly – every other day is a good pace. The class’s instructor looks at these himself (or at least he looked at mine himself and commented on it) and he’s very good at detecting who wrote theirs in one fell swoop the night before it was due.
If you don’t know what to write, here are some ideas I used throughout the course to inspire myself:
Draw a comparison between the class’s material and your experiences working in a team – you ought to have some from your previous career or OSU classes
Talk about any previous software development experience you have; maybe throw in a bit about how you think CS361’s teachings on topics like agile will help you on future projects you develop
Talk about how your group work is going
Relate the lecture material to outside reading you’ve done or things you’ve heard
Sometimes the lecturer asks questions in the video; respond to those
Respond to the weekly learning topics: early in the week, write what you think they mean, then, after you do the lectures and your part of the homework, write again about what you’ve learned about those topics and correct any misinterpretations you had initially
Track your group members’ contributions
Yes, it feels creepy to keep secret notes about who in your group isn’t attending meetings, who turned in their part just hours before it was due, etc., but in the last week you’ll be asked to produce a very long, very detailed documentrating each group member on a half-dozen criteria and justifying your rating in writing, so having kept track of this stuff will help you earn full credit on the assignment. I did my group member tracking in a Google Spreadsheet with a column for each week of the class and a row for each group member.
A lot of people in the Slack channel reported getting dinged for not being detailed enough, so keep regular notes and you should have plenty of material for this document and you should be able to write it in very little time. (Mine was 14 pages and included screenshots and data about meeting attendance and how close to the weekly deadline each person submitted their work; I got full credit on the group evaluation.)
Pick a programming language / framework that plays to your group’s strengths
Three people in my group inexplicably voted in favor of a framework they had little to no familiarity with – and majority ruled. I spent 2 weeks giving myself a crash course in JavaFX, coding as I went, which was fine but our development weeks would have gone so much better if the group had just picked something we already knew and could’ve hit the ground running in. The end result: some group members struggled to produce anything at all during the coding weeks.
Here’s what we ended up with: a clickable map of the United States that colors states according to how they voted in the 2016 presidential election and, alternatively, according to how gerrymandered they are.
This screenshot best represents my portion of the work: building the map and hooking it up to real data.
Implementing this much functionality posed plenty of interesting challenges to work through. Things like building a complete map out of individual SVG boundaries, figuring out how to make them clickable, altering their color based on data from the project’s database, and fitting containers within containers to get everything fitting in the application window kept me busy for the two weeks.
For some people in my group this was their first exposure to Git as well, so this project came with a side-helping of Git training. (Note to any future students out there: if you don’t know git yet, start learning it now – don’t wait until you’re in a time crunch of a group project with multiple people counting on you.)
And finally…
Don’t be a dick
Show up to meetings. Do your part and do it early enough so that your group can review it. Don’t disappear during the coding weeks. Be a good team member and make connections on LinkedIn once the class is over.
An educational program like this one is a huge opportunity to network and make friends; you never know who might end up at a great company someday and put in a good word for you. You can gripe about 361 and sandbag for two months, or you can impress a bunch of future industry peers by knocking it out of the park every week.
This post is part of an ongoing series recapping my experience in Oregon State University’s eCampus (online) post-baccalaureate Computer Science degree program. You can learn more about the program here.
Six-word summary: Where my 4.0 GPA went to die
CS271 is a pedantic deep-dive into your computer’s inner workings and an opportunity to enjoy coding in a highly restrictive language. There’s special emphasis on going step-by-step through the stack frame and understanding what’s in every register and even some much-appreciated training on “what order to do things in” when building a program.
CS271 Review
CS271 often felt like it was made of two distinct halves that ran in parallel: the first half is made up of the cute little MASM programs you write for the homework that’s due every other week. The other half is the mountains of computer architecture trivia and methods for calculating various things you learn for the bi-weekly exams, such as binary/hex conversions, Hamming codes, memory usage, optimization, recursive output, stack frame changes, the step-by-step changes in registers as a program runs or steps through a loop, and so on.
The class is very well organized. They tell you precisely what to do for the homework and what the output should look like, line by line. Unlike many classes in OSU’s CS program thus far, you won’t need to do a ton of Googling to learn the material – the lectures and the book reading are actually adequate preparation for most of the class’s homework and quiz questions. The workload is consistent. Each week follows the same pattern, and the homework’s complexity ramps up slowly.
However, the homework (in which you write some Assembly language code) is rather light and may give you a false sense of security come quiz and exam time. The true heavy hitters in this class are the self-checks you do after the lectures, the weekly exercises, and the bi-weekly quizzes. Mastering the material found in all of these is essential for surviving the midterm and the final.
Whether 271’s material is interesting is going to depend on your own likes and dislikes. I thought most of it was squarely in the “hey, that’s neat” category, but I thought it focused too much over low-level details that (probably) won’t directly enhance my career in software. (And that’s just like, my opinion, man – I’m sure some people who take 271 find their calling and never resurface from the depths of CPU architecture, binary math, hex addresses, and bit ordering.)
Class structure
10 weeks
Multiple briskly-paced weekly lectures
An ungraded/untimed “self-check” exercise worksheet for every single lecture – you should actually do these, the quizzes and exams pull from them
A weekly exercise quiz with a 6 hour time limit – you get two attempts and they keep the best score, but each attempt has a different batch of questions so it is advised to take it twice to see both question banks
4 bi-weekly tests, 1-hour time limit, each worth 2.5% of your final grade
6 Assembly-language coding projects (homework assignments) total – each one gives you two full weeks to work on it, with the grading rubric released at the start of the 2nd week
Proctored midterm, proctored final
Steady, even workload
Less self-teaching than some OSU classes (still quite a bit of rote memorization and practice, though)
NO GROUP PROJECTS!
Tips for CS271
This was my first OSU CS class where I couldn’t quite earn a solid A (I got an A-). It certainly wasn’t for lack of effort or time put in – I think I cleared 20 hours of practice most weeks and I worked on this class’s stuff daily.
There’s a ton of material and the tests are very picky – they’re not multiple choice where half the answers are obviously silly, they’re fill-in-the-blank or multiple choice where all the options seem like they could be right. (The tests are also almost half your final grade. Ouch.)
When I look back on what I could’ve done better and what I would advise future students, these are the things that come to mind.
CS271 tip #1: Get the book, it doesn’t suck!
This is one of the books that’s worth buying. It’s approachable with many examples to follow and, surprisingly, many quiz questions are lifted line-for-line from the book.
I liked having a physical book because it freed up screen space during quizzes and while working on homework. I found it helpful to read on paper, practice in a notebook, and really work problems over and over until I had the process down cold. (That’s just my personal preference; I seem to retain more if I read and work on paper.)
CS271 tip #2: Make yourself some worksheets and grade yourself
Speaking of rote memorization and brute-force practice, I highly recommend making yourself some worksheets out of the weekly self-checks and bi-weekly quizzes. Print them out and work through them (over and over) until you can do all of them quickly and perfectly.
This technique was time-consuming but it went a long way to cementing the steps to solving all the various types of CS271 problems. As I mentioned earlier, the homework is borderline useless for the exams. The exams draw their questions almost entirely from the weekly self-checks and bi-weekly quizzes.
The exams tend to layer multiple concepts together into one question and they’re autograded, not graded by a potentially generous TA, so your goal for CS271’s tests should be to become very fast at solving every kind of problem you encounter in the practice materials.
CS271 tip #3: Get a binary/hex calculator
The Casio fx-115ES can do math in binary and hex: addition, subtraction, and conversions between binary/hex and back again.
I had no idea this kind of calculator even existed and the course materials make no mention of it. Frustratingly, I only found out about it through the class’s Slack chat. I was doing conversions by hand like a total chump, which would have cost me dearly on the midterm either in terms of time spent or stupid mistakes or both. The hex and binary questions on the exam were made trivial by having this calculator. I don’t know why the syllabus doesn’t open with “GET THIS CALCULATOR”.
As an alternative to the physical calculator, the course lets you use your operating system’s built-in calculator. (I did this course’s work on my PC but I take tests via ProctorU on Macbook since that’s where my webcam is, so I preferred the physical calculator over having to get familiar with multiple OS calculators.)
CS271 tip #4: Pack that cheat sheet to the density of a neutron star
I made mine in Google Docs, which will let you pick a font size as small as 6 (you have to type it in, it’s not in the dropdown).
One side of my CS271 cheat sheet – the back side was all code examples.
I don’t care for exam cheat sheets. I think allowing cheat sheets drives students to put their efforts into guessing what details should be on the sheet, which sets the student up for an inevitable wave of frustration and disappointment when they realize 2 seconds into the exam that they guessed wrong. Letting students bring a cheat sheet seems to inspire instructors feel free to ask all kinds of minutia-focused questions instead of testing for a more general understanding of the concepts.
But… nobody asked my opinion, and I doubt the cheat sheets are going away any time soon, so my advice here is to pack your sheet as full as you can get it. I think a good cheat sheet for CS271’s midterm and final would be at least 50% code examples, which is what the back side of my sheet was full of.
CS271 tip #5: The extra credit on the homework was generally a waste of time for me
I tried to do the extra credit (of which there are 1-3 points up for grabs on every bi-weekly assignment), but for the most part I found the extra credit opportunities frustrating and almost as time-consuming as the rest of the assignment itself. Your mileage may vary, but I should’ve spent the time on worksheet drills instead.
CS271 tip #6: If I could do one thing differently…
I’d spend more time studying all the nuances of what happens in the system stack while a program runs a loop. Here’s me practicing on a whiteboard, but despite all this preparation I still think this is where I lost points on the exam. I was probably off by 4 on some memory address or miscounted loops somewhere.
And that’s it for CS271! I’m glad I’m done with it; I’ve heard it’s one of the tougher courses and for me, that was definitely true. I worked very hard in this class and I advise all future students to do the same. The tests are no joke and your ability to track and manage tiny details will be tested like never before.
Next up: CS290 – Web Development. See you all next quarter!
This post is part of an ongoing series recapping my experience in Oregon State University’s eCampus (online) post-baccalaureate Computer Science degree program. You can learn more about the program here.
Six-word summary: brutally difficult, but it’s over now!
CS325 – it me
In CS325 you’ll study recurrences, asymptotic bounds, probably every major sorting algorithm plus some silly ones, dynamic programming, graph traversal, recursion, linear programs, and more.
CS325 Review
Well, the rumors are true – this class is hard. I’d place it in a tie with CS162 for overall difficulty. But where CS162 tries to kill you with a brutal workload, CS325 tries to kills you with instructional materials that don’t adequately prepare you for the homework or the exams.
The lectures are not sufficient preparation for the homework – you’ll rely on YouTube and Stack Overflow to get through each homework question. The weekly homework assignments are time-consuming and the documents you prepare are long. Mine were anywhere from 5-15 pages of graphs, pseudocode, and written explanations for my work.
If you can take CS325 by itself, you should.
There was a noticeable (and distressing) disconnect between what was on the homework and what was on the exams. I scored 100% on the homework assignments, but failed the midterm. It’s like the homework and exams were from different classes!
A week or so after the midterm was graded it was opened up so students could see which questions they got wrong and dispute wrong answers, if they could prove they had it right. I thought for sure I’d prove the TAs wrong on at least one or two of mine, so I reworked all of my incorrect answers – and reworked and reworked them – until I eventually figured out what subtle thing I missed while taking the test.
I definitely struggled in this class, and for the first time I wondered if I even belonged in this CS program.
Class structure
10 weeks
7 assignments total
Group work: weekly graded discussions on Canvas, a 3-person group project the last two weeks of the quarter
Proctored midterm (20% of final grade), proctored final (20% of final grade)
No homework assignment the week leading into the midterm
No homework assignment once the group project at the end begins
You can bring a 8.5″ x 11″ sheet of typed notes (size 6 font!) into the midterm and the final with you
Tips for CS325
Take every extra credit opportunity (they’re rarer than you think). There was an extra credit opportunity on the first homework, but there wasn’t another opportunity until the last homework!
Comment early, often, and be helpful in the Canvas discussions. There’s an opportunity for 1 point of extra credit in each of these weekly discussions. I was able to earn it most weeks by doing all of the following:
As soon as the discussion thread was available, I “structured” the discussion by creating a series of replies, one for each homework question. In each reply, I posted the contents of the homework question for easy reference. This gave each homework question its own thread for my group mates to use.
When I figured something out on the homework, I posted pseudocode or a “how I approached this problem” guide to the Canvas discussion to help others. I spent easily 1-4 hours on creating this type of “tutorial”, every single week.
I started the homework right away. On Sunday I did the lectures, on Monday I did question 1, Tuesday I did question 2, etc. By midweek, I had half the homework done and was able to assist with answering questions from group members just starting theirs.
This was a ton of extra work. I see why people blew off the Canvas discussions. But the discussions did two key things for me:
It helped my understanding of the various topics to revisit them and “teach” them to others
The extra credit helped me squeak by with a 92.58% in this class, which got rounded up to a 93% (the cutoff for an A). I needed every. single. point. I could get.
Study recursion – put it on your exam sheet! A lot of the class’s materials (lectures, book reading, and homework) will “gloss over” recursive solutions to problems. They’ll be like, “this is the slow way to do it with recursion, now here’s the better way to do it with <the technique of the week>”.
You might be tricked into thinking the exam will want you to know the fancy technique – you’d be wrong. The midterm will expect you to produce the recursive solutions, which you won’t code for the homework or even look at past the few minutes they get in each lecture. I thought this was unfair of the class, so that’s my tip to future CS325 students: study the recursive solutions. Put them on your “cheat sheet”. Know them inside and out!
The extra credit competition among the final project groups is a poorly-designed zero-sum game that you have almost no chance of winning. Here’s how it works: 60+ groups implement algorithm(s) to solve a given problem in as little time as possible, then post their best running times to a Canvas thread. The assignment won’t tell you what “good” times look like – you’ll figure that out by looking at results that trickle in from the other groups. The winner is whichever group (or groups) has the best performance times in the two different categories.
I think this competition could be made better by awarding extra credit to any (and all) groups that can pass a certain benchmark, since that’s hard enough on its own. My group picked difficult-to-implement but highly performant algorithms and did our work in C++ and we still lost to multiple other groups by a little bit. Unless you’re super dying for that extra credit, I think the winning move here is not to play. Take the time you’d spend optimizing your final project towards an unknown goal and spend it studying for the final instead.
The book sucks. (This is the book.) Okay, maybe the book doesn’t suck, but it doesn’t map nicely to the class material and it won’t walk you through how to solve the kinds of problems you’ll face in the homework. I think the teacher requires this book just for the sake of requiring a book.
You’ll need the power of Google (and YouTube and Stack Overflow) to uncover how-to’s and guides for actually solving problems. I still did the readings every week, just in case something useful turned up, but the book is more like an introduction to the topic, not a guide. I relied almost 100% on external resources to actually learn this class’s material.
There are better videos and walk-throughs for every topic this class covers on YouTube and people’s blogs. Seek them out! There are people who recorded themselves going step by step through real problems pertaining to topics like recurrences and dynamic programming in ways the class-provided lecture videos do not. I owe my A in this class to the generous people of YouTube who took the time to demonstrate these difficult topics.
More than any other class before it, CS325 requires self-teaching and finding help on your own. Whether that experience is worth $1900 is left as an exercise to the reader – there is, of course, the argument that self-teaching is what you’ll do on the job so you might as well get used to it, but there’s also the argument that $1900 ought to buy you at least a little bit of hand-holding.
I’ll be in two classes next quarter: CS271 (Assembly and Architecture) and CS361 (Software Engineering I), so say hi if you’re in either of those with me!
This post is part of an ongoing series recapping my experience in Oregon State University’s eCampus (online) post-baccalaureate Computer Science degree program. You can learn more about the program here.
The beatings are over I survived CS162! If you were wondering where OSU’s eCampus computer science weeder course is, this is it.
The material is challenging and the workload is punishing. The video lectures are crap, but the book is good. The class isn’t well organized (expect poorly written assignments with unclear requirements). 10 weeks is nowhere near enough.
However: I learned a lot. I got faster than I ever thought possible and worked with topics I thought would have had their own standalone courses.
In this article: topics covered in CS162, survival guide, what I thought of the class.
Note: While I normally love to post code here, I can’t share any of my project code (against student code of conduct) or specific assignment requirements, test questions, etc.
Topics covered in CS162
The class is taught in C++ and teaches (or at least requires you to know):
pointers to arrays
pointers in arrays
pointers to pointers
pointers to instances of classes
passing pointers to functions
linked lists made of pointers
abstract class and subclasses
virtual functions
overloading operators (give == an exciting new meaning!)
polymorphism
writing functions that do something recursively, like reverse a string, sum numbers in an array, solve a math problem
data structures: queue, dequeue, stack, linked lists, circularly linked lists
sorting algorithms
Equipment
CS162 is a programming class. Like CS161, I found my Macbook to be sufficient for this class.
I don’t know why they tell people to get a Windows PC and use Visual Studio. I didn’t need it and you won’t need it – there is no assignment based on Visual Studio knowledge.
In fact, judging just by Piazza posts, a number of students seemed confused by the extra files and the “another thing to learn” factor introduced by Visual Studio.
In case you are curious: I did every assignment in Sublime Text and a Terminal window.
Workload
At any given time expect to be working on a 1-week lab assignmentand a 2-week project, and mid-course, a group project on top of the first two. You will also write a multi-page document (PDF) for each project with a test plan (input, expected outcome chart), your designs, ideas you changed along the way, reflections on the assignment. This document always took me at least 3-5 hours to complete to my standards. There’s a quiz every couple weeks (15 minutes, not proctored).
I’m a proactive student who started each week’s material the moment it was released, worked on it daily, and generally finished just moments before a new load of work was dumped onto me.
The first two weeks hit like a ton of bricks: a simple Langton’s Ant simulation by itself would have been a large assignment, but CS162 adds a user-navigable menu, input validation, user-adjustable parameters (dynamically sized board, variable turns to run, etc.), and other features that have to be designed, coded, tested, debugged.
Oh, yeah – it has a visual component, too.
There are also two lab assignments to complete while you work on the Langton’s Ant project.
This pattern continues until the end of the course. The toughest week was the one where I was working on a project, a lab, and a group assignment all at the same time.
Here’s what I did (or wish I’d done sooner) that made CS162 more bearable.
Take it by itself (if you can)
I know there are financial aid reasons not to but if you’re normally taking 2 classes a quarter, consider taking CS162 alone (or at least with fewer classes than you normally would). It’s a ton of complex material – assuming you haven’t worked a lot with C++ pointers, memory, arrays, etc. yet – and the assignments are black holes for time.
Diagram things out on paper
I found many of CS162’s assignments too complex to hold entirely in my brain.
For example, here’s a crazy thing we did: create a circularly linked list (in C++), let the user fill it and delete nodes from it. When you exit the program, it has to unload from memory node by node. “Empty nodes” are marked with -1 for their values. This drawing I made helped a ton (actually, this was probably the 5th iteration of this drawing).
And here’s another one, this one showing how the heroes in the polymorphism project either rejoin the tournament queue or get kicked out to each player’s respective loser pile.
PS: Some people got really precious about their diagrams having to be works of art, but you don’t have to for these assignments. Just draw this stuff out, paper/pencil (or a little whiteboard) is sufficient, and plan to trash your first few drawings. If you need some material to bulk out your retrospective writing assignments for each project, photos of the diagrams you make are excellent fodder.
Go straight to Google (and Stack Overflow, and YouTube)
Sure, it sucks to pay $1880 to do so much self-teaching but you’ll get a lot of mileage out of the skill. The recorded lectures are crappy and I felt like they were wasting my time. There are better guides to all of the concepts covered in this class on YouTube.
I recommend getting a physical copy so you can have it open next to your computer while you work, and use your monitor(s) for your code and Stack Overflow. It’s the same book you use for CS161 (if you haven’t taken that yet, either), so at least you get two classes out of it. You can also buy the loose leaf edition to save some cash.
After two classes with it I can say it’s a good book. The examples are relevant to the coursework, they’re clear and easy to understand, and there are a good number of examples.
Start every week’s material the day it drops – and don’t count on weekends
Sometimes the new week will be released on a Friday. Sometimes a Saturday. Sometimes a Sunday! And no, the instructor doesn’t move that week’s deadline out just because you lost the weekend due to the materials not being released in a timely manner.
For this reason, I recommend setting up your life (at least for these 10 weeks) to allow for working on this class work during the week (ideally daily). Don’t expect to fit it all into the weekend. Even my light weeks were at least 15 hours spent on the class (usually closer to 25 or 30).
Check Piazza religiously
If they improve anything in CS162, I hope it’s the unclear assignment requirements. They requirements were notoriously bad – assignments are written in a conversational style and it’s hard to know what is really being asked for.
Many students took to Piazza (the class forum) to question (or worse, debate) the requirements until a TA or the instructor herself came along to clarify.
Pretty much every week went like this:
New assignment comes out – oh no, it has unclear requirements
Someone asks for clarification on Piazza
TA makes a call and says do it X way
2 days later, another student asks the same question
Different TA makes a different call on this new thread and says do it Y way
They have a fight, triangle wins…
You already coded it, so do you redo it to Y or keep it as X or what?
For what it’s worth, every time this happened (and I had already coded it), I kept my code the original way and still got 100% on the assignment.
Test on Flip!
So many things happened in my code in the Flip environment that did not happen on my Macbook. Weird things, too – things that weren’t easy to spot without thorough testing. I made the mistake of not testing on Flip until I thought I was done with the assignment, only to find heaps of bugs that only occurred in that environment.
It’s a memory management tool that’s already installed on Flip and you won’t be able to find memory leaks without it. If you wait until you are done coding your assignment, it will be harder to find the memory leak. Upload your code and check it with Valgrind every so often and you will save yourself a lot of pain.
The worst weeks were weeks 1, 2, and the final project.
Okay, they were all brutal. There were many weeks where I thought there was no way I would get everything done and I’m a workaholic. The biggest workloads were the first project (Langton’s Ant) and the final project at the end (make an adventure game).
You do actually have to contribute to the Canvas conversation topics
It’s a misguided requirement because these “conversation” threads quickly turn into 100+ people dumping commentary and links in one place. It’s not a conversation, it’s just a dogpile.
But if you contribute a few posts (I think I made 5 decent, paragraph-sized comments between January and March, evenly spaced throughout the quarter), it’s an easy 20 points that you will (probably) be very happy to have at the end.
Take every quiz twice
(Unless you get a great score the first time around, of course).
You get two attempts for each quiz. A quiz is 20 questions in 15 minutes. (I liked this format). Only the grade from the last attempt is kept. Questions are drawn from a larger pool, so you won’t get exactly the same ones the second time you take it.
My strategy was to use the first attempt to see what’s on the quiz and make my best guesses as to the answers. This gave me a feel for the questions and sometimes revealed tricky ones. I usually got about a 16/20 on my first try but Canvas tells you which ones you got wrong, and what the correct answers were, so this is a chance to see what you missed and study it some more. After a little studying I’d retake it, usually getting 18/20 or 19/20 that second time.
Grading
The final’s worth 15% of your grade, so save some steam for the end. There was a bonus, extra credit lab announced right at the last minute, too, but its points could only be applied to your lab grade.
Weekly labs – 30% of your grade
Quizzes – 15% of your grade
Projects – 30% of your grade
Group activities – 10% of your grade
Final project – 15% of your grade
Overall impression: OSU CS162
I hated it at times, but it was worth it. I never would have pushed through some of this stuff on my own, without a grade and a degree motivating me. OSU’s online CS is meant for people with a full-time job and the occasional signs of life outside of class but I had to take a couple days off work here and there to accommodate the workload, and I barely saw my family. The most difficult parts of this class – deciphering confusing and unclear requirements – were totally unnecessary. OSU should hire a proofreader and clean up CS162’s assignments. And some weeks the workload was just pure insanity – the week with the group project stands out in particular.
But… it’s over! And I got a 97%, so I’m going to take a much-deserved week to rest up for the next class.
Onwards to CS225!
Other student reviews of CS162
Leave a comment and I’ll update this post with your review!
This post is part of an ongoing series recapping my experience in Oregon State University’s eCampus (online) post-baccalaureate Computer Science degree program. You can learn more about the program here.
With my successful completion of CS161, I am now 1/16th of the way to a Computer Science degree! Despite being labeled an “intro to CS” course, this class wasn’t a walk in the park – the two exams (worth 60% of the grade) were the tough part.
CS161 syllabus, topics
My CS161 was taught by Tim Alcon. He was remarkably responsive on the class forum (“Piazza”) and over email. There were something like 200+ students in the class, though, so assignment grading was done by a group of teacher assistants (TAs).
If you’re a prospective student reading this and these topics are all brand new to you, you should get familiar with them prior to the class. The class moves pretty quickly, especially past week 3.
These are all courses/video series I’ve worked through myself and recommend to anyone wanting to get started with programming:
The course is 10 weeks long. Every Wednesday at midnight the next week’s homework and reading (called a “module”) becomes unlocked in the class portal (known as “Canvas”). You can do the reading/homework as fast or as slow as you want, as long as it’s turned in by the due date, typically the next Sunday or Wednesday (so you had either 5 or 7 days to get everything done before the next batch opened up). There weren’t any videos or supplementary materials beyond the book. Basically it’s read the chapter, do the homework, repeat.
Early in the course, I found this drip-feed of content frustratingly slow. I wanted to work ahead and take advantage of free time when I had it. I usually had my assignments done within a day of their release. After about the halfway point, though, the class picked up the pace and I was turning in homework much closer to the Wednesday night deadline.
CS161 homework assignments
Every week had a reading assignment (usually 1-2 chapters from Starting out With C++: Early Objects) and a coding assignment. Some weeks also had a group assignment and/or a reflection assignment (1-2 pages written response). For the code assignments, you upload .cpp files to upload via “TEACH” (OSU’s interface for uploading homework).
The time commitment was reasonable, in my opinion. My daughter was born the same day class started so I had the advantage of being on maternity leave from work, but a newborn is demanding and I ended up squeezing homework and reading in anywhere I could, at odd hours of the day. In the early weeks of the class I spent about 4-5 hours a week on reading and homework combined. In the later weeks, I was spending 8-10 hours per week on the reading and homework combined. However, it’s worth adding that I’ve worked as a programmer (front end web developer) for the last 2 years, have already completed a web dev bootcamp, and have put myself through various online self-paced CS courses (this one just happens to be worth a college credit).
I thought the assignments were clear in their requirements and it was easy to understand what I needed to do.
The course materials suggest that you need a Windows machine and Visual Studio for CS161, but that’s not necessary – I did a lot of my homework on my Macbook and I never opened Visual Studio on my Windows machine. On my Windows computer, I used MinGW as my C++ compiler and wrote my code in Sublime Text. With this setup, I didn’t have to worry about Visual Studio adding anything extra to my files and my homework always compiled on Flip, the school’s Linux environment that you can log into and upload your project files to for testing. (This is the same environment the TA’s use to check if your work compiles.)
Some weeks had group assignments, which were coordinated over the Discussion groups in Canvas. The two major group assignments were basically “everyone upload last week’s homework, then decide amongst yourselves which one is best and write a page explaining why you picked it”. I found my classmates responsive and eager to complete the assignment; this wasn’t the group assignment horror-show you might remember from high school, at least not here in CS161 where it wasn’t about producing a completed project together.
Assignments were usually graded about a week or so after turning them in. Feedback was a line, at most, usually “Looks good!” or “You didn’t give this method the right name, -2 points”.
CS161 exams
The most important thing to understand about OSU CS eCampus exams is that they are “proctored”, which is academia-speak for “supervised”. This was my first experience with proctored exams. (And this will be the case of all exams for the online CS degree program, not just CS161.)
There are two proctoring options:
Take it in person at a local university/college/community college/test center (this is what I did)
Take it at your own computer with a live webcam stream of your face running the whole time with a service like ProctorU
I thought the ProctorU option was creepy as hell, plus I couldn’t guarantee the people I live with would actually be quiet while I took the exam. They require a 360 view of the room you’re in before you start, and any interruption is grounds for your test to be disqualified. Getting up to yell at someone / deal with a fire / etc is enough to make the person supervising you over ProctorU disqualify your test. Reading others’ first-hand experiences with ProctorU also put me off the service pretty quickly, but I never actually tried it myself.
Taking the exams at my local community college’s test center was easy once I confirmed with them that they were approved for OSU tests. I scheduled a time (they even had Saturday hours), showed up, sat down at a computer, logged into my OSU Canvas account, and started the test. The test is timed, and the test center provides paper and pencil (which they keep after the exam). The test runs in your web browser. My local test center charged $35 per test.
As for the exams themselves, I found them rather tricky. Each of the exams (there are 2) are 20 multiple choice questions with 4-5 answers to pick from. You have to hand-trace through the code (which is often iterative) and spot any errors that might be included in the code. (The paper and pencil help a lot here.)
In real life, you get the help of a compiler and unit tests (that I’m sure you wrote because you’re a good programmer) to help you understand (or debug) a bit of code, so the tests felt unnecessarily difficult and unlike my professional coding experience.
Here’s an example. One exam question had something like this (embedded in a much larger block of code):
if (x = 3) {
...stuff here...
}
I caught the single = sign, but I didn’t know it would actually do something in this case. In C++ (and other languages), this evaluates to true and sets x to 3. I’m just citing this as an example of how you have to know the fiddly bits of C++ to really excel at the exams. (I managed an 80% and an 85% on the exams.)
The test is graded as soon as you submit it, but you won’t know which ones you got wrong until they unlock the tests a few weeks after they’re done. Furthermore, while they’ll eventually tell you which questions you got wrong, they won’t tell you what the correct answer was.
So, don’t expect the exams to be much of a learning experience until the course has ended and you can work through the questions with an IDE and compiler.
Overall impression: OSU CS161
OSU’s eCampus Computer Science program looks solid from here, and I thought CS161 was a good value. The materials were well put together, the pacing was reasonably challenging, and the course’s time demands seem manageable for someone with a full-time job and family (I was on maternity leave while I took the course). I came into the class with more prior experience than the class is really meant for, but I still felt satisfied and challenged by the material. The OSU eCampus Reddit forum is a helpful resource for information on individual classes, admission process, instructor reviews, etc.
