Week 12 : Final Impression of CSC148

                This course was very enjoyable for me, I found I was always interested in what we were learning and I find that to be a great way to lean. The way this course encouraged group work through the assignments gave me great experience with working in a team, which I believe will be very beneficial to me in my career. I was very happy with using python this year as I believe the simplicity of the syntax allowed for faster and easier learning of concepts, which gave me a great taste of object oriented programming projects. I have friends at other universities that used other languages such as C and they are far behind because of the difficulty of the syntax and language slowing them down.

                Over all this was my favourite class this term and I think that is a good sign since I hope to specialize in computer science! I wish everyone luck on the exam!

Week 11 : Reflections on Recursion

In weeks 4 and 5 my posts were mainly on the topic of recursion and my immediate fascination with it. Since that time I have had a lot more first hand experience with recursion through the assignments and labs, and my fascination has not been broken. I have read in other students slogs that even though they may have previously learnt about the concept of recursion they did not learn how to trace recursive functions. This was the same for me, I knew what recursion was and how to use it by I found it really confusing at times, especially when trying to understand a recursive function I did not write. With the method of tracing recursive functions taught in this course, I find now with practice I can look at a recursive function and understand what it is doing just as easily as one that uses loops.

In Jesse’s slog on recursion he talked about his initial thoughts on recursion and how recursive functions end, being as I was, initially confused on the topic. I like how in this course it is taught to first think about a base cause that would not need recursion. Doing this in a way makes you think about how the function is going to end before you even start the recursive body of the function. I believe this method of writing recursive functions, makes it much easier to tackle a new recursive function, taking away most of the thoughts of “I don’t know how to start this”.

Week 10 : Impressions of Week 9

               

                In week 9 we did not learn much as we had our second term test on the Wednesday. On Monday we reviewed binary search trees for the test which I covered in my week 8 slog. I found the test to be very fair as it covered all of the big concepts we have learned since the last test. We had done a lot of class work on binary trees and binary search trees and this was reflected by the amount of question on the subject on the test. When studying for the test I mostly just reviewed the slides from each class we had after the first test, making sure I understood and knew all of the information, but my main focus was redoing all of the labs on the topics present on the test. I find this to be the best way to study as by completing the labs you show yourself that you understand each topic very well. I also find it helpful to sometimes write out my lab answers on paper as that is how it will be on the test.

Week 9 : Impressions of Week 8

               In week 8 we learnt about the data structure linked lists. Just like trees, linked lists are made up of nodes which point to other nodes but in linked lists each node can only point to one other node, this node is called the next node. The first and last nodes in a linked list are kept track of in the linked list class and are named the front and back nodes or sometimes the head and tail, as seen in the image below.

                 When I first tackled the linked list lab I found it a little confusing and I was unable to get the first function in the lab to work as intended. Since this type of mutable and iterative data structure was new to me I knew that before trying any of the functions I had to play around with the class and draw lots of picture until I felt that I had a firm understanding of linked lists. Sure enough after I had done this I was able to complete all of the functions/methods without problem.

Week 8 : Impressions of Week 7

               In week 7 we learnt about the data structure called Trees, and more specifically binary trees. Trees are a way to store data, we also learnt that different position in a tree have different names. In the image to the right you will see a binary tree, each circled value in the tree is called a node and the top node, 8 in the tree to the right, is called the root. Trees in computer science are upside down to trees you would find in nature, so the nodes at the bottom with no children (children are nodes extending from other nodes), are called leafs. Trees can have as many children as given to them but the special type of tree called a binary tree can only have two children.

                Since nodes in binary trees can only have two children they have special names, right and left. There is also a special type of binary tree called a binary search tree, the tree mentioned earlier is actually a binary search tree. In binary search trees data in the left subtree of a node is less than the data in the node and data in the right subtree is greater than the data in the node. While learning about binary trees we also learnt about binary tree traversals.

                There are three ways we learnt to travers a binary tree, inorder, preorder and postorder. When traversing inorder you visit the left most unvisited tree, then the node itself then the right tree, always repeating this algorithm recursively, I remembered this by remembering the order of three letters, L, N, and R (LNR) L for left, N for node and R for right. One thing that I noticed when traversing a binary search tree inorder is that you visit the data in the tree in sorted order from least to greatest. When traversing the tree in preorder you first visit the node then the left node then the right node repeating this recursively with each node visited (NLR). With post order you first visit the leftmost node then the right node then the node itself, always repeating this algorithm with each node visited (LRN). The way I remember the algorithms is with the letter orders I have been putting in parentheses. The algorithm for inorder is LNR (left node, the parent node, right node) and I remember this because each combination has L before R and with inorder the ‘N’ is in-between ‘L’ and ‘R’. I remember preorder as the ‘N’ is before (pre) the L and R so NLR. I remember postorder as the ‘N’ is after (post) the L and R so LRN.  

Week 7 : Object-Oriented Programming

                Last time I posted about what we had learned about object-oriented programming up until that point, and I had stated that I found inheritance to be a very interesting and powerful. This power was very well shown in assignment 2 where we were able to wright game strategies that would work for multiple games (subtract square and tippy in this case), without any game specific code. Along with the power that comes with object-oriented programming in python, there may arise confusion on how to make inheritance work in the way you want it to.

                I find that the best way to overcome these confusions is to play around with the things that are confusing you until you have a thorough understanding of what is happening. The best way to do this is to create a very simple class and then make another class be a subclass of that class and then slowly add and test things so build your understanding. As an example I was confused about how to changes methods in the subclass but still retain the basic aspects of that method in the subclass, through this experimentation process I quickly found I could just use the original mothed in the new one (by using something like this SuperClass.methond()).

Object-Oriented Programming

Up until now we have been learning the basics of object - oriented programming in Python. We have learnt how to create our own objects by creating classes with certain attributes and how to give the objects their own functions known as “methods”. While you can create your own methods that can do anything a function can do, we have learnt about the special python methods. These methods allow you to do things within python like check if two objects are equivalent (with the __eq__ method) and create a string representation of the object when you print it or use the str() function. These special methods are identified by being surrounded by double underscores e.g., __str__. One thing that I always wondered while using Python was if there was a way to make objects and attributes private as you can in most other programming languages, and I found out you cannot but we did learn a way to mimic privacy. This is done using Python’s built-in property() which basically allows you to control what happens when you try to change and access an attribute of an object. In class we used property() to only allow a variable to be set by the user once by controlling what happens when you try to change the value of a variable. We learnt that if you want an attribute to be untouched you up a “_” before the name, this does not actually make it private but it tells the user that it is at their own risk to change it.


The most interesting and useful thing we have learnt in OOP so far was how to make objects inherit attributes and methods from other objects. This was the main focus of assignment 1 and I think it was very helpful for it to be so. Understanding how to make a base class that covers all of the base needs many other classes will need is very helpful as it saves coding time and helps prevent errors from copy-pasting code.

Tracing Recursion

                Last week I talked about how interesting recursion was to me, and since then I have read the SLOGs of many other students who are also very interested in the topic. Among the SLOGs I read was Jesse’s who in his post entitled “Wrapping my head around recursion” took an amusing baked dessert look on recursion. In week four we learned how to properly trace a recursive function so that we can understand how a function behaves with different inputs and eventually prove that any input will work with the function (with certain conditions). This is done by starting with the simplest (or shallowest) input you could input and tracing deeper and deeper calls (one depth at a time). In the processes you do not have to rewrite a depth you have already tried as you have already proved that the function works with that depth.

                I find this method of tracing a recursive function very helpful as it can be used to trace most recursive functions no matter the complexity. Some students seem to find it pointless with the function we have been practising with as you can figure out most of them in your head without this method, but that is not the point of us learning this method. This method is meant to help us with any recursive function that we may come across and for that I find it extremely helpful.

The First Four Weeks of CSC148

                In the first four weeks of CSC148 we have learnt about classes, subclasses (inheritance) and recursion. Although it was very valuable to learn about classes and how to make other classes inherit all of the methods and attributes of another class, in my opinion the most interesting instrument that we have learnt in the first weeks is recursion. At first recursion is a very abstract thing to think about, a function calling its self in its own definition. 

                When you eventually wrap your head around what is happening you will realise that it is basically the same as a conditional loop but a lot cleaner and simpler to implement. Recursion allows you to use a function that would normally only work with a finite number of instances and allows it to be used for an (almost) infinite number of instances. As such recursion makes creating algorithms based on repeating tasks (such as sorting) much easier to implement.

Why Geeks Should Write

                In today's connected world an idea can be shared with anyone almost instantly. This sharing of thought and knowledge makes it possible to lean almost anything you could imagine just by searching for it on the internet, but if you do not know about the existence of a topic you would never know to search and learn about it. This is why geeks should write (more than they do). Although geeks do write and share information, this information is normally found in places where “non-geeks” would never look and is often explained in ways that only another ‘geeks’ would understand. This is why geeks should not only write more but should write in a way that anyone could find and understand the information.

                People in professions such has humanities are great at getting their thoughts and knowledge out to the masses. This means that many people know at least the general idea of the topics in their field and can learn more about them if they please, the same cannot be said about things “geeks” are interested in. The very fact that geeks are referred to as “geeks” shows that what they are interested in is not considered normal, but why shouldn’t it? Everyone in the modern world with a mobile phone uses technology created by “geeks” almost every day of their lives, and very few of them understand how the technology and software that make up their devices function. The fact that people use technology everyday shows that there is a very large following for the things geeks are interested in so why shouldn’t people at least have a chance to understand. In this world of many professions and ways of thinking, sharing is the only way to progress together.