Software Development

Taken from Software Development Capstone Project reviews

"I can't agree with the first reviewer more. This "course" (and I'm being generous even using that word) is an unconscionable abandonment of any sense of responsibility or accountability on the part of UBC.

To put the entire 6-course sequence in perspecive: The first two courses (taught by Gregor Kiczales) are perfectly fine courses (on functional programming), and they run like a well-oiled machine (no doubt due to the fact that he's been teaching them on one MOOC or another for at least the past few years, from what I can tell). These courses were both taught in Racket, a purely functional language (no loops of any kind here), but I don't think that's so unusual - I've spoken to Comp Sci graduates who had courses in Racket early in their education. It's not a language I suspect you'd ever use in your career, but it's a good teaching tool for functional programming (and a lot of other basic concepts).

It's in the next 4 courses where things started to go astray, and it's obvious that a large part of the problem is that these 4 courses (and the MicroMasters program that they help justify) were all just added in 2017-18. I was a student in the first-time sections of all 4 of these.

To be fair, courses 3 & 4, taught by Elisa Baniassad, were not bad. They're taught in Java, and the learning curve was a bit steep, but since they're self-paced, you have plenty of time to catch your Java skills up to the general Comp Sci concepts being taught in the course. And I will commend them on having a good number of programming exercises (many optional) which were engaging, educational and very helpful in bringing my Java skills up to speed. And the final projects (as in courses 1 and 2) were pretty interesting and reasonably challenging.

However, it really started to become obvious that UBC had bitten off more than they could chew (or, perhaps, more than they were willing to chew) when the 5th course started up in early 2018. I was still in course 4 at the time, and it was obvious that something was wrong: whereas you could previously get a TA response within a day or so, questions started going unanswered/ignored for unreadonably extended periods of time. (One of the TAs admitted to me later that there were a lot of logistical problems and platform/content errors with course 5, and they were completely consumed with trying to deal with that – instead of covering their other courses.)

Now, on to course 5 – this is where my regrets really start. Generally speaking, I thought the material was interesting enough (and certainly relevant), but they made some pretty strange (and, I think, maddeningly unreasonable) decisions here. Namely, whereas we’d just finished two courses in Java and built up a reasonable comfort/proficiency level, the professor (Reid Holmes) inexplicably decided that to the extent that we’d even look at code, it was to be TypeScript – a language we’d never seen (it’s a structured superset of JavaScript – which has no real relationship to Java). Moreover, we were told that TypeScript wasn’t going to be taught at all in the course – we were to learn it on our own. And unlike the previous classes, there were no opportunities to actually code in it as part of the course work (not even any practice coding assignments). We simply looked at some code examples at times (and tried to figure out what they meant – TypeScript is kind’ve strange). Unfortunately, some of this figured into at least one of the exams – which was difficult, given that we’d never really “worked” with the language in this class.

By far the worst part of course 5 was the final exam. Because this is a MicroMasters program, they supposedly had to make us take a proctored final exam (with a webcam, being monitored by some outside company – nothing on the walls or desk, and you can’t get up for any reason for the 2 hours – even to go to the bathroom). Okay, so that’s doable, but this exam was ridiculously hard and unreasonably binary in its grading. Here’s what I mean: one type of question this professor had used on all the graded quizzes was the “choose all that apply” format. On the quizzes, this was often a case of choosing two or maybe three out of 4 or 5 choices. If you chose all but one of the correct choices (say, 3 out of the correct 4), you got 0 points (not 75% credit) for the problem. That’s a terrible way to test, because the fact that you correctly chose most of the correct options shows that you do know the material, but you still get zero. And on this final, it was even worse. A surprising number of the questions were of this form, only here, there were more like 8 or 10 choices (and God only knows how many of them were the “correct” choices – you could have chosen 7 out of the 8 correct ones, and you still got zero credit for the problem). The TAs had warned us up front that the scores on this exam were quite low compared to the quiz scores, and this is undoubtedly why. I made it through okay (having come into the final with a high average), but I know we were all very worried that we’d do so poorly that we wouldn’t pass the course (I’m not sure if that happened to anyone, but I think it was pretty close for a few people).

And now on to the biggest regret of all: course 6. (Again, I’m being generous even calling this a course). Reid Holmes was the teacher (and I’d pretty much be lying to say that he “taught” anything in this one). There were some introductory videos where he briefly explained the nature of the capstone project, indicating that it would take approximately 120 hours (I’d say that’s off by at least an order of magnitude – I spent at least 4 times that on the 50% I completed before throwing in the towel). I can’t remember if he indicated in the video or if one of the TA’s said it, but supposedly this project is one that all the UBC undergraduates have to complete. However, I can guarantee you that the UBC undergraduates aren’t abandoned the way we were, 500 miles out to sea with a leaking life raft and half a granola bar. Let me elaborate:

It took me all of about 30 minutes to watch the few videos Holmes put up for this course, and none of them was directly relevant to the project. They were just “of general interest” (topics like Ethics in software engineering). Most of what I found regarding how to proceed with the project (and what it entailed) came from written descriptions on the website. We were provided some base code (via GitHub) that had stubs for everything and were told to come up with our own unit tests. Also, we were to run our code against a hidden UBC test suite on GitHub. Our scores were based on code coverage (and for later phases, passing tests).

So many things that were just unconscionable about this mess:

1) Again, we were told the project was to be written in TypeScript, which we’d still never coded in before. So step 0 was “Learn TypeScript development on your own” (and yes, they actually said that: “on your own”)

2) The TypeScript was compiling to Node JS, something else we had to learn as we went.

3) When I say “learn as we went,” pretty much I spent hours every day on StackOverflow, trying to figure out how to do things, and then going back and trying to find out why I was getting certain cryptic errors and exceptions.

4) Also in the “learn as we went” category, I noted that there were some links on the course website to “useful material” we needed to know, including Asynchronous Promises. But all these links were dead. When I reached out to the TA about this, I got back a “Gee, I guess we never actually had anything to put there. Try a Google search of those topics.” The dead links soon disappeared from the website completely.

5) I definitely second what the other reviewer wrote about this course: our only point of contact with UBC was a lone TA who more or less did the online equivalent of shrug and say good luck. It was obvious from the start that we would get no help (and Reid Holmes – I’d almost forgotten he supposedly “teaches” this course – no contact with or word from him EVER. Which, by the way, is what makes the claim that all UBC students do this project so laughable: I’m certain that UBC students have access to professorial office hours, TA sections, and each other in tackling this project. We had none of that.)

6) Regarding my last point: I should mention that in theory, we were allowed to form teams with other students, but really nothing in the first 5 courses had set up an environment where that was even a realistic scenario. I don’t really know any of the other students, or who’s a verified learner versus an audit student from all those courses. To my knowledge, most people worked solo since they also didn’t know anyone else (and no credible efforts were made by UBC to introduce us to other potential coding partners).

7) We were severely limited in that we were not allowed to do things the way any real software developer would with a Node JS project: find API packages that would allow us to accomplish certain well-defined tasks. This was strictly “roll your own,” which should explain why I constantly ran into problems that led me to StackOverflow (where people would often respond “Why don’t you use such-and-such API for that? Nobody would do it this way.”) I suppose a sophisticated JavaScript API developer would “do it this way,” but as students with a mere 5 fairly scattered MOOC courses (material-wise) under our belts, we were dreadfully unprepared for something this immense.

8) The project used a strict TypeScript linter which disallowed just about everything it could, so even when I did find a working solution via StackOverflow, more than half the time it was not an option because the linter prohibited it. (Yeah, sure, I get it: when you work on a development team, a linter is very desirable to keep everyone’s coding style consistent, readable, etc. Guess what: we weren’t on a team, we aren’t professionals yet, and we’re just trying to self-teach our way through this already daunting mega-task, made even harder by the linter).

9) There were weeks on end where the UBC autotest bot was down or not working properly, so we couldn’t even check to see how our code was performing against expectations.

10) The grading was supposedly based on your code coverage percentage. On the first part, I spent a considerable amount of time pushing my coverage percentage close to 90%. And when the TA graded me at 80%, I complained. The explanation was that, contrary to what the advertised grading policy was, Holmes had set the grading system up to have 20% granularity/ticks (i.e., you get 100%, 80%, 60%, etc., but no value in between). So my almost 90% got floored down to 80%. Nice.

11) I started this project in May 2018, and it’s late August as I write this. The course started in early March 2018, and as far as I can tell, even the people who started this thing 2 months before I did have yet to complete it (the other reviewer indicates the same thing). It is painfully obvious that this “course” was set up with no real consideration of its actual feasibility for a student on his/her own who is drawing primarily on the material presented in the previous 5 courses.

12) I hate to be a pessimist, but when you factor in the professor’s complete absence from anything that could even remotely be construed as a teaching role, and the fact that a single TA seems to be (mis-)minding the store, this MicroMasters program sure looks like nothing more than a cheap money-grab by UBC.

I thoroughly regret having enrolled in this program overall. There’s no way I will throw away another night (or even hour) of my valuable time on this “road to nowhere” project. So much for that MicroMaster’s degree. (I’m actually already pursuing another in a related field, and the quality difference is night and day.)

If you’re considering a CompSci MicroMatster’s, I’d urge you to enroll anywhere else but here. This has just been awful. (I wish I’d done Penn State or Harvard or MIT or Columbia instead)."