Sunday, April 5, 2015

Week 12: Final Thoughts

     And now... we're here.
     Overall, I really did enjoy the course.  Like I've said before, the pacing, what we studied, the wonderful people I've worked with... CSC148 was much more enjoyable for me than many of my other courses.  It was fascinating and challenged me but it wasn't to the point where I was totally lost.      I'd very much like to thank Danny and Diane for all of their hard work, patience, and understanding.  Seriously, they held loads more office hours than usual, especially during the strike, and were extremely helpful.  I didn't feel intimidated going up to them and asking for help, especially since they were so kind about it.
     The labs were... admittedly, I sort of wish I just went for the quiz.  I usually did the labs ahead of time on my own laptop, meaning that I sat in the room for about 2 hours doing other work, gaming, or nothing.  However, as time went on, I really did need labs so that I could actually ask questions (which was a bit hard without TAs, but I managed) and I'm glad we were given that time.
     I've learned so much from this course, even if it went by quickly.  Recursion was fun to work with, even if I wasn't the greatest at it.  Trees were fun, and the assignments weren't too frustratingly hard.  (Though I'll admit, minimax was... tough.  And I think my partners and I all went crazy.)  The term tests, I believe, were decently fair (except in terms of time, but I guess I can't help that).  Overall, CSC148 was a great course, and I really did enjoy it.
     I'll admit, though, writing SLOGs was a bit annoying.  I suggest actually having students write SLOGs in tutorials (as in, make it a part of labs) so that not only do we have impressions right off the bat, but we also don't just forget it.  This semester was busy and SLOGs completely slipped my mind until this last week.  Hopefully this isn't too late, even if this is last minute.
     Lastly, I'd like to make a shout out to two of the greatest friends I have ever made, Sophie and Justin.  Whether we were getting KFC, procrastinating by deciding which Disney character we were, texting each other lyrics to wake someone up, or just getting frustrated over our programs, we always stuck together, from CSC165 last semester to CSC148 this semester.  It's been grand working with them, and I hope to work with them next year, too.  CompSci has been quite the adventure thus far here at UofT, but I've enjoyed it greatly.
     And thus concludes the awkwardly sentimental SLOG.

Best Wishes,
Dominique

Week 11: Looking Back

     I'm looking back at my "Weeks 4 & 5: Impressions & Recursion" slog right now, and I do still agree with the majority of it.
     I did like the gentle transition from CSC108 to CSC148.  I feel like this class was extremely wonderful in how it handled teaching us things slowly but efficiently.  We learned a lot, though it feels more familiar and I'm more confident with what I've learned now compared to classes such as CSC165, where I was struggling to keep up.  The pace of CSC148 was wonderful, and I stand by that statement.
     I think now that I am more comfortable with certain ideas, I found that the second term test didn't feel so rushed.  Of course, it still felt like it was an unfairly short period of time for so much writing, but I was able to think and plan out more for the second term test.  I'm hoping for a good grade and more time on our final exam, which I am studying for whenever I get the chance.
     I've gotten much better at understanding recursion and I've found it extremely useful, especially in A3, which didn't feel so much like a struggle (though admittedly, that might've been because of the strike).  My partners and I got it done earlier than usual and we believe we did pretty well on it.  Hopefully that's true.
     My partners in crime assignments are Sophie and Justin, two excellent people who have been so very helpful and patient with me this whole time.  In Sophie's slog, she mentions how nice the pace of CSC148 is and how nothing is exactly overcomplicated and simply requires practice, both things that I agree with.  In addition, I share Justin's love of recursion, as confusing and annoying as it can be to me sometimes.  I loved reading through their slogs, both of which helped me formulate my own ideas and thoughts.

Weeks 8 - 10: More Trees, Linked Lists, Term Test

     We worked on quite a lot during these weeks!  Here is where it started to get more complicated for me.  While I had some experience with the ideas presented, I hadn't ever put them to use before.
     We did Binary Search Trees, which were a great way of sorting out numbers and operations.  I found it much more efficient and fascinating, as I loved the logic behind it.  As strange and nerdy as that sounds, trees are extremely interesting to me.
     We also started learning about linked lists, which weren't as exciting for me.  I liked the logic behind them, but to me, as there was no set order or way in which to view them other than going through it, I found them restricting.  While it can be good for certain things, I didn't like experimenting with them.
     These were hard weeks without the TAs.  I did the labs on my own, but these were times where I started having more questions and almost no one to help me answer them.  However, I will admit, it felt wonderful once I did figure out how to finish the lab problems.
     In addition, we had our second term test.  I remember my impressions being that it was harder than I expected but that I was able to really get through it anyways.  I did pretty well on it, as well--I expected a lower grade.  I'm pretty satisfied with how I've been able to keep up, even without the TAs.  Hopefully my work contributes towards a good grade on the final exam, which I'm extremely nervous about, especially since we didn't have tutorials.
     Otherwise, CSC148 is much easier than I expected.  Yes, it does present challenges, but they're not challenges I feel I can't overcome.  The logic behind it is sound and I feel much more secure here than I did with CSC165, where I was seriously doubting any sort of computer science-oriented abilities that I had.  Hopefully this keeps up!

Week 7: Abstract Data Types

     ADTs in object-oriented programming are very interesting to me (if a bit frustrating).  They are "abstract" because they can be modified later on.  So, they define the methods of a class and what they should do, but there is no specific implementation.  We take a set of data and define the operations that can be used on the data, but we don't define it in a specific way (yet).  It allows for a simpler understanding of an algorithm and the creation of similar classes.  It also allows programmers to keep track of more than one instance of a collection of items.  So, we know what it's supposed to do, but the real question is how.  Some ADTs included within Python are strings, sets, lists, and dictionaries.
     Stacks are a prime example of ADTs.  They are a collection of elements, meaning that multiple elements can be included.  It's a list, but it can only be modified in two ways: push and pop, which adds a new item to the stack and removes an item from the stack, respectively.  However, pop only ever returns the last item added.  Yet, there is no one way to implement these methods, and they can be interpreted different ways; for example, pop can remove or return the most recently added item.
     Ergo, ADTs can be implemented in a few different ways.  They must be implemented to allow for any foreseeable action to take place--for example, if we're creating a class of points, we should create methods that create the point, add points, return the point, etc.  We have often used ADTs in class, when we make subclasses and the like.  We define methods in one class and the next inherits it or modifies it in some way.  We've also used them in labs; for example, queue was an example of an ADT.  It had enqueue and dequeue, which people implemented in different ways.  It was a helpful exercise that allowed us to experiment with different ideas, and it was interesting to see how different people had completed the lab.  I finished early with a simply implementation, but someone beside me had lots of trouble trying to use a more complicated function.  It all depends on the programmer, I believe, to make efficient use of ADTs.

Week 6: Trees

     First off, I must apologize for the lack of slogs.  I'll post all of mine today, as I did write little notes as to what I would include in my slogs when I got around to them.
     If I'm correct, Week 6 started our dealings with trees.  Not only did I find them fun, but I found them extremely helpful; after all, it allowed us to organize things better in accordance to nodes and number order.  However, I'll admit, the lab didn't do much to help me.  Gather_lists was extremely annoying and I couldn't get it to function on my laptop (though found that it worked fine on the CDF computers a bit too late).  Even so, I understood the logic and it was all rather simple.  I enjoy working with trees, as strange as that might sound.
     Seeing people actually represent the tree in class was pretty fun, as well.  I sure got a kick out of seeing everyone around me shyly stand up.  I do believe we all left with a better understanding of the subject, though, even if most of us were a bit confused at the time.  It was rather clever.

Saturday, February 7, 2015

Weeks 4 & 5: Impressions & Recursion

Apologizes for not writing a SLOG last week.  It completely slipped my mind, I'll admit.  So I'll cover both topics in this post.

The first few weeks were admittedly a very easy but nice transition into CSC148 from CSC108.  I guess it's because I've taken computer science courses before, but the first few weeks were rather easy.  Of course, it's always good to review again and I was glad for it.  Now, we're delving into things I haven't done, which is good considering the gentle build up to it.  I'm excited to see what happens next and how I'll deal with it.

The midterm was easy, but I honestly wish we got more time to write everything.  I'm sure my grade isn't great because I was rushing the whole time, and even at the end, I still hadn't finished writing what I wanted to write.  Perhaps I'm a slow reader and thinker, but most people around me had the same complaints.  Though I'm annoyed, I do feel okay with it.  I think I got the majority of it done, and done well.

Tracing recursion isn't my strongest suit, but it was easy enough.  Admittedly, I do mess up here and there because I rush through things and I don't like to take time going through each and every step, but overall, I think I've got the hang of it.  I just need to slow down and check my work, especially on the more complicated bits of code.  I did like the practice, because I'm so bad at tracing code overall.  I think it really contributed to my understanding of recursion and coding.

That's it for now, so hopefully I remember to post again next week.  I'm looking forward to it!

Best Wishes,
Dominique

Saturday, January 24, 2015

Week 3: CSC148, Writing For Geeks

I'd very much like to start off with the fact that I've always thought that writing was important for geeks/nerds.  Writing is a method of communication, and communication is vital in programming.  Whether you're trying to communicate to an audience or you need to communicate to a computer what it needs to do, you need to be able to understand and specify what you want.

For example, when you create a class, you have methods, variables, and objects associated with it.  However, how do you explain that to someone who can't code or read code?  Well, you describe it.  Say you have a class that takes input from a user and checks certain things--how many letters it has, how many syllables it has, perhaps even what words it rhymes with.  From there, you should be able to describe what the class does and how.

It works the same visa versa, as seen in class and in our labs.  We're given thorough descriptions of what to program.  From that description, we ascertain what we need to do and how.  For the class I described above, variables could include something that keeps track of the user's input and what is being printed back to the user.  Methods would be calculating how many letters the word contains, how many syllables it has, what words it rhymes with, getting the input, and giving an output.

I think it's very important that geeks write about programming and coding.  It helps others understand what's going on, and it helps the programmer understand what is expected of them.  Being vague or not expressing correctly what you want doesn't help.  It's like implementing code--you have to tell the computer exactly what to do, or you won't get what you want back.  Writing is important, especially when you're a geek.

Best Wishes,
Dominique