Week 4

It feels like this course just started yesterday and now we're already finished one third of the course. The first four weeks have been interesting and I'm learning a lot which is making this class very enjoyable. The first assignment was submitted recently and there were a bunch of remarks about the assignment. The one aspect of the assignment which I felt should have been changed was the method we needed to use to make it.

We were not given a list of functions we needed to implement which was good, however, at the same time we were required to implement certain classes in a way which could have been changed. Apart from that one small aspect, I feel like the freedom given on the assignment was good and the assignment itself was a nice assignment that took time to sit down and really thing about the implementation and design / layout.

Furthermore, on another note, we learned recursion this week and the worksheet we did in class was a very well designed one to help understand recursion better. The worksheet gave me a good idea of how it works and tracing it was a good idea. The lab exercise was also very helpful in extending on my knowledge of recursion and hopefully I can work on mastering the concepts taught in the course to do well on the upcoming term test.

Week 3 - Debugging Logs

The most painful part of coding can be the debugging process. Thinking your program runs and then finding out that there are bugs in it can be very demoralizing. Sometimes there are cases when you read over the code and think you know where the bug is, but even when you think you fixed it, the bug remains. This can take hours, even days to fix the problem if you do not constantly check over your work and properly debug. A smart way to debug is always to set breakpoints and figure out exactly where the problem is. Constantly running the program after new additions of code can be a smart way to avoid a painful debugging process.

A smart thing that most people do not do is keep a debugging journal. This is so underrated however so very useful that people must start doing it more often. Most of the time people ask others to look at the problem which is helpful however keeping a journal to keep track of your own code can be useful in the long run. It lets people trace over their own code and sometimes even reading over what you write in a journal, instead of an IDE is all someone needs to realize their mistake. Keeping a journal is also a good way for future employers to recognize that you are indeed understanding what you're doing and also understanding how to fix the problems that occur occasionally. Apart from just having a journal to help you with debugging, it can also help you keep track of projects that span over a long period of time. It is very easy for you to figure out where you started, and how much you have progressed over the period of time from a simple journal entry.

Therefore, it is crucial that people realize the importance of writing and how it can be truly beneficial to them in more ways than they think.

Weeks 1 and 2

Hello!

My name is Jahid Ahmed and this is my CSC148 blog. This blog will feature my weekly experiences throughout this course.

In the first week of this class we went over object-oriented design and how to create classes. This was mainly review from CSC108 and none of this was too complicated to grasp the concept.

The second week of class was creating __str__ and __repr__ methods for our Point class. After going over that, we learned about controlling attribute access by making access private. We also talked about stacks and created two implementations of a stack class which involved appending and removing items from it which once again was not very difficult. When we moved on to the unittesting part, this was a little different from what we learned in CSC108 so it took a second look to understand the concept.

These few concepts were the main topics for the first two weeks of class.