It’s been a while since the end of class and graduation, but I still want to complete this proposed post.

Courses Taken

CSC302 - Steve Easterbrook, CSC336 - Christina Christara, CSC401 - Gerald Penn, and CSC488 - Dave Wortman

CSC302

Like the code suggests, this course is kind of a continuous course of CSC301. However, we concentrated more on paperwork side of software development. While the course was still mainly on agile development in which documents are significantly less than “traditional” model, there are still some quite essential documents that people need to work on to stay on track. Some of them are requirement analysis, risk analysis, progress tracking, release plan, and user manual, etc.

Like CSC301, students were assigned into groups of 5-6 and therefore the workload will be shared, so it wasn’t a very workload intensive course, even though some did more and some did less. However the problem was the group I was in only had 4 people, it was not disastrous but quite unfair. However our team was performing well overall given the shortage in manpower. We got a high mark, 95%, and a 90% for the first and last assignments respectively, and received some around average marks for the other two assignments. The course average for the assignments were high 80s I think.

It was very fun to work in groups and I had chances to act as a casual leader who called for meetings, prepared issue lists/agendas, finished own parts relatively early and helped out on other people’s “backlog items”, a frequent word used in SCRUM. The material is highly relevant to practices used in current software companies and absolutely comes handy when team work experience is needed.

“… I had chances to act as a casual leader who called for meetings, prepared issue lists/agendas …”

CSC336

Numeric Methods. This course introduces basic limitations of machine computation, causes or error & prevention, matrix decomposition, function approximation, and differentiation & integration approximation etc. It’s been a while since the exam now so I am rusty on the material and probably cannot recall all of the topics. It’s a fundamental course of computer science and I found I should take a in early years and it would have saved me many days trying to tackle numeric problems without understandings of this material. No wonder many previous courses looked hard!

The professor was Christina C. Christara, aka CCC. I often used CCC to warn some lower year CS buddies I knew that her class was hard. It was very well known that in the very previous term this course was extremely easy and rumour said the average was 90%. That’s probably not true but the average was probably closer to 90% than to 70%. After two weeks of class I knew this wouldn’t happen to us. Nothing seemed trivial and I felt I sunk into the dark helplessly once again, but eventually I realized most people in the class felt the same. If I cannot do it, neither can most people in this room, and I just get to do my best. After all I was probably one of the few freaks who took it in his 5th year (included the 1 year intern).

The marks were higher than I expected though. It was easy to make mistakes in assignments and exams but TAs didn’t seem to deduct marks too wildly except for the first assignment. So everyone survived and I was lucky enough to set a new high for my personal grade, 91, which was very likely to be nothing to some people. But like I always said, I didn’t give a damn to gpa until two years ago and that’s why it sucked abnormally badly.

CSC401

Natural Language Processing. I was a loner in the class; I talked to no one and was mostly doing assignments alone. Half of the class were graduate students, and the marking is more strict. While I didn’t see I had any major disadvantages comparing to graduate students (I shouldn’t be since I am supposed to finish all pre-requisites by now), but the slack years I had laid a very unreliable layer of statistical “component” in my head (if you think learning new stuff requires a whole lot of underlying “components” and visualize it like a classical component diagram) made a lot of easy concepts intricate to me.

It is inevitably the hardest course I took in the winter, probably also  the hardest during my undergraduate, considering I was a million times focused on school stuff than before. But it was fun. We wrote programs and scripts doing text classification, simple deciphering using hidden Markov model, text segmentation, and summarization. Through these I think I had a peek of a whole different computer science realm of topics like information retrieval, machine learning, and natural language processing etc., all were so different from software engineering issues. I really found this course useful and I think knowledge of such will have a big advantage in the industry as more and more software products now consist of at least some kind of machine learning / artificial intelligence components. My current company’s key product depends heavily on the performance of our information retrieval system, although I wasn’t interviewed for this knowledge, but it will come handy at some point.

CSC488

Compiler. This is a very hardcore computer science course, requires solid understanding of almost every lower year computer science courses - CSC108/148 (Java Programming),  CSC258 (Computer Architecture) CSC263 (Data Structure and Algorithms), and CSC343 (Computer Languages). It’s another group course and group size was 4. The assignment average was incredibly high though, and we were another “constantly-below-average” team (the term came from a self description of a team in this course from previous years which I came across on the web).

“… There was one assignment, accounting for 10% of every team member’s final grade, for which I did about 90% of the work …”

We built a compiler that compiles a C-like language to instructions of a simulated machine. We were given a list of production rules, in some form of context free grammar if I didn’t confuse the name. The workload was high and we switched to new topics very quickly. I often found absolutely no clue on how to write a single line of code for the coming assignment even when I did major coding for the last. Fortunately we had a graduate student on our team who often gave us  tutorials on goals of assignment so I could help executing the ideas on each one of the 70-some production rules. The team didn’t work out that well and workload was off balance. There was one assignment, accounting for 10% of every team member’s final grade, for which I did about 90% of the work. It was during midterm so everyone was busy. Even though I had a midterm right after its due date, I just couldn’t see us losing that 10% of the mark and worked 20 hours straight. We ended up getting our highest assignment mark for the course. So I was delighted and it was worth it. I was very depressed and desperate when I sat in the lab overnight doing it all alone though. It was kind of unfair, but in the midterm of this course in the following week, I knew how much the effort helped me prepare for the midterm. Even though the test was more on the theory side, the hands-on experience definitely at least consolidated the part of knowledge used in the assignment. The average for the midterm, however, was 43%.

We pretty much worked on all stages of the workflow of compilation. We used open source programs to do lexical analysis which takes production rule file we wrote and breaks source code into a stream of tokens. We then rewrite the production rule file to construct program tree as tokens are processed. After that we added code to go traverse the program tree and do semantic checking. We created a symbol table to validate uses of variables - e.g. if a variable name doesn’t exist in the symbol table, then it’s an invalid program and we generate an compile time error. Finally we traverse the program tree again and iteratively generate machine code.

Some of the features we were able to finish in the term were if..then..else, for loop, while loop, array type and dynamic array, and function etc. There is more than doing nerdy stuff in this course. After this course, all programming languages converged in my mind, all statements were automatically decomposed into a series of machine instructions in my head. I am able to think programs at its lowest level and now has a deeper understanding of language design problems, how special data types are handled and represented in machine, and how programs are structured in their virtual memory space. These will be essential for further learning of memory related security issues, operating systems, modern computer languages and many more I can’t think of now. Well it’s not necessary to get all listed here, as I am only doing some reflection here. I will know when I need it.

After 8 months of torture, both physically and mentally, I’ve finally finished school. I knocked off 5 credits, 4 out which are 300 and 400 level computer science courses. I had, on average, 1.5 assignments in every single week, and each assignment takes between 20 - 40 hours. I have, for many times, felt depressed and even desperate because of the “endless” todo list that kept getting longer as each day passed. Phew…….my hair turned slightly grey too.

“my final year GPA will be around 3.4 - 3.5/4.0″

Now it’s over, and looking back, I found it very rewarding. I’ve learnt a handful of new concepts, technologies, design patterns, algorithms, and tools etc. I expect to get another “combination” of AABB this term, and my final year GPA will be around 3.4 - 3.5/4.0, if, however, I exclude my English grade. Ha, what a shame.

I will do a summary of my courses for this term a bit later, when the mark of my last exam is out.

Meanwhile, I need to start a new journey and make up a plan for the next couple of years, like what I did two years ago.

Courses Taken

CSC301 - Greg Wilson, CSC369 - Karen Reid, CSC373 - Derek Corneil, CSC418 - Karan Singh, and an English Course for humanity distribution.

CSC301

The course wasn’t as scary as I thought, probably because the course was being taught for the first time and many things had to be justified. Some concrete things I’ve found useful from the course are the tools we’ve introduced to and asked to use: SVN, Ant, Java Thread system, and Java Profiling Tools. There weren’t too much writing in this course (probably in CSC302). I also find the design patterns to be quite interesting, in fact, I have identified quite a few design patterns in programs I wrote in my former job after I read through the design patterns.That somewhat shows I am kind of smart enough to come up with similar things as experienced software engineers, but what’s more significant is probably that my experience serves as a proof of the generality of the text, and the patterns are really things produced in productions.

Also, it’d be really great to work in a good team and you can often find in some morning before the due date, a big chunk of code is, magically, checked into the repo. and it’s working. The magic, apparently, is from teammates.

“… a big chunk of code is, magically, checked into the repo …”

CSC369

I wasn’t very confident about my C programming skills, but I couldn’t believe how my knowledge of C organized themselves in my head and I suddenly got pointers right and wade through the course with no feeling of insufficiencies in C. The course has been very interesting to me and I couldn’t help correlating the function of OS to computers with that of JavaScript frameworks to the web today. OSs need to be compatible with many types of machines, and JavaScript frameworks need to work with major browsers. General OSs usually provide built-in libraries, and JavaScript frameworks usually provide library as classes as well. General OSs also handles complex inputs like mouse movements, and JavaScript frameworks also often provide a better layer on interaction and also animation, on top of browser, to support better mouse and keyboard inputs. Last, with XHR object, we now may have synchronization problems in web programming too.

After the first two assignments, however, we’ve worked on things mostly irrelevant to web domain. We implemented Virtual Memory and File System. We had an extremely stupid and sad story to share when testing the Virtual Memory assignment. In OS/161, there are two files that the simulator uses to use as swap disks, usually one of them, called IMAGE1.img or something alike. To test the functions, we ran the simulator and executed a series of provided test programs. The virtual memory system will then move pages in and out the file and the memory of the virtual machine. The tests ran very slowly, due to both the CPU speed and virtual memory size, we set the virtual memory size to be small to generate more page faults. So to speed things up, we ran two instances of simulators (the executable files of which are in the same folder) together. We get wrong results, and sometimes crashes. We spent hours and hours to re-read the code and fixing likely “bugs”, when there were probably very few or none. Until the noon after another allnighter, had I realized, after 2 hours of sleep, that the two simulators are using the same image file and we are moving pages between two totally different world! So WATCH OUT! It’s the very first time I get to know what’s “demanding faster, never arrives”.

Here is also what I’ve got after scratching my head 1000 times. A DIAGRAM of the virtual memory system we are implementing. vm161.pdf. It contains some errors, I assure, but I’ll not bother to fix them, in case I gave too much information to web users.

“… couldn’t help correlating the function of OS with that of JavaScript frameworks today …”

CSC418

The course was so much easier than my original thought, a perception I’ve got after seeing people doing fancy, complex, and dazzling effects on computers in the lab. In fact, the course does have a lot of workload, yet I didn’t feel any tiredness, as it’s so fun to work on. Time slipped by as I refine my programs bit by bit, and it could continue. We do get fair bonuses if we were able to add neat refinements than specified in the handouts, resulting in high averages of assignments.

It was supposed to be math intense, but I could only remember some very basic vector concepts being used and the most complex ones were probably the change of base matrix which I had a hard time to understand and memorize vectors from which coordinate are mapped to vectors from which coordinate. The homogeneous transformation was a bit confusing for me too, but it doesn’t affect me too much for solving the problems.

For the course project, aka A3, a compelling scene is much more plausible than a well written piece of ray-tracer or animation alone. I was lucky to have a little bit sense of arts and have rights to use some of my photographs, which helped winning us an alien model. I have had one of the best partners I’ve ever got and we collaborated very smoothly, almost perfectly complementary which means both quality and efficiency.

CSC373

It was the misery of last term. I can’t say it was the one I spent most time on, since I was able to write up assignments between 15 - 20 hours, compared to programming courses that easily bite 30 hours off. I still lack of practice to be prepared for the tests, although I thought I had enough by doing three past tests. The hardest part was the proof of greedy algorithms. For dynamic programming and divide-and-conquer, the solutions in many cases are easy to reverse engineering when you are given clue that you will use a specific type of algorithms. To conquer the course, one has to be able to somehow acquire the instinct to solve problems in exams quick enough, which only comes with intense practices I assume. The course does cover a lot of topics and algorithms, I feel, and one should have a solid foundation of computer algorithms. I like the course but hated my marks. No more comments.