Programming with Python, CSC148

[procsc148experience-blog]

Week 11: Coming to an end

As we approach the end of the course we look more deeply into algorithm run times, and how to determine run time by glancing at code. We learned about Big O and how we generalize run times of code into the big O of a function, due to its similar behaviours when given really big inputs (in worst case scenarios). Other than this, I’m really happy with the materials I have learned over the past semester in this course.

Reflecting back on my first few reactions into the course, I feel like my understanding of computer science has become a lot deeper and meaningful. Where before this course, I was able to understand syntax and basic classes/attributes of Python (such as Lists, Dictionaries, Strings, etc) and implement this properly in assignments, this course taught me to think bigger than just those classes, and more into how to process data in different ways. Examples of this being trees and linked lists.

Doing the assignments in this course helped me solidify my understanding of all concepts in this course, from overriding functions or extending classes to trees. In the first assignment we worked with about 8 classes where many classes were used within other classes. Realizing how complicated tracing the code to find bugs was, we finally took away how to use the debugger from this assignment. Also, this assignment made me realize how crucial it is to do an overall analysis of the program due to how dependent the individual classes were on each other. In the second assignment however, we implemented a lot of new concepts learned in the course. I learned how to implement trees using depth-first searches and breadth-first searched, using the help of queues and stacks. Also working with puzzles gave good practice of visualizing how extensions of puzzles would be used in solving the puzzle (since the solving functions were common to all puzzles).

[procsc148experience-blog]

Week 9: The second chance

After recursion, trees, and binary trees we also explored another form of a tree which was more of an extension of a binary tree, called binary search tree. With the same intuition and attributes as a binary tree, it differs from it by being organized. When our prof showed us the power of this kind of tree and how it could exponentially reduce search time, I was at awe. It was crazy how it could search through about 1,000,000,000 pieces of data in just 30 steps in the worst case scenario to a specific node. That’s crazy!

Although this concept was really intriguing I couldn’t really pay attention to it’s implementation and practice it much due to the energy that studying for the test was taking, this was my second chance. So this time, even though concepts were clear to me I took time to practice writing all the API from Linked Lists to Binary Trees on paper, due to the lack of practice I had for writing code on paper for the 1st test, wasn’t going to mess this one up. I was still paranoid and nervous as the morning of the test approached, and felt I was still unprepared for this test as all I had done was practice API implementation. After the test I was really happy because I actually finished the whole test, with still a few minutes to spare and look over my work. I felt confident that this was the test that was going to save my test 1 mark thanks to the new marking formula.

[procsc148experience-blog]

Week 8: More Trees

After a good intro to recursion and trees and some rigorous practice with implementing them we expanded on these concepts as we learned about new kinds of trees. Now instead of having a single list of “children” of a tree, we learnt about binary trees which have a left and right “child”, so 2 children at most. Implementing these kinds of trees is a bit different although the overall idea remains the same.

Some problems I ran into while learning how to implement this type of tree was making sure to consider the case where one “child” (either left or right) was none, while the other wasn’t. Other than that it wasn’t too much of a problem coding the different aspects of this tree. Also our lab was not on binary trees, so that was also not much of a problem.

Still loving these concepts and having a lot of fun implementing trees with and without recursion! Hope to learn even more! :)

[procsc148experience-blog]

Week 7: Recursion and Trees

As we just began recovering from brain exhaustion as a result of our first assignment/program, the course takes no mercy on us as it bombards us with yet another assignment. I hear my brain fart, as I mentally hard reset it to get it working for the next wave of impact. Jokes apart, I’m happy that we get our next chance to apply what lessons we learned from assignment one. Not taking this one easy, our team has already started reading through the handout and taking notes for this assignment.

Week 6 introduced us to recursion leading straight into week 7 where we solidified this concept and applied this in programming using trees. The thing I found really interesting and crucial to the understanding of trees was the analogies that were made by our professor in order to motivate this concept (for example, children, leafs, roots, etc.). Although recursion in itself was an intriguing concept, the way we write it all in one line using list comprehension and shorthand “if, else” statements is mind blowing!

I didn’t really have much of a problem picking up the intuitive idea of recursion. Moreover, tracing many examples of how inputs are processed using recursion really helped me in getting a deeper understanding such as the exercises we were given in class before we actually tried programming them. A crucial thing our professor stressed in the tracing was not to go too deep when tracing a nested list as it made things more confusing. Some functions get confusing especially because of how many things we’re doing in one line. I am still familiarizing myself with how to incorporate functions such as “any”, “max”, etc. to write efficient recursion code.

[procsc148experience-blog]

Week 6: The aftermath

Trying to recover from the fall, and deeply pondering my career, I finally came to my senses and stopped taking things lightly. Even for the program (assignment), I assumed we would easily finish it, but little did I know the depth at which we would be analyzing the program some time before the deadline. Although the program had no errors and was running fine, the output was not right. Thinking this was just a small issue, my partner and I left the rest to the last few hours, but from trying to fix one function we ended up having to fix many other problems which were even harder to solve than syntax error, because these were semantic errors. Since the code had many classes working together we had to trace back almost 7 to 8 calls back to find and pin point the problem.

From this downfall, learning my lesson, I am definitely taking away that computer science is actually getting more complicated and I will have to prepare a lot more ahead of time than previously expected. 

Moving to the content learned this week, Recursion! Definitely I think recursion is an amazing concept, kinda like inception! Function just calling itself over and over again (function inside a function inside a function = funception!). The cool part is how everything is written in only one line, using list comprehension and so on which. Tracing how inputs are processed using recursion really helped me in grasping this concept. Looking forward to learning more about recursion!

[procsc148experience-blog]

Week 5: The Test

So this week was fun, as all weeks are in comp sci classes and labs, but then it happened. The test hit hard. I felt really prepared after trying out past midterms and not having much problems with them. Also clarified what ‘the container class’ was, which turned out to be barely anything, feeling really prepared. Usually I do really good in these comp sci tests, they’re my thing... so was this. The only big... no, HUGE problem was that the test was meant to be written throughout a whole day (a bit sarcastic but you get the point)! All that writing classes (including docstrings) was the death of me, barely got through half of it. Really taught me a lesson though, don’t take computer science lightly. First time a computer science test has gone so badly, only way to improve this is practice writing classes (and programming in general) really quickly on paper.

[procsc148experience-blog]

Week 4: New stuff; Stacks, Sacks, and Queues

No more playing around with PyCharm, this week was when we actually dove into some new material. It was pretty cool seeing new tricks done with lists, as they were not used in just old boring ways, but this time got extended to give them unique characteristics. These different types of lists that we learned were stacks, sacks, and finally last but not least, we worked on a third way to represent lists in our labs, which were called queues.

A great representation we saw was done by our amazing prof., Danny Heap, as he pulled various things out of his “sack” (backpack), showing us what a random way of drawing out objects from a list would intuitively look like. Not only that but our TA actually got serious about the CSC148 material (up till now which he thought was a joke).

Early in the week I wasn’t able to understand exactly what stacks and queues were and how this would work, but then of course our labs really helped us grasp this knowledge where I took in the powerful ability of such lists. Our lab quiz was also on queues. This lab quiz went pretty well because my partner and I took our time visualizing and really grasping the logic of such lists during the lab.

Week was pretty blessed still!

[procsc148experience-blog]

Week 3, First impressions/reactions

The transition from CSC108 to CSC148 has been pretty smooth so far. I am glad that i took CSC108, even though it was the online section, I feel I developed a deep understanding of python and the way object-orientated programming works. In fact I really liked the online concept of CSC108 compared to a lecture concept, it allowed me to experiment with python along with the lectures and made the learning more interactive. But my first experience with the labs last week was very satisfying as it made all the concepts learned in the lecture come together nicely in the lab we had to do.

In these first few weeks picking up pycharm IDE has been a weird experience. It feels a bit confusing compared to wing IDE, but being more complicated means it’s probably more professional, which is exciting!

Enough about the transition now, let’s actually get into the course material of CSC148!

Working on a new format of docstrings has been exciting… because this time they actually help instead of just being blocks of boring text. Like the @param feature of writing type contracts. Also discovering new ways of writing code in much shorter ways has been interesting, such as writing a for loop in just one line! Pretty cool!

Some things in the first few weeks were pretty challenging. One such thing was comprehending a paragraph given to us by pin pointing the exact things we need to create from it on python, such as picking out what class(es) to create, which attributes to create for the class, which methods to make, etc. This is becoming easier as we practice it in lectures. Another challenge in the first few weeks i found was working with superclasses and classes. More specifically how they interact by extending methods, overriding methods, etc.

I hope on learning a bunch of python ‘stuff’ this semester, and am excited to apply the knowledge in labs and Assignments