Week #12: last impressions

Finally, this semester comes to an end and this is my last slog. Look back over this course, it's totally different from csc108 and csc165, which first gives me impression of what computer science is about. From the very beginning of the class, we learned about abstraction data type, and then applying it in python along with some methods as well as inheritance and exception, etc. Then, we use these knowledge to write a subtract square game as our assignment 1, which is the first time that all the step is determined by ourselves, and frustrated me a lot. It gave me the impression that this course is so hard, however, surprisingly, I got a good mark in the first test, which brought my confidence back.
After that, we learned about the recursion with list comprehension and how to apply it into a tree class and linked list class. This part is the most difficult through the course as well as on the test because we have to be extremely familiar with the recursion part so that we are able to write codes on paper correctly without testing it. I've complained much about recursion in my previous slogs, but still practice a lot is very necessary. About recursion, we have it for minimax from assignment 2 and for almost every function from assignment 3. We suffered a lot doing those assignments but if we think in another way, those exercise help us improving recursion a lot.
Last but not least, we talked about the efficiency part. It is easy compared with the previous parts as it was mentioned a lot in csc165. We got the idea that in which way is more efficiency, which will be used in the future.
Overall, I feel very happy for learning lots of new knowledge about computer.

week #11: revisit an earlier slog

This week we have an assigned topic which is to revisit an earlier slog to see what have been changed in our mind. I will revisit my third slog, which is the impression of tracing recursion. At that time, I said that recursion is my favorite part in this course so far because it is easy and interesting, but now, I changed my mind after using recursion in a tree and linked list, etc. Recursion is one of the most difficult parts to learn in this course. I have to say, using recursion in our code really helps a lot and looks simple and clear. It is much better than writing whole bunch of codes that is awkward for people to see. However, every time I'm asked to write a code with recursion, I feel like confused and have to spend a lot of time working on it. However, the good thing is that in assignment 3, I can figure out how to write a grow function using recursion by myself. It suddenly brings me confidence and encourages me to study more on recursion. Hopefully, by the time the final exam comes, I'm not afraid of recursion any more.
compared with this slog http://148slogger.blogspot.ca/, I find that we have the same problem and it is not only me that have a problem on recursion. The key part of recursion is to figure out the base case and the body. So, just like the instructor says, every time you write a recursive code,work from the base case up, and then test your base case. Once you are sure it works, test a problem one step larger. Practice more on recursion with this method and I'm sure it can be solved easily.

week #10: impressions of week 9

Last week, we just finished test 2, and again, I feel regretful on how I prepare for the test. I remember that when I was preparing for the first test, it was so confused to me because which way will the instructor test on and what the difficulty it is. Therefore, what I did for test 1 is to look over the lecture in slides and do past test. I didn't focus too much on lab exercise at that time, which, surprisingly, gave me a pretty good mark. However, after I looked over my test, I was like I should have done more on lab exercise and my mark could be even higher. However, this time when I was preparing for the second test, I totally forgot about that, and again, I started reviewing the test by looking over the slides and then past tests, which is exactly the way I was using in the first test. How stupid I am to have the same mistake twice. I can tell that the grade of my second test will not be as good as my first test this time. Re-doing the lab exercise is really helpful not only for preparing for tests but also for applying the new knowledge which was taught in lecture into real problems. Due to the lab, I am able to understand the course. For me, I can't make the same mistake three times. For my final exam, the first thing to do is to re_do the lab exercise based on what we've learned.
Also, unlike the last week in which we learned about how to mutate the linked list, this week, we came into a harder lever, which is to mutate the BTNode by writing insert and delete functions along with the step of algorithm, which pretty helpful.

week #9: impressions of week 8.

This week, we learned about the linked list. It can be seen as a sequence of nodes, each has a value and a reference to next node. When I first saw it, it think it is just like the tree writhing in a horizontal way. However, there is much difference compared with a tree. For instance, linked list is a wrapper class of LLNode which represent a single node, but there is no wrapper class for a BTNode. Also, an empty linked list is an instance of the class, with attribute values set to show it’s empty, while an empty tree is represented as None.
Although, we've looked over the codes in linked list class and learned how it works, I'm still confused about it because it is not in way i used to think. The first thing we learned about is to traverse a linked list, which has a pattern that is pretty helpful:

And the most important part in the linked list is how to mutate a linked structure. It is easy to understand how it changes through the code if we draw a simple diagram, which shows both the front and the back and the current node and previous node. Like this:

Basically, those are what we learnt about linked list. If we look at the code of a linked list, it is very simple and sometimes it is simple enough that I am not sure how it can work through python. Every time I try to write a code like this , I always think in a difficult way and as a result, the code I write keeps failing. In order to get over it, I find that do lab exercise including the extra practice in the back every week is a good way to learn how to use it properly.

week #8 : impressions of week 7

In week #7, we continue learning tree. Instead of general tree which is the new knowledge taught in week #6, we learn a particular kind of tree called binary tree as well as the node class for a binary tree. A binary tree is a tree which only has two children called left children and right children. The binary tree can be easily understood once we got the idea how a general tree works. However, some functions under a binary tree class including contain function is a little bit different from the general tree class as we have to make it more specific into left and right children rather than just children.
Here is the contain function in a tree class:

And here are the contain functions in a binary tree:

All of them use recursion: first assume that the function contains works, and then make it to a helper function into the code itself. The only different is that writing contains function of a binary tree, we have to think both left and right children not like that in a tree class.
Overall, I think the tree class is interesting and is pretty helpful for us along with the recursion. Once we understand them and know how to use them perfectly, it will be our treasure in future studies.

Summary of recursion

For the last few weeks, we have learnt recursion including how to understand the recursion code by tracing it and how to write some easy codes with recursion. But more importantly, in order to fully understand the what is the recursion, we need to define how to think in a recursive way.

For tracing the recursion code, I think it is the easiest part in the study of recursion. Just plug some examples which is from easy to hard into the code step by step and finally we will get the correct result unless we are not carefully enough.

For writing the recursion codes, it is a further lever of studying the recursion. Here is the way it goes, the problem with recursion can be easily solved and will be straightforward if you get used to recursive thinking. However, you can't even write a word on it if you are not familiar with the recursive thinking. So, a recursive way of thinking is very necessary for us to learn the recursion. 

So how to think like that? It is kind of different from when we do a normal code. Unlike we try to figure out the necessary code that can return the result we want when we are writing the code without recursion, we need to get the idea that what does the whole function do and think in a opposite way, which is that we assume that we've already got that function and use it as a helper function into the code. Before using that, we need to find a base case, which is the easiest possible result that it might return.

For me, although I got the idea how the recursion works, I still need more practice on that. I did the lab about recursion with some easy exercise and I got them all right. But the fact is that the recursion is weigh much harder than what we did before as we've started learning the tree which has almost every function that has to be done using recursion. I hope I can get used to that. 

summary of Object-Oriented Programming concepts

Talking about Object_Oriented Programming, I would like to say that almost everything, such as objects and classes, that we have learned though this course except recursion helps us understand  the Object_Oriented Programming well, which is short for 'OOP'. OOP is the way of programming in order to design the application more focusing on using objects rather than logic. In Object_Oriented Programming, we don't care much about how the logic goes between input and output, what we mainly care about is the objects that were mentioned in this application.
I remembered that at the beginning of this course, we were learned abstract data types (ADTs) in python including classes, attributes, methods, etc. According to the course notes,  "an ADT speci es the intended meaning of the data it stores, and the operations it provides on that data". The stack is an typical example explaining what we basically do with ADTs  with some general features of ADTs. A stack, obviously is the object and pop, push and is_empty are methods used to manipulate the stack. Also in our first assignment, we use OOP concepts  to make a game with five classes. Our first step is always to find out objects and operations needed by this object.
Inheritance is also a concept which is important and beneficial to understand OOP. Sometimes, we only have general features which does not satisfy some specific requirements. Employee, as an example that was taught in class, is the general object ( parent class). However, we have different kinds of employees under that parent class like hourly employee and salaried employee, which are named child classes used to implement the parent class. As a result, hourly employee and salaried employee share the same features as employee but have their own attributes on the other hand. This method is so helpful so that we don't need to overwrite the same code under a class.
In a conclusion, understanding Object_Oriented Programming concepts is pretty important to us because it is the basic stuff we need to know in order to make a further move into computer science. After I summarize the OOP concepts by looking over the whole thing from the course notes, I feel like this part of knowledge is much clearer to me. If we have something not familiar with, reading course notes over and over again might be a good way to get through.

impressions of tracing recursion

Tracing recursion is my favourite part in this course so far. It is pretty interesting and for me, it is kind of easy to trace the output through looking at the code that is given. Everytime I see the code, thinking that how magical it is that the function itself goes into its own body code. I've seen the slog from http://sl0gforcsc148.blogspot.ca/, and there is a conversation which I totally agree with that goes like this:

       Student: "How do I learn recursion?"
       Teacher: "You have to know recursion to understand recursion..."
In order to understand how the body of function works, you have to understand what the whole function does. And then , useing a smart way with only a few lines to illustrate something which goes to unknown even to infinity. 

Although I love the way tracing recursion does, there is still one thing I'm worried about. I have no idea how to start if I'm asked to write a recursion by myself. We did the lab exercise in week 4 and there was a part asking us to write a code of recursion which confused me a lot. I know it won't be long to ask us write the recursion code by ourselves, so I still need more practice on that in order to fully understand the recursion part.

Impression of first few weeks...

It has been four weeks since winter semester started. I was quite busy and tired during past few weeks even though a series of tests haven't come yet. It is much busier than last semester partly because I take six courses in total this semester, but mostly because the courses that I take are more difficult, especially CSC148. Every week there is only two hours' lecture plus two hours' lab for CSC148 but it covers more staff than CSC108. Besides, it is quite different than what I used to think.
When I first came to the lab, I got frustrated a lot. What I used to is basically implementing a class that has been given or understanding the code written by others. To tell the truth, I have totally no idea what should I do to design a class by my own through looking at the instruction even though I was learnt ways and several examples during lectures. It was the first time I realized that I supposed to work harder on that.
Thankfully, I get familiar with the course materials through reviewing the lecture slides and even Rampup slides. But I'm still worried about the oncoming test. Hopefully, I could survive after the test.

Why geeks need to know how to write

I started to write slogs for the course CSC165 last semester totally because they counted for marks. And to tell the truth, I've never had such a habit writing slogs every week recording what have been done and what am I worried about. So when I first heard that we need to write something every week, it was really a bad news to me. However, after 12 slogs have been done, I have to say that keep writing slogs is kind of beneficial to me, not only in the way of writing skills but also in the way of  understanding the course material itself. And I think it is also one of the reasons why geeks need to know how to write.
 Not only in computer science, but also in other fields of study, geeks need to record what they have done so far so that they can move on to the next part based on those things they just got. What's more, we don't have such a strong brain to memorize all of the stuff we've learned and mistakes we've made. Therefore, it actually a good idea to write down those things as "With the log you’re building a record, a stream of evidence about the bug." and "But in light of fresh evidence, it becomes the key that unlocks the problem and points to a fix. "--Adventures in Debugging-Keeping a Log.
For the course CSC148, we again need to write slogs. But this time would be a little bit different to me because it is not only for marks but also for improving.










 ----

Week #12

This is the last week before the class ends and it will be my last slog which is needed to hand in. What we learnt this week is about countability and computability and most interestingly, induction, which is another method used in proof. Since I've already learnt about induction at the beginning of MAT137 and we did a lots of practice at that time. It much easier for me and much clearer to me when I listened to it as the second time. In my opinion, induction is quite useful to solve questions with variable n, which is uncountable as long as this method is actually in your head. 

Although the term test result really frustrated me these days, there is a good news happens to me, which is I got a full mark on my second assignment, which surprised me a lot. I can't even imagine that I can get any full mark in university because courses in university seem much more difficult than high school. But I did it!  I suddenly feel like maybe I can do better than I used to do by changing my mind of these courses. And it actually encourages me to prepare well on final exam.
I see many amazing slogs on the course website especially slogs from http://www.reddit.com/r/journeythrough165/. I think keep writing slogs every week is a good habit because it can actually record your mental journey through this semester.

Here is a proof using induction :

Week #11

This week is the last second week before the class ends, plus there is a fall break with two days off on Monday and Tuesday, which makes me excited. Although this week doesn't cover too many things, what we learnt, again, makes me confused. I heard that this is the last chapter for this course, which i think is also the most difficult part. Basically, what we need to do is to prove non_computable function and computable function using reduction, which is something related to halting function. I still have no idea about it until I see the course note from course website. I can understand the example that was given and structure is clear to me. But that it, I don't think I can solve the same type of question by myself. I really hope that there will be more examples with solutions on this type so that I could have a deep understanding. The following question is the one appears on the course note, which I think is pretty typical. At least, I think we can figure out the structure of same type of questions after understanding this example.
I also check other students' slog like http://davidhanslog.blogspot.ca/to see if we have the same problem on halting problem.And yes! Many people are confused by this kind of problem.

The following is an example using induction:

Week #10

This week, the second term test result has come out, which frustrated me. I remember that when I first saw the test paper, there were only three prove questions and it seemed like i had done them before because it looked familiar. But actually, like the last test, I spent too much time on the first two questions and when I moved on to the last question, I realized that I didn't have enough time to finish. After the test, I heard that the second question is the most difficult and the last one is pretty easy. But what I did is just opposite because I get a full mark of proof on questions two but get 0 on question three.That looks ridiculous. The most regretful thing is that the question that I get 0 is the one that appears on assignment2 which is just due before the test. Although I use a more complicated way to solve it in assignment , I should have done it on the test.I felt like I could have enough time to finish it, then I was so careful to do first two that I forgot the time, which is the main problem. Also, I always think that what if I get more familiar for the stuff that is tested, this result may not happen to me.

It has already been two tests, and only one final left. I can't loose chance to get high mark next time, so I really need to look everything carefully and get familiar with the whole bunches of knowledge that I have learnt in this course.

problem solving:

 if we want to prove something equal, we have to show as following:

Week #9

This week, we began to learn Big O and Big Omega and how to prove or disprove it. This part is pretty interesting, which, I think, is my favorite part in this course. The way we did the prove of Big O and Big Omega is quite different from that we did for other questions. Maybe that's why I like it:)
Although what we learnt this week is kind of easy to me, we have the second assignment that is due on Monday. Some them are pretty easy and we practice lots of time. But others seem not easy to solve like the following question.
∀ x ∈ ℝ, ∀ e ∈ ℝ!, ∃ d ∈ ℝ!, ∀ w ∈ ℝ, |x−w| < d ⇒ | x − w | < e
Here is the way I did:

    

Every time I see there are too many variables in a question, I feel confused and don't know which way should I do it first. However, there is something interesting hidden in this question, which is that this statement is actually a definition of continuous function. Since the graph of floor is obviously not a continuous function, we can say that this statement is False and we need to disprove it, which eventually gives me some ideas to solve the next question that looks similar to this one.
∃ x ∈ ℝ, ∀ e ∈ ℝ!, ∃ d ∈ ℝ!, ∀ w ∈ ℝ, |x−w| < d ⇒ | x − w | < e

Here is the way I did:

Week #8

This is the 8th week and we learn about counting steps using worst case.Basically, what it asks us to do is just counting how many times a line should run in python, which eventually has something related to the course csc108. Overall, this part is not so hard though as long as we understand the meaning of the code which is necessary to know in csc108. What's more, professor also talks a little bit about Big O. At first, I was really confused because there are too many variables in the definition. But later, after we did the prove stuff, I gradually figure out what does it mean and the definition seems pretty clear to me.

There will be a second term test next week, which mainly tests us how to prove based on what we learnt these weeks. I personally have more confidence on this test than on the previous one partly because I did very well on tutorials and the example test that was given to us is pretty easy. But still, I need to do much work to review just in case that there was any knowledge that I didn't cover before.I hope I can get a higher mark on it.

Problem solving:(counting steps)

week # 7

It's been seven weeks since this semester started, which means we are already in half way through the whole term. Every time I look at the stuff learned before, I feel like that the time in university goes so fast. This week, we are still continuing on proofs but more complicated than before, which is to prove by cases. This kind of proof is not hard but we have to separate it into several cases and prove every case in order to make a good proof. What's more, I think the most useful part during this week is to introduce some rules, which can also be seen as the conclusion of some basic and necessary rules of proof.
Elimination:
conjunction elimination: If you know A ^ B, you can conclude A separately (or B separately).
existential instantiation: If you know that there exists k in X, P(k), then you can certainly pick an element with that property, let k' in X, P(k').
disjunction elimination: If you know A or B, the additional information :A allows you to conclude B.
implication elimination: If you know A implies B, the additional information A allows you to conclude B. On the other hand, the additional information :B allows you to conclude :A.
universal elimination: If you know for all x in X, P(x ), the additional information a in X allows you to conclude P(a).
Introduction:
implication introduction:If you assume A and, under that assumption, B follows, than you can conclude A implies B.
universal introduction: If you assume that a is a generic element of D and, under that assumption, derive P(a), then you can conclude for all a in D, P(a).
existential introduction: If you show x in X and you show P(x ), then you can conclude not x in X, P(x ).
conjunction introduction: If you know A and you know B, then you can conclude A ^ B.
disjunction introduction: If you know A you can conclude A or B.
The most difficult part this week, which I think is the worst case by introducing two functions which are the upper bound O(U) and the lower bound. The formal definition was pretty complicated and confused when I first saw it. However, after understanding the actual meaning of them, it is much clearer to me. The issue is that I can understand it when I'm looking at the definition but can hardly write it down by myself. Therefore, it is probably a good idea by practicing related problems in order to get familiar with it.

week # 6

We have a long weekend  as Monday is a thanksgiving day, so we only have two lectures  and no tutorials this week. Personally I think the work in this week is much easier than that in previous weeks. And we are continuing on proof of different types of problems including the proof of non-boolean functions and limits as well as the proof of something false. Since we've already learned how to write the outline of a good proof on last week, it's not  as confused as I thought at the time in which I learned proving in MAT137. It's really helpful for me when the professor taught us the proof about limits with an example of asking us to proof the definition of the functions which is exactly the same as what I learned during MAT137 lectures. In fact, I've been frustrated and confused about those kind of questions for a long time and eventually, I chose to totally memorize them instead of understanding them. However, I got really excited when I saw this proof in165 lecture on Friday using the different way of thinking but the same solution. As a result,  I'm not as confused as before, and I even wanna go back to do all the questions that I didn't get one more time using the method I was learned in 165.

The following graph is a typical graph to illustrate the definition of limit:

week #5

Good news in this week was that I didn't lose mark on my quiz, but bad news was that we just had a test which is my first term test in university and more importantly I didn't even finish it. I focused on the first two questions which spent me lots of time and I didn't realize that the time passed so quickly. As a result, I had little time to think about the last question, which again, made me frustrated after the test. I think the most possible reason of this situation is that I'm not so familiar with those knowledge so that I'm afraid to make mistakes on them which at last waste me a lot of time. I'm on the way back and I have to catch up with other classmates and then keep pace with them. That's my foremost goal of 165 now. Thankfully, this week's work is to proof some fundamental questions, which means that I'm able to spend more time focusing on reviewing previous knowledge through my notes and lecture slides on course webpage.

Problem solving:

week #4

It has been four weeks since this course began. And what I found interesting is that this course is kind of similar to the course MAT137 which I'm also taking in this semester, such as the proof of limit. Although the ways of teaching might be slightly different, I'm still quite happy about that because that helps me to improve understanding of this field of knowledge.
Basically, what I have learned this week is about proof. Not the proof of a real problem like what we learned in MAT137 but the outline of proof, which I think is helpful on both course in the future because what we actually need is not to solve a real question correctly on the test but to understand the problem and design a plan to solve it. This week's stuff is pretty clear to me and hopefully I can still be like this next week.
However, the issue of this week is not about the lectures during the class but about the first assignment. This assignment only includes 5 questions with several subquestions each, but the fact is that I have been doing it with a group of 3 for two days. It looks like pretty easy but once we do that, lots of problems come out as each of us has different understanding of those questions. In particular the last two questions, none of us is pretty sure about them. As a result, we studied the notes from lectures over and over again in order to find the solutions, which spent us plenty of time.
         4. For each pair of statements below, given an example of sets D; P, and Q that make one statement true
and the other false. Explain the difference in words, and show it with a Venn diagram.
(a) The pair 8d 2 D; P(d) ) Q(d) and 8d 2 D; P(d) ^ Q(d).
(b) The pair 9d 2 D; P(d) ^ Q(d) and 9d 2 D; P(d) ) Q(d).
We still don't get the satisfying solution of question 4 above until the answer key has been out, which is quiete simple using the basic knowledge we learned. I looked through the solution carefully in order not to get confused next time after I meet a question similarly.

week #3

This week, we are continuing on basic symbols like conjunction, disjunction, negation and implication. And especially  the differences between predicates (∧and ∨) and sets (∩ and ∪). What's more, some more complicated examples of negation and the truth table were introduced by professors. Through all those new things I learned, I personally think that the truth table makes more sense to me as I can't even figure out what the relationship between variables P , Q and disjunction, conjunction and implication of P, Q until I learned the truth table. It really helps a lot on proving.Although I get more familiar with the teaching style and get more used to the university life than the last week, there is still something dissatisfied happening to me, which is the first quiz that I ever took in the university. It's actually not as difficult as I thought and the format of quiz is exactly the same as the practice that appears on the course website. But I still get a worse mark on it, which makes me frustrated. After the quiz, I do think about the reason and I think the most possible reason is that I still lack of the understanding of the knowledge which is on the quiz so that I can't figure out what to do with it once it's only changed a little bit  but with the same knowledge as the practice.
In conclusion, as this course is necessary for computer science program, I'll always keep in mind  that how important for me to learn it well and I'll make all those stuff which is unclear to me clear.