betterlivingthroughpython

blog about me resume portfolio

Problem Set 6; Problem 3 of 5, Part 2

October 24, 2011

In my review of my functions I realized that I took a different angle to the next part of this problem set. The problem asks you to ‘...change the implementation of is_valid_word to take as an argument the representation you created above rather than the word_list itself.’ (page 4) Here they want you to alter the is_valid_word() function so that it can not only verify that the word submitted is contained in the word_list, but also that uses the points_dict variable that was created. Then as an answer it is supposed to spit out that the word is accurate and what its point value is.

Suffice it to say, I didn’t do this at all. I still ran is_valid_word() separately and used the points_dict variable to handle any point creation. Because I did not combine the two, it made some of my later adjustments, perhaps, more complicated. My apologies in advance for any ridiculous looking code.

The next function I created is a generator for the computer player, that will create combinations of letters based on the hand. To do this I implemented a brute force algorithm. Typically brute force algorithms are very poor choices, unless the information you’re processing is minimal. My function is shown below, it’s recursive.

def comb(chosen, available):
   finallist = [chosen,]
   for a in available:
       newavail = available[:]
       newavail.remove(a)
       finallist += comb(chosen + [a,], newavail)
   return finallist

This function creates a new list (of lists) called finallist, that returns all possible combinations from the letters provided in the hand. It starts off by going through each letter in available (which is the same as hand). For each letter it creates a new combination of letters by taking a slice, removing the letter being processed, then adding a new list to the finallist by recursively calling itself. Once completed this returns a list of lists, that might look something like this: ((‘a’,’b’,’c’), (‘b’,’c’), (‘a’,’c’), (‘a’)). This example is not fully complete, because it does not show all possible combinations or different ways in which the letters could be organized.

Up Next Time: Problem Set 6; Problem 3 of 5, Part 3

Problem Set 5 - a correction to a previously made function called update_hand()

October 21, 2011

A unique aspect of this problem set is that the course creators provided a test python file you could run against your file to test the correctness of your functions. I meant to do that right away when I originally finished the Problem Set, but I didn’t get to it until just a bit ago. So it seems that I had a mistake in one of my previous entries and I wanted to make sure to update everyone. It seems that my previous version of the update_hand() function was not entirely accurate. It almost completed the necessary task, but it missed one thing in particular.

If you don’t remember, update_hand() is a function that takes the (assumed) correct word submitted, verifies how many letters from the hand that were used to create the word, then deletes them accordingly. Originally in this function I used a for loop to go through each letter in the hand. What I didn’t realize at the time was that my original function would only go through each letter once. Normally this wouldn’t be an issue, unless a word was created using two or more of the same letter. An example of this would be a hand consisting of the following dictionary of letters and frequencies = {'h': 1, 'e': 1, 'l': 2, 'o': 1}, and the word submitted being ‘hello’. In this instance my original function would have simply subtracted one from the frequency in which the l occurred, but then moved on to the next letter. Thus an ‘l’ would have remained in the updated hand, and the function processing would not have correctly solved the problem.

In order to figure out what I was doing wrong I used a common method of debugging, using the print statement. By having my function print the values of my variables in different places, I can ascertain more acutely where the problem is. Normally, that is. Today I was having problems actually getting where I could alter something to fix the issue without having to redo the entire function in order to pass the test file provided. Here is my corrected function.

def update_hand(hand, word):
   newlist = get_frequency_dict(word)
   newhand = hand.copy()
   for letter in newlist:
       if newhand[letter] == newlist[letter]:
           del newhand[letter]
       elif newhand[letter] >= 1:
           newhand[letter] = newhand[letter] - 1
   return newhand

It seems what I missed was recognizing that I could simply ask in my for loop if value of the letter in the dictionary newlist was the the same as the letter in the dictionary newhand. If they were the same, I could simply delete the entire entry from that dictionary. If it wasn’t, I would simply subtract one from that value, so that the one instance in which that letter showed up was accounted for.

This alteration does make it so my new function passes the test file, however after some thinking I realized that it would still not be accurate in a couple of rare situations. Those situations being when three of the same letter or more were present in the hand, and less than that total amount were used in the word submitted. In such situations I am presented with the same problem I had before.

So, while my function still works...most of the time...I’m going to show you what another solution to the problem is. This solution is provided by the course instructors, and presented in the materials for Problem Set 6. Here is the function they had created.

def update_hand(hand, word):
   freq = get_frequency_dict(word)
   newhand = {}
   for char in hand:
       newhand[char] = hand[char]-freq.get(char,0)
   return newhand

This function creates two dictionaries, one called freq(based on the results of the get_frequency_dict(word)), and one empty one called newhand. This function works for all cases mentioned above, because it designates each new key in newhand to be based on the character(letter) being processed in the for loop. It then designates the value by subtracting the value for that char in the freq dictionary from the value for that particular char in the dictionary hand.

While this function is fairly simplistic to understand, I know that it didn’t come to mind for me to use a get aspect to solve it because I’m just not that familiar with it. I understand it, but when solving problems it’s not a tool I think about on hand. The more I program the more I realize how much it’s utilized. I think small things like these, small tools that end up being way more helpful than you realize, are going to be the next big thing I need to work on for my programming to get better.

Up Next Time: Problem Set 6, Problem 3 of 5, Part 2

Problem Set 6; Problem 3 of 5, Part 1

October 20, 2011

The next aspect of this problem set is, I feel, the most difficult task I was yet presented with. The third problem asks for you to create a computer player. More specifically, it wants you to create the ‘support’ for a computer player. There are many different tasks throughout this problem, so I’m going to chop my explanation up into multiple entries. Here are the first couple of functions it asks for me to create.

The first function it asks you to create is one called pick_best_hand(). This function is to take in the hand and points_dict variables and return the highest scoring word from points_dict that can be made with the given hand. If no words can be made with the given hand, then it is to return ‘.’. This is the end function I was to create, however there were several different steps I had to write before pick_best_hand() could be made. One of the first steps to doing so was to create a helping function called get_words_to_points(). It is shown below.

def get_words_to_points(word_list):
   points_dict = {}
   for word in word_list:
       points_dict[word] = get_word_score(word,n)
   return points_dict

points_dict = get_words_to_points(word_list)

This function was to take in the word_list (a list of all possible words to be created, based on a scrabble dictionary), and produce a dictionary that would have the word as the key and it’s total points as the value attached to it. Thereby creating a dictionary to use, when determining the highest scoring word possible.

To begin with I needed to define a new dictionary within my function, that would be returned once filled and completed. I named this points_dict = {}. Then I simply used a for loop and went through each word in the word_list. For each word I simply ran that word against a former function I created, the get_word_score(word,n) function. This function simply takes any provided word and spits out it’s point value.

To make the code more easy to read I went ahead and assigned each word I processed and it’s value (get_word_score(word,n)) to the dictionary as the for loop continued to process information. Once the word_list was entirely processed, all point values would have been attached to their appropriate word, and the new dictionary point_dict would be finished. The only additional step this part asked, was to assign the end value of the get_words_to_points() function to a variable that could later be called upon. This variable name was points_dict.

Difficulties? Not really, as this was a basic for loop problem with the addition of creating a dictionary along the way. Learning how to write this code simplistically will make future such problems much easier to read.

Problem Set 5 - a correction to a previously made function called update_hand()

What are sick days to the self-employed?

October 19, 2011

I was sick the other day, yet I still posted an entry to my blog, and I still worked on what I could. In all honesty I didn’t work that much. I was incredibly foggy headed. I even missed a soccer game! Not working that one day left me feeling incredibly behind, more so than I’d ever felt at a normal job. If I was at a normal 40 per week job I would have thought, it’s okay I’ll get to it tomorrow. Nothing I can do about it now.

Right now it doesn’t feel like it’s an option to get sick. Every lost hour is another hour until I can create a product that will finance my food and living situation. It’s a painful realization after only working in the standard 40 hours per week workforce. If I get lost in thought, or distracted because of something small but relative, it makes it that much harder to get work done.

In other words, if you’re not working at your most focused, highest level, you’re not working hard enough. If you take time off to read a book, you may be recovering but your work load doesn’t magically get picked up by your co-workers. You won’t make the money to put food on the table, and you most definitely won’t be paying rent this month. While invigorating, I’m not sure what I think about this new pressure quite yet.

Up Next Time: Problem Set 6; Problem 3 of 5, Part 1

Current thoughts on Open Course Ware

October 18, 2011

I’ve been thinking a fair amount about the Open Course Ware movement lately. I use the MIT Open Course Ware Intro to Computer Science and Programming course. In general I believe highly in the Open Learning movement. As an active member, I realize how much of a difference having access to these materials makes. It allows a person access not only to course materials, but lectures, readings, and sometimes forums where one can discuss the materials with others currently following it.

My current tendencies - I do not currently interact with the online forums and chat rooms for the Intro to Computer Science course I follow. I have chatted once or twice within the study group provided, but not at any depth. Despite my lack of interaction I’ve still noticed that the amount of students participating in the course along with me is small. There are moderators that interact with the chat rooms and forums but they are also only interacting intermittently, as is appropriate considering the current volume in students. There is simply not a critical mass of students involved to require more constant interaction.

The thing I needed to make this work - The interactions that occur with this course are almost entirely via text, excepting recorded lectures available online. Personally my best learning tends to come from verbal conversations I have about the course material. Those conversations are what help me to process and better remember the information I am reviewing. That is not much of an option considering the course. Luckily I have an additional resource of Robey (efficient and experienced programmer, who has taught before and acts like a tutor). With him I can have the discussions needed, and ask questions regarding many of the things that other would be programmers might have when beginning this course. Therefore I have had the necessary verbal communication I need to really learn the materials. If I hadn’t had this resource, I cannot imagine myself having learned the material anywhere near as well. Having someone to talk to about the course is a serious advantage.

Despite my appreciation and support of Open Course Ware(OCW), I realize that unless I had someone who could either, a) act as a tutor and help answers as they come up, or at the very least b) be someone who would listen to my thoughts and chat with me about what I am learning, it might not work so well for me. Due to these concerns, I feel that finding a way to integrate more verbal communication is necessary for a higher level of success for OCW. It would make the courses accessible to a wider audience. There are many out there that would greatly benefit from OCW, this would be a great way to make those new feel welcome.

By verbal communication I don’t mean that OCW needs to create an extension to the History Channel. Not that the History Channel isn’t awesome, but that’s not what OCW is all about. There are some great options out there that solve this problem. One of the best ones I’ve seen yet is Google Hangout. I think it would be awesome if some of the OCW courses would host Google Hangout sessions once a week, so students following the courses could stop by and chat with someone about their problems. There are graduate students already assisting with the online text chatter, why not up it a bit and talk with people face to face? It might also provide for the development of study groups originating from the students themselves.

Other interesting tidbits about online learning - Previously I worked for Ecampus at Oregon State University. Ecampus offers online courses and degrees, and when you graduate you receive an official degree from Oregon State University. It’s a pretty cool place, and the staff is made up of some pretty cool people. Through my time there I learned about virtual classrooms. One uses a virtual classroom by creating a personal 3d avatar, and through the world, attending your classes and chatting with classmates. Bascially World of Warcraft for educational purposes only. However, as far as I’m aware, Ecampus doesn’t offer virtual classrooms at this time. Nevertheless I feel that such virtual classrooms might offer another solution to this problem.

What else is it about OCW that needs tweaking? A higher level of organization of the course materials needs to be implemented. While the Intro to Computer Science course materials are organized, and the readings are set up with the course timeline, there are still some inconsistencies I’ve found in the assigned problems. Often I’ve found myself lost, simply because things are written out with less flow. The current course materials provided were originally created for a live audience. Online students don’t get the benefit of the professor emphasizing that one or another course reading is more important, or when a professor points to particular aspects in the homework assignments. I’ve often found myself straining to keep up with a lecture, because class handouts that are not included in the course materials. Both professors will often refer to class handouts, and without them you’re a little lost.

Lastly, many OCW courses are created by high experts in the field. While it is fantastic that these people are taking their time to provide this information for the public at large, it creates a problem. Many experts tend to have a vocabulary and style of writing that is consistent with their field. This makes it sometimes difficult for the beginning learner to make a connection. Often I’ve found an assignment written in a such a way that makes it very difficult for me to understand. When I have Robey review it to help me understand what they’re asking for, he will often comment as to how it’s almost written for a computer scientist. While it’s important to provide exposure to such writing styles, such a block in the beginning can highly deter an online learner from feeling able to learn the materials.

Imagine random Joe who starts following an OCW course. Things are going along swimmingly, then one day he hits a snag. He’s having difficulties understanding the materials. He goes online to the study group and tries to contact someone regarding the problem. He gets some help, but for some reason it’s not hitting the target. Now he’s finding it hard to go any further in the course until he’s gotten a chance to talk to someone about it (either via text or verbally)again. Considering the fact that random Joe is following this course in his spare time, after his 40 hours a week and other responsibilities are taken care of. That snag has now grown into a mountain, and the effort to reach the end result doesn’t seem as worth it anymore.

What I’m trying to get at is this. Open Course Ware is an amazing offering for many people. It provides them with the information and instruction they need, as long as they don’t really come up against any serious learning hurdles. Once that happens it’s hard to imagine that a large population of those learners will continue following the course. If you want to keep these people active within the community, and for the community to subsequently grow, you’re going to need to provide more access opportunities. I’m not meaning tons of man hours, but simply allowing the students more tools to interact with either Grad students supporting the course, or simply more students following the course. Many of the concerns I brought up above could be solved by simply giving students easier ways to interact with each other. Provide them with a larger, easy to use, variety of ways to communicate about the information they’re learning. If you can do that, then OCW is going to go somewhere and it’s going to make a bigger difference.

The difference between a good app and a Great one

October 17, 2011

As I mentioned in my last programming related entry, I’ve noticed that there is a serious difference between a good application and a Great one. It mainly stems from how much work was put into the final touches of the program. A person can create an effective and good application, that solves most of your problems. But if they, say, forget some of the linking that is needed between items, leave drop down menu arrows without an actual drop down menu, or choose not to actually provide you access to archived information you’ve written then they go from good to somewhat annoying. It’s exactly this case with googlegroups.

Our business has a forum on googlegroups for our Kickstarter project. I’ve been using this application for just over a month now and I have one thing to say, once you submit something via the ‘reply to author’ button, you’ll never find that text again. We attempted to search for some kind of archived file within my email, we looked on the website, and we checked in the googlegroup official forum. It seems that the information is not archived at all, and hasn’t been since 2008.

One of the great things I find about Google, is the ease with which you can use their products. They work hard to make their products fluid like, and they normally do it well. However for older products, that might be on the way out for them, it’s hard to find a way to contact them about problems that arise.

Some of these ideas are still great, they just need some more work. Google is a great company, and can provide great products, but they are starting a trend that doesn’t look good. I’m not saying that all their products need to be hits, but they put such a big spiel on each of them. Now many of them are being remembered. They are still providing some stellar services with their search engine, gmail, googledocs and in my opinion google+, but for them to become Great would be to start developing some of their smaller projects into more full applications. Don’t leave them by the wayside, keep working on them, and at least make sure that someone is available to received comments about concerns/problems. Have a contactus email or form, please!

Problem Set 6; Problem 2 of 5

October 14, 2011

This next problem is another simple use of the time module. Now, instead of simply collecting the time, we’re also setting a time limit on how long the player has to enter an answer. This problem only required some simple modifications to the play_hand() function. Those modifications included simply requesting a time limit from the player using raw_input(provides a prompt that allows the player to enter in the time limit). I’ve made more modifications as I’ve been working on the problem, so I’m going to simplify the code for you, so you get the gist of what one would need to solve it.

The basic difference between this alteration to the function, and the previous function, is simply the request for two new variables (time_limit, and time_left), which both provide integers, and a print statement. Using basic mathematics you can determine how much longer that the player has to enter an answer by subtracting the time_limit from the total_time it took for the player to enter their first answer.

Another part of this adjustment was including a conditional statement that would verify that the player still had time left to enter an answer. You can see that with my last if conditional statement.

if time_left > 0:
           print 'You have %0.2f seconds remaining.' % time_left
       else:
           print 'You have no time left.'

Basically, if the total remaining time left was equal to or less than zero, then you would be unable to continue the game.

Difficulties? There were several issues with this problem, actually. I encountered a, what it seems may be, consistent issue of mine. When I am programming I sometimes place a the original function run within a loop, instead of outside of it. When I place it in the loop, the variable I am trying to monitor is reset each time the loop restarted. If I place it right outside the loop it runs once, and then all additional information is accumulated within the loop, like it needs to be done. This sometimes instigates a feels of brain drain when I realize I need to fix it, because for some reason that idea takes a little more brain power than the rest. The other aspect was learning to use the round() function that is built into python. That was my first time using it, but not at all difficult task to learn.

Important Notes: Often I find that additional conditional statements always seem to be required to make sure that the user doesn’t enter in information that doesn’t make sense. From my own experiences prior to working with programming, I remember situations when I would use the program incorrectly, but the programmer would not have provided sufficient response information. In such cases then I would get error messages with nothing in addition, so I would have no idea what I could do differently to fix the problem. These little details seem to be part of the difference between a good application and a great application.

Up Next Time: My impressions on the difference between a good application and a great application

Problem Set 6; Problem 1 of 5

October 13, 2011

This next Problem Set was designed to teach you more extensive ways to manipulate your code from the Problem Set 5 (not including ghost()). Two of the main aspect it works with is the time module, and implementation of a basic computer player setting.
A module is a set of previously created functions that have been documented and are normally available for all python programmers to use. To access them you simply type in import *name of module* at the beginning of your code. Sometimes there are additional things needed, which you can read more about on http://docs.python.org/. The time module that I import at the beginning of my code allows me to implement time related functions within my game. Which brings me to my first problem in the problem set.

The first problem needs a simple end result. It simply wants you to alter your function play_hand() so that it can determine how long it takes you to enter your word, and then spit that information back out at you. As I had never worked with this module before, it was incredibly helpful that the MIT problem documentation gave the following hint.

Hint: The following code will tell you how long it takes to enter your name:

import time

start_time = time.time()name = raw_input('What is your name?: ')
end_time = time.time()
total_time = end_time - start_time
print 'It took %0.2f to enter your name' % total_time

This hint basically gives you exactly what you need to solve this problem. Start_time and End_time are variables, and time.time() is a function within the time module. When you place the start_time variable before a raw_input section (identified with the time.time() function), It will implement the function time.time() once the question has been printed. Then you identify end_time with the time.time() function, and it collects the total amount of time it took to enter the information into the question prompt.

Here is the altered play_hand() function that includes the time aspects. Please note that I am using the ps6.py document provided by the course, instead of my own ps5.py. That is because I realized after the fact that there is an error in one of my functions that I posting a review of here in the near future. I have made the text bold for the time module areas of the function that needed altering, as discussed above.

def play_hand(hand, word_list):
  k = 2.0
   time_limit = int(get_time_limit(points_dict,k))
   total = 0
   initial_handlen = sum(hand.values())
   while sum(hand.values()) > 0:
       print 'Current Hand:',
       display_hand(hand)
       start_time = time.time()
       userWord = pick_best_word(hand,points_dict)
       end_time = time.time()
       total_time = end_time - start_time
       total_time = round(total_time,2)
       if total_time == 0:
           total_time = .01
       print 'It took %0.2f seconds to provide an answer.' % total_time
       time_left = time_limit - total_time
       if time_left > 0:
           print 'You have %0.2f seconds remaining.' % time_left
       else:
           print 'You have no time left.'
       if userWord == '.' or userWord == '':
            break
       else:
           print userWord
           isValid = is_valid_word(userWord, hand, word_list)
           if not isValid:
               print 'Invalid word, please try again.'
           else:
               points = get_word_score(userWord, initial_handlen)/total_time
               total += points
               print '%s earned %d points. Total: %d points' % (userWord, points, total)
               hand = update_hand(hand, userWord)
   print 'Total score: %d points.' % total

As you can see from the altered function, the time module additions are almost a clear cut and paste of the hint provided. An interesting note here, is that originally I missed part of the original problem, which was also to adjust how the points were assessed. The total points are to be divided by the total_time it took to complete the problem. That is shown at the very end, where the variable points is defined, and total_time divides the words score.

Difficulties? I didn’t really have any difficulties with this Problem Set. The hint made the implementation so easy to understand that I barely had to do any independent thinking to solve it. While the hint was very helpful, It made this problem fairly imbalanced in terms of difficulty in comparison with the rest of the Problem Set. What was problematic was the next problem set, when learning to collected the total_time and learn how to implement a time_limit function.

Up Next Time: Problem Set 6; Problem 2 of 5

How to find closure without outside assistance

October 12, 2011

In my last entry I mentioned how I ran into an old coworker, and how it allowed me to start finding closure regarding what had happened at my last job. What worries me now, is just how much longer it might have taken for that process to really have taken hold, without some kind of outside assistance. By outside assistance I don’t mean counseling and comments from friends, I mean actual confirmation from people within the situation.

I can only imagine how long it must plague those who endure such situations for a longer time than I did. I remember when I first started reading literature regarding bullying at work, and how so many people who are in such situations stay there for years before they move on. Why would a person do that to themselves? I know how much it affected me, so I can only imagine how painful and emotionally scarring it might be for those in it longer.

Until I had spoken with this coworker, I had never really realized how much of my self-confidence was still repressed. Learning that there were others that realized my situation, that even management had changed her position so that they could contain her (I only assume), I started feeling release. This understanding that, yes, I am the intelligent woman I always thought I was. Why on earth did I doubt myself? Why on earth did I let those comments even pierce my skin?

One of the most prevalent comments today that rubs my skin the wrong way is the phrase ‘Don’t take it personally’. What is that phrase supposed to mean? If you didn’t intend in some way to make it personal in the first place, either by your poor choice in words or social skills (or simply because you wanted to make it personal), then you wouldn’t have made the comment in the first place. ‘Don’t take it personally’ is a way for someone to try to get out of the repercussions of making a personal comment about someone. Often you’ll find managers making such comments, when they need to give feedback to one of their employees. They’ll say it, because they don’t want to deal with the emotional repercussions those comments might have on their employees. I feel that the sign of a good manager is recognizing that good employees will take feedback comments personally, because they take their job personally. Learning how to make those comments and still provide a sense to the employee that their work and self are valued, that’s what makes a good manager.

Personally, I find that comment to be a warning sign about your manager. If they use that, it means they are either lacking in experience or they don’t care about you and your feelings. If you are trying to find closure regarding something, and you remember hearing this phrase come out of the other persons mouth, hopefully my reflections can help you to realize that that phrase does not excuse their actions.

Up Next Time: More Programming!!

I think I found a little closure

October 11, 2011

Yesterday I ran into an old coworker. It was quite a fantastic meeting. I was heading out of the grocery store and I was doing my ‘hellos’ towards her as I headed to my car, when all of a sudden she started into a more in depth conversation than I was expecting. First off, I haven’t seen this woman since I was working at my last job. Second, she worked directly with the person conducting the investigation. Third, I always held her in high regard and knew she was more involved in that particular group the whole investigation was concerning in the first place.

This in depth conversation did one astounding thing that I felt I had to mention. This conversation helped me to begin finding closure with how things ended at my previous job. From what I can remember, she seemed to confirm that what I felt I was experiencing (fairly often public shaming from my immediate supervisor) was real, and that it was also seen by others at work (who unfortunately didn’t know what to do about it). She seemed to confirm that my previous supervisor is now in a position where she has no managerial duties. She also noted that no one at work seemed to understand where the concerns with my work ethic and ability to get the job done came from, because everyone else never had any issues with it. If anything, they had problems with my supervisor’s ability to get things done.

Once I finished this conversation I was almost a little giddy. I was so incredibly satisfied that my former supervisor was no longer treating anyone like she treated me and that my reputation was, as far as I could tell, still intact. That everyone was kind of upset about the whole thing and that I was not crazy.

I’ll say it again...I am not crazy. What I experienced was real. Due to a variety of reasons (some family related), I sometimes question myself overly regarding my interpretation of events. It is partially due to this that I allowed myself to believe the interpretations of my superiors. Instead of using my common sense and self esteem I allowed myself to question my own interpretations and thus allowed her to destroy my opinion of myself.

I’m not saying here that one should never question oneself, but that there is a limit to that questioning. When you reach that limit, you allow yourself to be influenced in ways that could potentially be incredibly harmful. That is the point where if you let them, they will control you. Sometimes they want to control you because then their world is safer. Sometimes they honestly don’t know what they are doing and their own personal obliviousness to the situation is what makes it even harder to trust yourself.

Always question yourself, but do it in a healthy way. Never allow someone to make you feel like you’re crazy. There are legitimate reasons why you feel the way you do. Your actions may be inappropriate, which is why learning to hold back on enacting them is key. Understand why you feel that way, allow for self reflection, then act.

Up Next Time: How to find closure without outside assistance

Previous Next

better living through python