#{FizzBuzzword}

jQuery Fundamentals

Basic AJAX

AJAX Remote Forms

Underscore Templates

Bootstrapping data

Friday was Ajax day, in combination of jQuery, a bit more javascript, and back to my good old buddy Ruby. There were definitely a few extra semi-colons in my Ruby code due to a wandering pinky finger. Funny how quickly muscle memory is set.

Building things I can see and interact with is so much fun. I could (and did) spend hours making my projects looks and flowing as best I can. We build UIs for our old Tic Tac Toe and Hanoi games (previously played on the console), and even made Snake from scratch. The other two are still baking, but I think this one is ready as is:

JS Basics

Node.js

Objects

Constructor functions

this

First day of Javascript already, meaning we only have a couple more weeks before we begin working on our final project! Back in March, the whole idea of building an entire product on my own seemed daunting. Six weeks later, the idea is nothing but exciting -- especially after seeing how (relatively) easy it is to pick up a new language once you know another language.

This weekend was spent packing every bit of JS we could. We moved quite fast! We begun where most online intro tutorials left off, and here are some bits of the new things I learned:

Constructor functions: Very similar to Ruby's classes, from what I can tell.

function Cat(name, age){     this.name = name;     this.age = age } var cat2 = new Cat("Breakfast", 4)

Prototype: Used to set "class"-like methods.

Polymorphic Associations

Concerns

Integration Testing

Last day of rails. Crazy to think how far we've come.

In true spirit of the season, we built an app where you can set goals private goals or make them public (and hopefully get some words of encouragement). The words of encouragement, aka comments, is where things got tricky. A friend can leave a comment on a user (similar to a fb wall post), or on a goal. So how do we reflect this in our associations? A user can has_many :comments but so can a goal. And how can a comment belongs_to :user and belongs_to :goal ? Well, the answer lies in polymorphic associations.

First, we let the comment know that it has two owners (is polymorphic):

class Comment < ActiveRecord::Base     belongs_to :owner, polymorphic: true end

The notation for the owner classes is more familiar. We simply make a note of what the comment is calling its owner:

class User < ActiveRecord::Base     has_many :comments as: :owner end

and same for the Goal class:

class Goal < ActiveRecord::Base     has_many :comments as: :owner end

Testing Rails with Rspec

Testing Models

Testing Associations

FactoryGirl

Faker

Draper

Pretty funny day today. Not only did we build a Reddit clone (not really, it's optimized for x-posts), but we learned about some awesomely entertaining gems.

Faker is a gem that names of all sorts of esoteric attributes. This comes in handy during development when you quickly run out of funny lines for your theme. The options get oddly specific. Everything from usernames to BS. Yup, company BS to be more accurate. My favorite one was "incentivize mission-critical communities", which I took to mean "get this pack of slackers to do something".

You can then use the FactoryGirl gem to build a lot of instances of this class for your rspec. I have a minor fascination for the names people give to their gems. WIth FactoryGirl, I picture this Barbie-like Rosie the Riveter just building instances in a factory like. Only instead of naming every attribute herself, she stamps it with Faker. Faker is the big robot arm, and FactoryGirl is the manufacturer.

Lastly we used the decorator gem Draper. Just like my other favorite Draper, the Draper gem reduces the unnecessary clutter in your view. It ensures you get the exact method you need, and only that. No need to call many objects only to call other methods on it until you end up with chained data.

I'm not very superstitious. Some of my favorite pieces of fiction are full of the supernatural because I know that, in the real world, magic is just what the ignorant call what they don't understand. Magic is relative, in a way. i rid my world of a little bit of magic today, and in exchange, I gained a whole world of knowledge as to what goes behind the scenes in Rails.

Building my own Rails methods (solo!) in Ruby did wonders to my understanding of what exactly each method is doing. The hardest part was creating my own params. It's all peachy when there's only one layer, but what do you do when you have user[address][street]=main&user[address][zip]=89436 and you want to turn it into { "user" => { "address" => { "street" => "main", "zip" => "89436" } } }?

Well, first I needed a helper method to get all of the keys available:

def parse_key(key)   key.split(/\]\[|\[|\]/) end

The URI class has a pretty cool method in Ruby called #decode_www_form which takes a query string such as “a=1&a=2&b=3” and returns an array [‘a’, ‘1’], [‘a’, ‘2’], [‘b’, ‘3’].

Knowing this, I took the original user[address][street]=main&user[address][zip]=89436 string, passed it through #decode_www_form, and for each pair, begin nesting:

def parse_www_encoded_form(www_encoded_form)    nested_hash = {}    URI.decode_www_form(www_encoded_form).each do |pair|    array_of_keys = parse_key(pair[0])     level_hash = nested_hash     while array_of_keys.length > 1      unless level_hash.keys.include?(array_of_keys.first)       level_hash[array_of_keys.first] = {}      end     level_hash = level_hash[array_of_keys.first]     array_of_keys.shift     end     level_hash[array_of_keys.first] = pair[1]   end   @params.merge!(nested_hash) end

Nested HTML Forms

Extracting and Permitting Nested Data

Transactions

inverse_of

View Helpers

View layouts

View Partials

ActionMailer

User Authentication

Password encryption

Controllers and State

Cookies

CSRF and Forms

To finalize our 99cats project, we added some user and session controllers, but only a user model. Working with a controller that didn't have a model was certainly a tough concept to wrap my head around. Is a user under a new session when they sign up? How can I determine if a user is signed in or not?

We use sessions to keep track of logged in users. A user logs in using a username and password. The latter is encrypted using the BCrpyt gem used to verify passwords without actually storing them. Now, app academy makes it very clear that you would never write your own authentication in productions. There are much better people who have dedicated their life's work to do this. Use that instead. Still, I think it is pretty essential to know how things work. And what better way to learn than doing something on your own?

HTTP

Google and Twitter APIs

OAuth

Today I broke my perfect-score streak for the assessment... by one spec. I fell prey to that tempting fairy over your shoulder that tells you you know something pretty well, that it's the weekend, and that you deserve a break. I thought I'd learned from other peoples' mistakes last week, but, alas, here I am, waiting to see if I get to sleep in this Wednesday.

After the assessment, we went on to build our two projects for the day. The first one was an ice cream finder, which used three Google APIs:

Geocode to find your starting position

Places to find all the ice cream shops nearby

Directions to find directions to each ice cream shop

We got all of our info in raw JSON, so we used JSON Formatter, a chrome extension to make it more readable. I don't know how people could read deeply nested JSON outputs otherwise! We completed our Ice Cream finder just in time for my coding partner to bring me a snickers ice cream bar from the CVS store nearby.

We then moved on to build a raw Twitter API, which meant spamming my coding partner's Twitter account for fun. We used OAuth to authorize our app to both post and view tweets from a specific account.

Mucho ayuda el que no estorba.

I still like SQL better than Active Record, for reasons explained in the quote above. I really tried to think of an English equivalent, but there really isn't any. Google translate didn't really help, as per usual. It basically is used when it's easier to just do something yourself rather than coordinate and/or train someone. While it might make your job easier in the long term, right now, you'd much rather do it yourself.

That's how I feel about Active Record. Active Record is like a child prodigy who wants to learn a skill of mine. And make that a child from a faraway country at that. I also have to learn this kid's language so I can teach them! Sure, once they know how to do it themselves, they'll make my life easier. Heck, the student might even surpass the teacher. But in the meantime, the teacher would just get the job done faster by doing it herself.