chownage

I'm still here! I've just been extremely busy with class over the past few weeks. We dove into Rails in Week 4 and then moved right on into our first project! My concept was TubeTeam, a mishmash between fantasy football and YouTube videos.

I'm reasonably pleased with how it came out, but overall not thrilled with the styling of the page, even though I spent a ton of time working on the CSS (which is unfortunately really ugly to look at). I think I just need significantly more practice putting sites together to get a feel for how to proceed in terms of the macro structure so I don't end up boxing myself into a corner as I did here with several larger, fixed-width elements that just do not break well on smaller displays. I did do plenty of sketching and wire-framing, but my implementation was a bit clunky and I ended up "throwing a lot of CSS at the problem" in a pretty inefficient manner.

This week started inauspiciously with HTML/CSS. Although I do like design to an extent, and although I do have an eye for details (read: I get massive OCD flareups when things don't line up exactly), wrestling with CSS is not my favorite activity. I would like to get to the point where I understand more general design principles and their actual execution so that when I layout a basic webpage I'm confident in my decisions on structuring divs, choosing position settings, etc, rather than just trying to hack things together somewhat aimlessly.

The best part of the week for me was learning about Sinatra. It definitely helped flesh out my still-limited understanding of view/controller interactions and I'm excited to move forward into Rails!

We made several little sites, one of my favorites was actually the simplest. It takes a URL of the form /math/#/operation/# and performs a simple math operation between two numbers, so: /math/10/sum/15. Nothing too crazy, but one cool thing about my code is:

get '/math/*/*/*' do case params[:splat].delete_at(1) when 'sum' ...

I thought it was cool that I can simply use #delete_at within the case statement to both analyze which operation the user has selected and remove it from the params[:splat] array, leaving only the two numbers to then operate on. The cute little stuff like that is what I live for!

It also makes it easy because then multiple numbers can also be included since the operations themselves are based on #inject operations. It's just a matter of figuring out how to have Sinatra parse the URLs so that it knows how many numbers a user has entered (i.e. to add another entry to the :splat array rather than storing it as [5, sum, 10/15] when the user visits /maths/5/sum/10/15). I could of course simply hack it by having the Ruby code itself split up the last array entry into its constituent numbers. Maybe that's even a better solution?

I don't have this hosted anywhere yet, but I made a (very) little Modest Mouse tribute site!

The assignment was to do a quick webpage in a single-evening using our own CSS. Here are some things I learned:

Wrap everything in a container div with margin: 0 auto. Apparently this needs to have display: static to work properly. I didn't start with this and it ended up being too much of a hassle to incorporate later, so I just made the site always span the width of the page rather than hug the left-side when the window exceeds the max-width setting of the content.

font-size: 0 is awesome for removing tiny spaces between inline-block elements (obviously then you need nested divs or some other solution to actually put text inside). I used this on the .album_nav class which contains all the album cover.

If CSS transitions are doing strange things in Chrome, consider adding -webkit-transform: translateZ(0). I was getting some weird pixel-wide borders showing up when hovering over the album covers (because of the opacity transition) and this fixed it.

What a week! I definitely stayed up a bit too late on Thursday and was a bit blunted to say the least on Friday. Fortunately it was a lot of review and recap, as well as some really cool Git stuff with githug. I finally feel like I have at least a basic grasp on rebasing and in particular interactive rebasing to squash commits (did I use that term correctly?!).

One aspect of class that can be frustrating at times but will no doubt be incredibly useful down the road is the focus on TDD. I still find it tricky to write good tests from a logical standpoint: ones that actually help me write code and foster creative and elegant thinking about the task at hand. Alex is a TDD-whiz though so I'm hoping some of it will rub off.

Next week we're starting with HTML/CSS/JS stuff and then moving onward towards rails. The pace of the class is dizzying but we're learning so much, even if some days it feels like a struggle to summon it to memory, let alone to bring it beyond that to something approaching comprehension.

One of my favorite projects from this week was to code a simple method to score Yahtzee rolls. Even though I have not actually ever played the game, I'm fond of exclaiming "Yahtzee!" whenever I figure something out. This was couched as a pair-programming exercise, and here's what Mike and I came up with.

I won't belabor the whole solution, but two cool things worth noting are the roll_count function, which allows us to easily check for two pairs, three- and four-of-a-kind. From an array of five dice rolls, it looks at @rolls.uniq to determine how many different numbers we have, then adds their score if there are more than (value) of them in the original array. Thus roll_count(4) for an @rolls of [5,5,5,5,1] would iterate over [5,1] and add 20 to the score, since only the 5 appears four or more times in the original @rolls array.

The other cool thing is how we check for a full house. The code is:

return score if @rolls.uniq.length != 2 || @rolls.permutation.to_a.uniq.length == 5

This appears near the end of a case statement asking for the user's scoring method (if you're unfamiliar with Yahtzee, players roll five dice and then choose how they are scored: pair, two-pair, etc.). We first check to ensure that @rolls.uniq.length == 2 and simply return score (which is set to 0 at the beginning of each scoring loop) if this is not the case. Obviously, for a full house there must be exactly 2 unique numbers in the rolls array or its impossible to have three of one number and two of another. Thus this first condition narrows things down to full houses or four-of-a-kind.

The other part of our OR statement is:

@rolls.permutation.to_a.uniq.length == 5

I thought this was pretty slick! We use Ruby's Array#permutation to generate an array of all possible permutations for the initial @rolls array. We then get the unique combinations thereof because #permutation doesn't account for identical indexes, and if the resultant array of arrays has a length of 5, we know that instead of a full house there are actually 4 of a kind, so in that case we just return score (=0) as well.

Working on the Ruby Koans, I encountered these simple assignments as part of a test:

array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] sum = 0

I was really excited to realize I could simply use parallel assignment and do the same thing in one fell swoop:

sum, *array = (0..10).to_a

What a busy first week at GA WDI! It has certainly been demanding and challenging, but my knowledge definitely seems to be progressing and I may even be having a little bit of fun along the way!

This is my favorite project so far: Happitails. We were tasked with creating a sort of management system for an animal shelter, with intentionally vague guidelines. Essentially, the data is structured as:

Instances of class Shelter contain the shelter name and address, a hash for its clients and a hash for the animals currently at the shelter.

People instances have the usual people stuff, and a hash of pets that person owns.

Animal classes have a few attributes, and an array of toys the animal drools on and carries around the house proudly in its mouth.

The easy part was setting up these classes. I also produced a little text-based menu to allow for management of the instances. It consists of functions to:

Add or remove clients

Add or remove pets

Transfer pets between the shelter and client (as clients pick up pets or drop them off).

I did a better job streamlining my methods for this project. The cool part is there is there are just three methods to do all the above, and by sending methods with the #send method I could represent both picking up and dropping off, for example, with the client_action method. This is why I have:

object = (action == :drop_off && shelter.clients[which_client]) || shelter

in that method. This uses short-circuiting to create a ternary where if the client is dropping off, object becomes that client object (from the shelter.clients hash), otherwise object is the shelter itself. That means when we call the whats_left method to print the animals available, if the client is dropping off we see the pets in her pets hash (object is the Person instance), but if she's picking up we see the pets the shelter has available for adoption.

Just wrote a quick script that auto-hashtags all words over three characters in a string. Check it out!

tweet = "We ate fifty cheeseburgers for lunch" def auto_hashtag(tweet) tweet.split.select! {|x| x.length > 3}.map! {|x| "##{x}"} end def auto_hashtagtweet(tweet) tweet << tweet.split.map! {|x| " ##{x}" if x.length > 3} .compact.join('') end

There is auto_hashtag, which returns an array of #hashtags, as well as auto_hashtagtweet, which appends space-separated #hashtags to the end of the initial tweet. For the latter I hardcoded spaces into the tweet array rather than appending an extra space between the tweet and the tags.

As part of my GA coursework, we programmed a basic calculator. Here's mine: Prescott's Calculation Station. The parameters for the assignment are in master.

There are a few things I think are cool.

We first ask the user for his input with choose_operator. There's an until loop that requires that her selection matches a known operator in the all_operations array (which itself is a combination of arrays of known operations for two numbers (+, -, etc.) and one number (sqrt, sin, etc.)

Based on whether the user has selected something that requires one or two numbers, we ask her for them (the check for this is which array the operator is in). Note the difference between these two lines

user_numbers = chose_numbers(0), choose_numbers(1) user_numbers << choose_numbers(0)

The first creates an array with = since we get two values. The second must actually concatenate the single value from the user into the empty user_numbers array. If you try to use = here an error occurs because user_numbers ends up being Float instead of Array.

For the two_num_operation, rather than just do a massive case statement, I have a solution that sure seems cool to a neophyte like me. The function is passed the choice_array of the user's numbers, as well as her choice. Then we just use

choice_array[0].send(choice, choice_array[1])

which tells ruby to call the method choice (which remember will be "+" or "-" or "**", etc.) on our first number and then passes in the second number as the argument for that method. The result is one line that handles all the two number operations! Yay Ruby!

Finally, I love me some inject, so since we weren't allowed to use the built in trigonometric functions, I used a quick inject loop to approximate sin and cos based on their Taylor function approximations. This also allowed me to use the nifty recursive factorial function we'd written earlier in the day. I opted to calculate both sin and cos by hand (rather than doing one and then computing sin from cos) because it avoids having to do some messiness to figure out their relative signs based on which quadrant we're in.

Today was my first day at GA Boston's WDI program. We spent the morning doing some ice-breakers and doing a general orientation to the class prior to installing the tools we'll be using over the coming months. The schedule includes a lot of different tools and packages, so I'm both excited and a bit intimidated by the syllabus. We spent the afternoon doing some basic terminal stuff and scratching the surface of Git. One thing I thought was really intriguing is that when Tom was demonstrating basic workflow, he used

git commit . -m "message"

with the period to indicate a directory. I had never seen the directory specified like that in a commit and neither had Tom or Alex, the other two instructors. In turn they didn't realize you can specify

git commit [file] -m "message"

to commit a file or files piecemeal instead of committing everything from the index in one go. It was actually really cool to see that no matter how awesome you are at programming and its pendant tools, there are always new tricks to learn and tips to pick up.

My classmates seem very friendly and motivated, and the instructors--David, Tom and Alex--are really good guys. Time to finish up the reading and head to bed; these are some long days!

Tomorrow is my first day at General Assembly's Web Development Immersive Course. I'm extremely excited (and maybe a little nervous).

I was always interested in computers as a child and spent some time dabbling in computer programming, mostly little experiments in BASIC. Unfortunately I didn't pursue it very far; despite being really into math in high school, nobody ever really suggested it to me other than my ninth grade algebra teacher and as a result I don't think I was fully cognizant of the fact that computer science would have been a viable path for me in college. I think I would have been a lot happier going after a comp sci degree because although I really enjoyed my organic chemistry courses, I had no real affinity for the lab work, even then.

This is a solution I came up with for a Ruby Koans exercise. The premise is a dice game where you roll five six-sided dice with points awarded as follows:

1000 points for three 1's (in any order)

x00 points for three of any other number (500 for 5-5-5, etc.)

100 for each untripled 1

50 for each untrilped 5

My code is:

class DiceSet attr_accessor :values def roll(int) @values = [] int.times do @values << 1 + rand(6) end end def score score = 0 dice = @values dice.sort! (1..6).each do |digit| location = dice.join("").index(digit.to_s*3) if location digit == 1 ? score += 1000 : score += digit * 100 dice.slice!(location, 3) end end dice.each do |value| score += 100 if value.to_i == 1 score += 50 if value.to_i == 5 end return score end end new_one = DiceSet.new new_one.roll(5) puts "Rolls were: #{new_one.values}. Score is: #{new_one.score}"

This works well for the limited parameters of the game. Since you only have to worry about sets of three, you can simply sort the dice array (to put all the same numbers together), then join the sorted array into a string and find the index, if it exists, for each triplet. That index is then used to remove those three numbers so you don't double count them in the event they are 1's or 5's.

I'm wondering, however, how to do this without relying on the fact you can't ever have multiple triplets, and how this could be done if there were greater multipliers for 4 or 5 of one number. In other words, how to search for a more flexible set of entries and remove them from the array? My index method is a little clunky. I have a feeling this is easily accomplished with some intermediate RegEx (assign each instance of ### to a variable and go from there), but I don't really know how to do that...yet!

The first part of the GA Prework ("Computer & Internet Basics") itself begins with "OSX Basics". This part should be particularly embarassing for me because I'm a bit of an OSX neophyte, despite the fact that I worked as an Apple Certified Technician a few years ago! I knew my way in and out of virtually all of the Mac hardware and could more or less hack my way around the GUI, but I'm nowhere near as fast or as knowledgeable as I'd like to be in terms of shortcuts, tricks and just the general vernacular of the operating system. I'll be keeping some notes here for general reference.

Shortcuts

Yeaaaaaaah. We'll just leave these here and pretend I've always known which is the control and which is the option. IT'S GIVING YOU TWO OPTIONS: HIGH ROAD OR LOW ROAD!

⌘ Command key ⌃ Control key ⌥ Option key ⇧ Shift Key ⇪ Caps Lock Fn Function Key

This link has a lot of awesome ones. I'm pretty fast on the Windows shortcuts to move around and highlight text, and in time I will be ridic on the Mac ones too, I hope.

Spotlight