More Music to Work To.

I need to show my devotion to the beverage that has gotten me this far.

I Did The Thing

I won't be coy. I am more than happy with the content of the first mid-term. There seemed to me to be no requirement for any transformational laws, or even basic algebra (that will be the end of me in this course, guaranteed).

The questions on the test seemed pretty straight forward though and didn't appear too tricky, although I will admit that I tripped over myself with negations a couple times ("Is 'not any' the same as none, or 'all-not'? Is 'all-not' even a thing? Pretty sure...").
Maybe I also negated "m x n = q" incorrectly.
The fact of the matter is that things seemed straight forward enough to not warrant need of an aid-sheet. Aid sheets are not comforting. All it really means when a prof allows an aid sheet is:
"GO ON. WRITE ANYTHING YOU WANT ON THIS PAPER. NOTHING YOU WRITE CAN HELP YOU NOW."

Either way though, I didn't use an aid sheet...
Because I didn't have an aid sheet...
Because I totally didn't realise that the term test was today.
I thought that the test was on Friday, so I got to be the rube that walked into MP203 at noon thinking, "Hey, where is everybody?"
I checked the course website...and I started running.
I did not study...
I prepared no aid sheet...
I was 12 minutes late...

If I manage to pass this test, anybody who doesn't has no excuse.
Except if their dog just died...
Or they have a terminal illness...

"Assignments make an ass out of gnments and I"

It's rather obvious that I neglected this Slog for a couple weeks, in no small part due to the presence of assignment 1.

To be fair, I find most of the difficulties in logic assignments are the interpretation of the questions.
Am I logic-ing in the way that they want me to?
If I try hard enough, can I make a true implication using nothing but empty sets?
If I slap together enough conjunctions and quantifiers, I'm pretty sure I can pretend I made a uniqueness quantifier.
I'm going to state a non-existence and then predicate a relationship between something and this nothingness no represent a lack of relationship between two things. Yes, that is reasonable.
How do you even catheterize an acronym anyway? It sounds uncomfortable for the both of us.

At very least, I'm seeing some familiar faces from my brief time in PHL245. DeMorgan's law was familiar, although it was taught a lot later in the course, and we had to prove it's logical legitimacy before we were allowed to use it for derivations. It seemed like a pretty big, difficult thing at the time, so much so that I had absolutely no idea how it worked. Now I'm familiar with using it, but I can't help but feel like I only got comfortable with a lot of the transformational rules and what-not because they were mentioned to us with the hum-drum, side-glace of attention. Maybe because in this context, negation seems a lot more like an algebraic property and less like a meaningful proposition the way it feels like in Philosophy sometimes.

Either way, we start proofs soon, and true to this SLOG's theme, I have no idea what's going on. Really. I haven't done math in AGES. This is gonna be a disaster.

My Spoken Dialogic.

The pun in the title didn't work out exactly as well as I'd like, but it's super pretentious, so I'm going to keep it.
Through this week in 165 we're learning the basics of logic in CS. I'm a Cog Sci student first and foremost, so I've had to take a logic course in the past, PHL245, Modern Symbolic Logic. I should probably also note that circumstances led me to not finish the course, BUT it's something.

At very least, it's enough to note that some of the symbols and concepts that are being used in each respective logic system is a bit different. The universal (all) and existential (some) quantifiers are the same but this business with sets, and set interaction...this is new to me.

My professor for Minds and Machines (PHL342) conjured up logic that looks much like that seen in 165. Brian Cantwell Smith did in fact have his origins in information and computer science, so this probably makes a lot of sense. Symbols for implication and negation, for example, differ slightly in the symbolic logic that I had encountered before, but all of the underlying ideas and structures are more or less the same.
...because they'd have to be.
...It's logic.
...That's the point.
Going between the two seems more like speaking two dialects of the same language. The dialectical difference is rather small, and is less like the spoken languages of two nations separated by a vast desert, and more like the vernacular of two towns on opposite sides of a river. What my issue is right now is just picking up on the new lingo of the town that I'm in now. All the concepts seem really straightforward to me, but there's a bit of a weakness when it comes to the symbols. A vital weakness that's just waiting for a test or evaluation to come along and target it specifically.

...I should probably do something about that,

" Real " Python Design Recipie

> Get drunk.
> Write code.
> Sober up.
> Drink entire pot of coffee.
> Debug.
> Realise code is fundamentally flawed.
> ???
> Compile and error.

This is what used to be my SLOG for CSC148 that I took last year. I figure, why make a new one when I can recycle?

This is now my SLOG for CSC165. Those in 148 can probably scroll down and read my unproductive ramblings about the 148 content. I can't possibly imagine why you'd want to do that though.

Sorting Matters.

    Sorting seems to be a favourite I've seen when demonstrating the differences in the run-times of algorithms, my guess is because there are so many different ways that you can do it, and what's more so many different behaviours that each algorithm can have. We saw the most evident of these differences on the larger scale tests in the penultimate lab, but it's always entertaining for me to see the drastically different results that the means with which one handles data can have on the data management efficiency. 

    It happens to be of particular interest to me in Cognitive Science because it can show that the particular way that you take in and manage information, has a significant effect of how quickly you can use it, and in what contexts. With things such as working memory that are so tied to problem-solving abilities and general intelligence, information-handling efficiency is particularly important because of how limited working memory is both in capacity and in the amount of time information can be held in it. Showing a distinct difference in sorting algorithm run-times suggests that even in our own working memory, the way that we encode and manipulate information in our own brains might be a factor in how well we are able to solve problems and efficiently carry out tasks. It's really a fascinating thing.

Home Stretch

The funny part is that I'm looking at the course calendar and I'm seeing only three lectures left, but I don't quite believe it.
Really.
It seems pretty much like the usual "OMG THE SEMESTER WENT BY SO FAST WHAT?" but it's accompanied by this weird feeling of "I swear I learned something...I'm not quite sure what...but SOMETHING."

The issue I'm having now is of course, the only issue left, the exam. I compare the first mid term and the second midterm in terms of difficulty, but the apparent range of difficulty between the two tests was such that I can't ballpark where the exam is gonna be. I could average the difficulties of the two and guess it will be somewhere in the middle...or I can take the safe, common sense way of thinking and figure that it will just be more difficult than the first.

After this I can just worry about dealing with CSC165...Dammit.
I should start a sister blog for that titled "I Don't Know How to Math"
I really don't.
It's been 3 years since I've taken a MAT course.

What have I gotten myself into...

Naked and Proud?

    In lecture, Danny brought up that because of Python's apparent lack of aliasing or restrictions to instance variable names and all the like, it was said that moving over to Python from another coding language was a bit like walking into a nudist colony...

   From the perspective of somebody who knows next to nothing about programming, and has only programmed in Python this entire time, hearing this would be a bit more akin to being born and raised in a nudist colony, and then suddenly hearing that people elsewhere wore clothes...

What? People wear pants? And this is normal? Weird.

Testing, testing, 1 2 3.

The second test really just sneaks up on you doesn't it? I had an hour of relief once I had finished the assignment before I looked at the calendar and saw the second test first thing after the November break.
My angst arises from not knowing how to tell if I'm ready for the test. No really, I thought I had all the concepts down pat before, but I was wiped out by the test. I blanked out, all-gone, I forgot how to interpret a tuple. It was bad.

This time I have no idea how I'll do. The concepts about the performance of algorithms didn't quite sink in. I understand the reasoning behind the performance differences, but only on a very elementary level. I don't think I could even fathom any test-calibre questions on the subject. It doesn't help that I have a minimal recollection of how logarithms work. Other than that I don't even know what we're going to be tested on...how does one prepare for this??? How do I improve when I'm not so certain what it is that I really need study up on...

:|

Can't tell if easier...or actually improving.

I feel as though I'm in a bit of an awkward situation for the past couple of exercises. Using Linked Lists and nested lists, we looked at the binary tree structure. The seem more or less equivalent, except that the branches are calls to other objects instead of just a nested list. It would follow that the logic behind interpreting and writing code for them would be the same.

For me, this doesn't seem to be the case. While I only managed to figure out half of e4 (and even that took me a number of days), I breezed through e5 in a small number of hours. The recursive reasoning behind the binary trees in e4 seems to be the same for e5, but this time around it was a lot easier to grasp. Perhaps the reasoning is actually completely different, and I'm equating two incomparable things? Perhaps Linked Lists are simpler than nested lists? Perhaps I'm ACTUALLY getting the hang of this (not likely).

...or maybe it has something to do with the fact that I don't have two midterms on the same day this week...

cheers.

Comprehending comprehensions.

List comprehensions and generator objects seem to me to be one of the niftiest things we're covering for Python. Seriously, you get to consolidate maybe four or five lines of code down into one simple line. On top of that, the line is almost identical to an English sentence! Seriously, isn't that cheating? It feels like cheating.

What I honestly would like to know is exactly how they work, because whenever the IDLE debugger steps through it, I just see the object reference, and the MAGIC happen. Comprehensions are actually kind of a pain when debugging, because I get to slowly watch nothing I can comprehend happen. The comprehensions sometimes seen incomprehensible! I find it's a lot cleaner to write out code the long way first, and then when you get it working, thusly consolidate it into a comprehension afterwards.

Wreckusion.

    Yes, the title's a pun. The goal every year is to hit the ground running and get sufficient momentum going in the beginning of the year so as to be able to coast through the rest of the semester with less stress.

   I messed up. Recursion was one of the more challenging concepts for me to wrap my head around initially, because of course, I don't know what I'm doing. It seemed really counter-intuitive at first, almost fanciful. Why? Because recursion, to me, seemed a lot like,

ME: "So function, when I pass you these arguments, you're gonna do what you do... and then you're gonna            KEEP DOING IT...until you CAN'T DO IT ANYMORE."

FUNCTION: "But what is it that I do..?"

ME: "You know what you do."

And thusly it would work. Through some magic.
I have a better comprehension of how this works now. As I perceive it currently, when making a recursive function, one starts with a base case, which is like a goal for the function to reach. What the function body is thereafter is kind of like what you want the argument to keep doing to itself, as to reach the base case. It's kind of an iffy perception on my part because office hours for the last little while have been centered on the assignment, so I have had few chances lately to ask directly about at least intuitively considering recursion.
Until then I figure I'll just go over the readings, and stare at the code until it makes perfect sense to me.

Cheers.

Apparently I'm incapable writing code without music.

How I Learned to Stop Worrying and Love the Object.

     As far as the concept of Object-Oriented Programming is concerned, I'm in a bit of a pickle relating to a lot of people who have had experience programming in languages other than Python. I had come into this course armed only with what I had learned from CSC 108, in the Winter/Spring semester last year. My knowledge and experience of programming began and ended there, with basic Python, so as far as I knew at the time, OOP was the ONLY way of doing things.
     Object-Oriented Programming deals with the manipulation of, you guessed it, OBJECTS. These objects are very basic data structures, assigned to memory addresses in the system. Different objects are considered to be different instances of classes with their own properties, functional methods, behaviours, and attributes that distinguish themselves from each other such that they can be used and manipulated for whatever intended result. This struck me as a very intuitive way of doing things.
      In Cognitive Science, some of the first things we deal with are the different theories around categorization of concepts. The way that OOP starts from base objects and builds on to them until they have unique methods and attributes is very reminiscent of some classical Greek theories of concepts, in which concepts are based off of a conjunctive list of 'atomic' features that act as building blocks into creating categories of membership based of certain necessary and sufficient essential qualities. This is surprisingly close to defining new classes and the sub classes that are built from them.
    This is useful for computer scientists because in stead of dealing with lists of commands or subroutines, information is being embodied in its own object such that it becomes a lot more similar to the ways which human users are wont to handle and manipulate information and concepts themselves. This not only makes programming a little more intuitive (at least it does for me), but it is very useful in keeping ideas and information very self-contained.

...I think I got a little carried away...
     

WHOOPS.

So apparently we should have been writing these posts since week three...
How irresponsible of me.
In these first two months I'm not quite sure exactly how badly I've managed to sabotage my grade in this course.
None-the-less, I've invested too much time into it to stop it now.

Also, the feeling of getting your code to do exactly what it is supposed to do is far too satisfying.

Cheers.