My SLOG Posts

[course-log-148-blog]

Week 12: Final SLOG

For my final SLOG post for this semester in CSC148, I’ve decided to discuss briefly about my overall thoughts on this course, how helpful it was to my learning, and my general impression of the course material. I felt as though this course really provided me with a deeper and more thorough understanding of the subject matter, and in turn allowed me to demonstrate my understanding through course assignments and tests. The assignments were especially challenging, however, they were extremely conductive to my learning. I feel as though I am more confident in my skills as a computer programmer, and this course played an integral role in this newfound confidence. Additionally, the overall instruction in this course was very precise and detailed, and my instructor was very engaging in their teaching styles, which was also extremely helpful in my learning process. Overall, this course really broadened my horizons and showed me the endless possibilities in the field of computer science, which I find quite exciting and motivates me to continue my studies as a computer programmer!

[course-log-148-blog]

Week 11: Reflection

As the weeks went by in CSC148, I felt as though each week I was gaining a firmer foundation and broader skill-set as a computer programmer. Naturally, my progression as a computer programmer led to a progression of viewpoints that I previously held for certain aspects of computer science. So this week, my primary focus will be reflecting on the development of my viewpoints for trees by revisiting my previous SLOG post during week 8. On my week 8 SLOG post about the recursive data structure known as trees, I revealed my skepticism on the usefulness of introducing such a topic. In essence, I didn’t feel that we should even invest time in learning about trees due to my lack of understanding of real-world applications of such data types. Although I developed an intuition on what trees were, how they behave, and how to traverse them, I didn’t quite fully understand how they can be used in solving problems. Using different techniques and data types in order to solve problems in the real-world is, in my opinion, the main goal of a computer scientist, and this is where my reluctance and apprehension arose. However, now in week 11, my viewpoint on the usefulness of trees has flipped and my skepticism completely negated. Working on assignment 2 was integral in expanded my familiarity with trees that is not only limited by understanding them abstractly, but also how they can be useful in solving real world problems. For something as general as solving puzzles, data types that mimic the structure of a tree can prove to be extremely useful, which was evident by the class PuzzleNode on the assignment. With this in mind, it is much clearer to me that trees are not only data types that help you with understanding recursive behaviour, but they more importantly have fundamental implications on the real-world by applying them to solve various problems. From solving general puzzles for assignment 2, to dealing with order of operations for arithmetic expressions, trees can be used to solve a wide variety of problems, something that was not completely evident to me when first introduced it. Now I believe that learning all about trees is not only useful, but essential in progressing as a computer scientist!

[course-log-148-blog]

Week 10: Algorithm Efficiency

As another week comes to a close, it opens up the opportunity for another blog post about my experiences in CSC148. A huge relief has been lifted off my shoulders in terms of workload, since Assignment 2 was handed in just yesterday and term test 2 results have been given back. I was especially relieved since my hard work in preparing for the test certainly paid off. 

This week’s lecture continued the topic of implementing an algorithm for a delete method for binary search trees, but also introduced a new topic (or not so new topic for me) about algorithm efficiency and a quick preview into Big O. Because we finished up implementing our algorithms for bst_delete both recursively and iteratively, this provided a nice transition into the topic of algorithm efficiency, exploring which algorithm was more efficient in run-time and in terms of memory usage. Although I found it easier to write the algorithm recursively, this algorithm proved to be extremely inefficient with regards to memory usage in comparison to the iterative approach. This conclusion brought up a very important branch of study in computer science which analyzes not whether your algorithm works, but how well it works. We learned that although it may have seemed that the iterative approach for bst_delete was faster for run time, both approaches are seen as equally as efficient. This is where Big O sets, a concept that I’m already fairly familiar with due to CSC165, come to play which shows the function derived from the run-time only depends on the order of it, not the coefficients or constants. The importance of algorithm efficiency was more drastically emphasized by examples where different algorithms were placed in different Big O sets (constant, linear, logn, n^2, etc...). Given a large input size, the most efficient algorithm, being in the constant set, can take mere milliseconds to complete while the least efficient algorithm (O(n^n)) can take thousands of years to complete the same code with the same input size.

I found this topic to be very interesting since it brings a whole new dynamic to play, where you are not only worried about if your algorithm works, but how efficient it is at doing its job as well. As always, I look forward to learning more about algorithm efficiency and any other new topics yet to be introduced in class!

[course-log-148-blog]

Week 9: Term Test 2

This week was a tough week for me, personally, since the majority of time I was feeling under the weather. However, this didn’t stop me from continuing to work on Assignment 2 and practice implementing more recursive methods for binary tree structures. Also, since term test #2 was held this week, I wasn’t given much of a choice in taking a break from school work to fully recover. The test covered many topics that I already felt comfortable with which mostly included linked lists, recursion, trees and binary trees which made studying for it much easier. All in all, I found the test to be quite enjoyable, which is partly due to the extensive preparation I did beforehand. Now with test #2 behind me and the cold that was bugging me all week done with, my attention can now go to in finishing Assignment 2 and continuing my studies in CSC148!

[course-log-148-blog]

Week 8: All about Trees!

This week’s topic was all about trees, how to traverse them and all the different ways to use them. At the beginning I was skeptical on the usefulness of such a topic being introduced because I initially didn’t see how this tied in with everything we have learned so far in this course. However, the more I learned and was exposed to the topic, the more the skepticism faded away. Trees mimic linked lists in the sense that trees are made up of nodes that contain references to other nodes (or None) just like linked lists. Trees are also recursive data structures because they are defined with other tree references (recursively defined). With this information in my mind, the introduction of trees neatly fits in the concept of recursion and linked lists which contrasted my initial opinion of trees.

Despite relying heavily on recursion when traversing and building trees, it wasn’t a difficult concept to understand right away due to its intuitive definition and use of metaphors when describing it. Personally, I caught on quickly to how to deal with and understand trees as opposed to recursion which took some time for the concept to settle in. The biggest reason for this is due to maintaining real-life metaphors when describing trees. As its name suggests, this data structure is often compared to real life trees where the topmost node in a CS tree is called the root, the bottom-most nodes are referred to as leaves, and internal nodes are often called branches. They can almost be visualized as an upside down tree. In addition to this, trees often carry another tree metaphor which is the family tree. Nodes that refer to other nodes are called parents, children are one of the nodes being referred to, and siblings are nodes with a common parent. This intuitive approach when defining trees helped me grasp the concept almost immediately and with this was able to gain a deeper understanding to what they are, how they are built, how to traverse them, and the possibilities that exist in using them. 

The most common type of tree is a binary tree, which is simply a node with at most two references to two other nodes. One way in which trees could be used is when dealing with arithmetic expressions where binary trees prove to be useful in sorting the issue of order of operations. This is just one of the many examples that these data structures can be used to tackle problems.

With under a month to go in the school semester, there is still much to learn in CSC148 and I look forward to it!

[course-log-148-blog]

Week 7: More on Recursion!

In this week’s lecture we delved further into the concept of recursion and understanding how to implement recursive functions ourselves. As such, I concluded that there is no better topic to write for my Week 7 SLOG post! From my understanding of the concept, a recursive function is  defined as the calling of a function from within the same function. Since that is a mouthful to say and was initially hard for me to process, it can more eloquently and simply be understood as a function that calls itself. In these functions at least one base case (a terminating scenario that does not use recursion to return an answer) must be present along with at least one recursive case being present (meaning the function recurs). The reason why recursion is such an important tool in the arsenal of a computer programmer is because it allows some problems to be dealt with in a few lines of code whereas it would take on an immense amount of time and effort if you dealt with the problem iteratively. This is especially pronounced with solutions to problems that depend on solutions of smaller instances of the same problem.

Recursion was an idea that hurt to think about and was particularly difficult to grasp at first. The greatest difficulty I encountered when coding and analyzing recursive functions was processing and visualizing what the code was actually doing. Many times as I was coding recursive functions I wasn’t entirely confident that I implemented the code correctly, due to this lack of clear understanding. Debugging the code only proved to be worse since it just added to the general chaos that was happening in my brain since compilers deal with recursion with stack-based visualization which differs greatly compared to how humans actually visualize it. The strategy that was most helpful in reducing the confusion was tracing, tracing, and even more tracing! By extensively tracing through increasingly complex examples with the pencil-and-paper technique I was able to more clearly visualize what was happening. i felt like the learning curve was steep for recursion but once you deal with enough examples, trace the code manually, and implement recursive functions yourself, the concept becomes much more clearer. 

As I previously stated in my last blog post, my curiosity of the concept led me to stumbling upon a real-life example of recursion that I found quite intriguing. If you place two mirrors exactly parallel to each other, they produce nested images, creating form of infinite recursion, something not desirable as a computer programmer but interesting nonetheless. With more digging on the topic I realized that recursion happens all around us and pervades many fields of studies such as mathematics, linguistics, computer science, and so on. The Fibonacci sequence and the factorial are great examples of how the concept of recursion shows up in mathematics. It even shows up in ancient Greek symbols such as Ouroboros (a picture of a dragon eating its own tail) which symbolizes cyclicality and the concept of recursion.

Now that recursion is cemented clearly in my brain I feel more confident as a computer programmer and look forward to discovering more applications of it in both the real world and when programming!

[course-log-148-blog]

Week 6: Introduction to Recursion

In this week of lectures, a central idea in computer science was tackled. This topic is none other than recursion.

Although we did not go into depth on what it means for something to be recursive, I reached a general comprehension of the topic through the examples of recursive functions given and tracing these functions extensively, with increasing complexity each time. From my understanding, a recursive function is the calling of a function from within that same function. This being my time being exposed to recursion, this was a considerably difficult idea to grasp at first, however, as I was exposed more and more to this idea through intuitive examples, it became much clearer. From what I learned, a recursive function has one or more base cases, and at least one recursive case, meaning the function recurs (calls itself!). 

Being curious of the concept and wanting to explore the idea further, I stumbled upon a common real-life instance of recursion that I found extremely intriguing. Placing two mirrors exactly parallel from each other produce nested images, creating a form of infinite recursion! 

Overall it was a great week! Assignment 1 is finished and submitted, and I am very pleased with my test #1 mark. With week 6 done, I look forward to learning more extensively about recursion since it is a very strong tool in computer science, along with it being a very interesting topic. 

[course-log-148-blog]

Week 5: Linked Lists

As the weeks roll on, so does CSC148, with the most prominent event being our first test of the term. Although I felt the test to be somewhat short given the material we had to cover in that timespan, I remain hopeful that the test was representative of how much I have grasped in these past few weeks!

Along with our first test, this week’s subject matter was dedicated entirely to the motivation and implementation of linked lists. From my understanding,  a linked list is a data structure where each element is a seperate object. In essence, it is comprised of nodes that are “linked” together to form a single list of elements. Each node (or element) consists of two items - the value of the node and a reference to the next node, with the last node referencing to None. 

The motivation behind a linked lists is its advantages compared to a regular Python list. A linked list is a dynamic data structure that can efficiently grow and shrink as need, reserving just enough memory for the object value they want to refer to, a reference to it, and a reference to the next node in the list. On the other hand, A Python list allocates large blocks of contiguous (together in sequence) memory, which becomes increasingly difficult as more elements are added to the list.

However, the disadvantage with linked lists is that it does not allow direct access to each individual element. If you want to access a particular element, you have to start at the front and follow the references until the desired element is reached.

Overall, another great week of learning and now I set my sights in tackling the first assignment of the term. Wish me luck!

[course-log-148-blog]

Week 4: What I Learned

Although this week’s material only touched upon a few new concepts, it proved to be just as informative and interesting as the first three weeks, if not more!

We furthered our understanding of previous concepts, such as composition, inheritance, class hierarchies, and inheriting/overriding/extending methods in subclasses, through the development of the Stack and Sack ADTs (advanced data types). I found this extremely useful in solidifying my understanding of topics discussed in last week’s class since it provided us an opportunity to apply all these concepts by designing the Container, Stack and Sack classes. We even discovered a very practical application of the Stack class, in which we used this newly developed data type to solve the problem of parenthesization.

In addition, this week’s class re-emphasized the importance of testing when designing classes. Just as in any manufacturing company, the product is not finished until it is tested thoroughly. The same ideology applies to computer programming! To tackle this, we introduced unittests, a new (or not so new for CSC108 students) framework to setup test cases, run them independently from one another, document them and reuse them if necessary.

Lastly, we briefly discussed the shortcomings of regular Python lists, and introduced a new data structure, linked lists, as an alternative that bypasses these shortcomings.

All in all, it was a very productive week in terms of my understanding of topics covered in class, which is perfect for the upcoming test next week!

[course-log-148-blog]

My First SLOG (Week 3)

Being new to blogging and not knowing what to write, naturally, my first tendency is to write about the course and my opinions of it so far. That being said, for my first SLOG I will give a brief rundown of what I’ve learned so far and my general impressions of the course.

The first lecture acted as a transitional class from CSC108 to CSC148, reviewing concepts learned in previous courses. However, we also delved into the heart of object-oriented programming through the introduction of objects and classes (also know as advanced data types), and their relationship with each other. 

As the weeks progressed, we extended our knowledge of classes by exploring superclasses, subclasses and class hierarchies, discussing real world intuition of what those concepts meant and how they interact with each other. Also, the introduction of terminology and concepts such as special methods, attributes, abstraction, inheritance, composition and exceptions made for an eventful first three weeks!

Overall, I look forward to learning more in CSC148 and further extending my knowledge and skills as a computer programmer.