#w5d5

[shinkaneweek]

[shinkaneweek]

[loneliesthousewife]

I emailed my doctor and called the hospital about early pregnancy classes, but I still feel like I should be doing *more*. I should probably look into ways to improve my diet, I feel really guilty about eating so much junk last week. 

[psl646]

W5D5

Today I Learned: about callbacks, blocks, and asynchronous JavaScript.

We continued our foray into JavaScript by discussing callbacks, blocks, asynchronicity in JS. Asynchronicity in JS is one of the features that makes JS such a powerful language. It can continue to run while other functions are happening in the background, making it particularly useful for the browser.

We learned about some additional ways to invoke functions by using: .call and .apply

These functions in JS will actually take a function that belongs to another class and invoke it on an object that does not have that function originally. Here's some code that helps elucidate what call/apply (they are similar) can do:

Another special function we learned about is: .bind

Bind can take a function and binds that function to the argument/context. Bind returns a function!

If we look at the last two lines of code in the above image, we can make a new function which binds the meow function of the Cat class to a dog object(context).

In this way, we can call deweyMeow() function-style to get: Dewey: Meow!

Neat stuff!

After we learned about these cool tricks and concepts, we split up into our pairs to work on the day's exercises regarding callbacks. My pair partner and I learned some new tricks/quirks about JS. We ran into one interesting quirk when we were writing our addNumbers function. It was about first time attempting to use the 'readlines' library, which is useful for I/O in JS. We found that copying and pasting the JS code we wrote into node had some unexpected errors. Whereas when we ran the file into the command line via node filename.js the code ran as expected. How odd. Will require more research.

I am starting to appreciate JS; despite it not having as many "free" things Ruby gives us, I can already see how powerful JS can be.

[and-megan-blog]

W5D5 (& weekend)

JavaScript day 2. We're certainly moving at a breakneck speed through JavaScript. I find JS a lot easier to read when I pull out anonymous functions and name them as variables. It's easier for me to follow my code this way. It's also important for me to name my variables well, as they are passed around like lice in a kindergarten. During the week, callbacks seemed so roundabout. Breaking it down with a friend this weekend, I can more easily digest callbacks by thinking about them as ways to manipulate data further down the chain. Bind, call, and apply are some fascinating JS methods. It may have been obvious to others, but prior to the weekend, I didn't realize that these methods allow one to use methods on an object that are not defined on said object. For instance, Array.prototype.slice.call(arguments) allows you to use the array slice function on the array-like (but not array!) arguments object.

Call, bind, apply 'this'

your scope cannot contain you

'this' craves adventure

[dylanmeacham-blog]

App Academy: Week 5, Day 5

Today was our second day of JavaScript, and as with the first day, I definitely learned a lot.

Probably the biggest topic that I learned about today was using callbacks with asynchronous JavaScript functions, such as those associated with getting user input. For instance, the question function for Node's input reader takes a callback as its second argument that is invoked once the user has given input. However, until the user inputs something, the program just keeps running past the invocation of question. Thus, if we want something to loop each time we get input from a user, we can't use a while loop, but instead have to do the looping with our callback, since otherwise the loop will loop many times between inputs from the user.

The second major thing that we learned about was the this-that pattern. Because this always refers to whatever object a function was called on, if we have a function within another function in which we want to refer to the outer function's this, we need to set a local variable in the outer function to = that, and then capture that variable within our inner function. In this way, we can have a that variable within our inner function that captures the this of the outer function.

Last, we learned about file organization and the module pattern for exporting and requiring classes from other files. Furthermore, we learned how to make an "index" file that requires classes from multiple other files, allowing us to just require the index in our script and then get specific classes from the index when we need them, all from one place, without having to require tons of different files.

[finalpen]

Speed

Sometimes it’s good to take it slow and understand. Today was in stark contrast to yesterday, where we rushed as fast as we could to get done with the project. But both days, we practically finished everything. It just goes to show you, different approaches can be equally valid.

[keldonia]

Paired - w5d5

To was the first day anyone from our house was paired together and David was paired with me. It was fun and we learned a lot about the idiosyncrasies of JavaScript.