Week #12 - Final Thoughts

As I look back on this course, I remember in the beginning of this course when I was basically terrified that I would fail because I hadn't actually taken the CSC108 prerequisite. For once I was definitely glad to be proven very wrong. While there were definitely hurdles, I think I probably did the best in this course out of all of my courses, and it has cemented my decision to either switch to a computer science major or specialist or do a minor with my commerce degree. 

Python was I think a pretty good choice for a first language to learn. It handled all the basic concepts well, without too many additional bells and whistles. That being said, I've had experience with Java and C++ before, which are more complicated languages, and it's probably easier to go from more to less complicated than the other way around, so I can imagine I would have troubles moving on to C++ after Python if that had been the order in which I learned these languages.

Another thing that was definitely a hurdle in this course was that I just didn't have a lot of practicing coding. I can understand all the concepts perfectly, but if I just don't have that experience, then there are so many additional problems that arise when coding that just can't be predicted with only book learning. I definitely learned from this experience that I want to take this summer to do a lot of practice in coding.

Speaking of which, another thing I learned from this course was how useful it was to have a base understanding of the concepts before starting the course, so I definitely want to take the time to look into what we're going to be studying next year and brush up on it a little bit!

Overall though, a very fun course, with an excellent professor who was very engaging to listen to and super helpful, I know for a fact that he has stayed to help well beyond his scheduled office hours on multiple occasions. Just want to take this moment to thank Professor Danny Heap for this very enjoyable course.

Also making this course enjoyable was of course my two lab partners and friends, Dominique and Sophie! If you're reading this, thank for putting up with my sleeping in to ungodly hours, frequently leaving halfway through a work session to go eat food and overall distractions in everything. See you guys next year! 

Week #11 - Revisit

This week, I've chosen to revisit my post from week 3, about Why Geeks Should Write.

Overall, I think I still agree with most of the points I brought up in my very first slog post. I also had the opportunity to read over some friends' slogs on that same topic, specifically these two:
http://wickedbatslog.blogspot.ca/2015/01/week-1-csc148-writing-for-geeks.html
http://cleverprogrammingpunhere.blogspot.ca/2015/01/week-3-why-geeks-should-write.html

I really enjoyed Sophie's take on Why Geeks Should Write, especially the latex example. It's definitely true that mixing up languages can be a problem for those of us lucky enough to be multi-lingual so keeping up practice is important.

Dominique had a similar idea as I had, about how computer scientists need to be able to explain computer science to non-computer scientists, as well as a refreshing idea on how that can also work the other way around, when non-computer scientists need to be able to explain things to computer scientists, so they know exactly what they have to be coding.

As I do still agree with the majority of what I said before, I would instead like to take the time to develop this idea a little bit further. Considering the first assigned topic of the SLOG, I think it's a pretty reasonable conclusion that the reason we are doing these SLOGs is to develop our writing skills while we develop our computer scientists. While I obviously agree with the theory that computer scientists should be developing writing and English communication skills, I'm not quite sure that SLOGs are the best way to do so. I've talked to a lot of people that have let their SLOGs fall to the wayside, and while that's definitely a fault of us lazy university students, writing is a really important skill that needs to be developed, and I don't really think that SLOGs are able to give this skill the emphasis that it needs. I would much rather see a separate course that's devoted to improving writing skills for computer science students, as I've seen some friends in Engineering and Life Science take. Alternatively, perhaps the SLOGs could be a little bit more directed, such as having them written in tutorials right after a quiz, or replacing it with some sort of writing assignment, maybe a mock-up of a document that fully explains a code and how it works, similar to the ones that real-life programmers do in the workplace. That being said, SLOGs are definitely an excellent step forward in recognizing that developing communication is important for computer science students!

Week #8-10 - Impressions of Week #7-9

In week 7 we began working with binary trees and binary search trees. This was an interesting continuation of what we had learned earlier regarding trees earlier. The other thing was the start of our working on Assignment 2, particularly minimax, which is probably one of the most complicated codes I've ever written for this class. It was definitely good to get an in depth explanation of what exactly it was supposed to do in class during this week, otherwise I might have been even more confused during the assignment. I also really like that we're starting to touch upon the realm of AI type codes, even this is obviously a hugely simplified version of it. It's just really cool to work on this code and think about how the base concepts might be built upon to work on really sophisticated programs later on.

Week 8 was the beginning of the strike, and as such the lack of tutorials and quizzes, which made it a little bit harder for me to keep on task and focus, I will admit. I am just glad that the labs for computer science are things we can work on at home, unlike for something like life sciences or physical sciences. We also started linked lists this week! One thing that I found a little hard to get used to was using a wrapper class, because I was used to only having a class for the nodes themselves, but after wrapping my head around the concept (pun fully intended), I realized that it's probably a much more efficient way to handle the concept.

This was also the week we finished working on Assignment 2, which was definitely harder than I expected! Shoutout to Dominique and Sophie, my wonderful lab partners for putting up with my perpetual lateness and inefficiency in writing minimax. Luckily the rest of the code wasn't super dependent on having that finished first. I ended up departing a little bit from how minimax was intended to be written. Specifically, having the scores multiplied by negative one through each level of the tree, to reflect that a win for one player was a loss for another. Because implementing it that way wasn't working out that well, what I did instead was keep the values the same, and have it from the perspective of a single player. Instead, I alternated using max and min to reflect that on either player's turn, they would make use of the best strategy available to them. I was a little wary of not doing it exactly the way the assignment expected, but when I talked to Danny during office hours, he seemed to think it was okay, so hopefully that's not something I lose marks on!

Week 9 was our second term test! I originally left the test thinking that I done really well on it, but looking back, I remember that was also the day I had to hand an essay for ENG237, and as that essay was worth 40% of my mark, I put a lot more effort into it than studying for the test, which I think reflected in my mark. The biggest mark loss I had on the test was actually from not reading the instructions properly, which is ironic because I was up late doing literature analysis. The other mark loss is something I'd like to get re-marked though, since I wasn't sure if the comment said "front case" or "float case", but either of those cases should have already been handled.

Week #7 - Recursion

So at this point, I should explain that I was not aware that there had been assigned topics for each week (after coming out of CSC165 where we just wrote about the course in general each week, I assumed it was the same for this course, aside from the assigned topics for weeks 3, 7, and 11). Because of that, I can't exactly refer back to an earlier post, so I will instead just be writing an entirely new post about recursion and hoping with luck and/or the TAs on my side, this will be counted.

Recursion has always been one of my favorite parts of computer science, because I think it was the first time I began to see computer science as an actual science instead of just a fancy name for programming. Until then I saw computer programming as purely something functional, without really understanding how things like scientific theory could really be relevant to it. For once, I was very glad to be proven wrong.

A recursive function is, to put it simply, a function that calls itself. This is generally done when it is logistically easier to call the same function over and over again instead of writing a function that does the same thing multiple times within the function body. An important part of recursion is the idea of passing through values or arguments through a function multiple times, What's always helped me to understand this concept is those pictures-within-pictures, like this one: http://i.imgur.com/YnXn1.jpg When you think about it, the original picture is actually the smallest version of the picture, in the very center, and that value (the picture) is just passed through to the outer frames, which sort of recursively recreate the picture. In computer science, the smallest version of the picture might be the leaf of a tree data structure, or a single integer, and that's just passed through the layers of recursion multiple times. The difference between computer science and the picture example is that in computer science recursion, generally a change is made to the value every time it passes through the recursion.

This week focused on tracing recursion, an integral part to understanding how to write recursive functions, especially ones that involve passing through arguments. This is where we depart from the comparison to a picture within a picture, because in class we've primarily focused on examples of recursion that sort of gather multiple values together (as can be seen by the example we worked on class that summed lists together). The general concept is still applicable of course, with values being passed through and the recursion being called multiple times. I didn't find the tracing example too confusing, but of course being able to trace recursion is so much easier than having to sit down and write your own recursive function. That being said, the tracing was a great way to force yourself to visualize exactly what the function is doing, which will be very helpful in writing future recursive functions.

Week #4 - 6

Life is a little less crazy at the moment thanks to Reading Week, which means I can finally catch up on my very long overdue SLOGs!

In Week #4, our main focus was Assignment #1. Luckily, I had a group that I had worked with frequently from CSC165, and we still worked together very well. I was particularly interested in this assignment because one of the reasons I got into computer science was that I was really interested in video games. Although this was a really basic video game, I enjoyed being able to experience the process behind it. One thing that I definitely learned from this assignment was just how much effort had to go into all of the little details, like style checking, and docstrings (something that has always been the bane of my existence). Thank god I had other group members with me, I think I would have gone crazy if I had tried to do all that by myself.

Week #5 was pretty crazy, because I had, in addition to my CSC test, a Political Science paper due and an English test on the same day! Combined with an appointment I had on Thursday that forced me to miss my tutorial, not a lot of time this week for this class in particular. Luckily, I think I already had a pretty good understanding of Stacks and Queues from previous experience. It was definitely a good refresher though, doing the lab on my own time.

Week #6 was the beginning of our work with Trees which was definitely a really interesting aspect of recursion, and will probably from a lot of food for thought for next week's SLOG. Watching everyone walk around and recreate the tree in real life was a really good way for helping to understand it. This lab this week was pretty fun as well, except for a weird error I had when trying to use Gather_lists on lists that contained multiple nested lists with different depths. Although I got closer to a solution, I wasn't able to actually solve the problem entirely, which is something to work on for next time!

Week #3 - Why Geeks Should Write

For too long there has been a stereotyped perception of geeks as people who spend all day indoors, on their computers, playing video games, and not fully participating in the rest of society due to their lack of social skills. While that stereotype as a whole is not one that I can effectively dismantle in a single blog post, one aspect of it is very relevant to the question of why geeks should write. Specifically, the stigma that "geeks" are incompatible with the rest of society stems from the idea that geeks are not able to communicate in the way that other people are. This stigma extends into writing, as a form of communication.

Computer science as a field of study and a profession has been perceived by the rest of society as being largely populated by these "geeks". Unfortunately, this means that people have a different set of assumptions of a computer scientists ability to communicate and socialize with the rest of society, and this makes it all the more important that that stereotype is shattered.

This is especially important in this specific field of study and profession. Computer science and computer programming deals with concepts in fundamentally different ways, often through different languages. Having to express these concepts in multiple languages is difficult to do without having practiced writing skills already, particularly when trying to explain complicated technical ideas with relatively simple language and a lack of computer-science jargon.

It is also true that the field of computer science extends beyond just having to write code. Even within code, a docstring needs to be written in the English (or otherwise) language. Outside of coding itself, research grants, job applications, papers, advertisement, or even just communication with coworkers and employees all require a firm grasp of the English language and being able to use it with precision.

A lot of these reasons for geeks writing are things that can be applied to any person or any field. Many fields have complicated jargon that requires someone with good writing skills to explain to a layman. Many jobs require communication with coworkers and other such examples of writing as outlined above. But combined with the average person's need to write properly is a stereotype that we, as geeks, as computer scientists do need to combat until it is gone entirely.