#w6d1

Due to the incident at App Academy, as well as me calling in sick Friday, we will start with Week 6 Day 1 instead!

Today we did more Javascript exercises. We practiced using arguments, particularly in myBind and currying, and we also practiced using a Surrogate to do inheritance. My partner was willing to take it slow and ensure I understood myBind very well before we moved on to currying, which I picked up on a little quicker. We just got started on almost being able to render for Asteroids, but fell short of time. After class, my partner went forward in getting it to work, while I paired with another person who I said I'd try pairing with to study for the assessment. We went over myBind again and I think it helped both of us reinforce its purpose/usefulness.

Tomorrow we have a CSS day. I'm not sure how that will go, but it'll be a nice break from Javascript.

Other than that, I don't know what else to say for now. I had a lot of saltine crackers throughout the day?

Today I Learned: how to use canvas to generate images on a browser.

We began the day as usual with a review of Friday's materials. After review, we launched into a brief lecture on prototypal inheritance. We learned how to make a boilerplate inherit method to chain inheritance. We also discussed how to "curry" a function through the use of callbacks.

Essentially, to curry a function is to decompose a function (that takes multiple arguments) into a series of functions that takes part of the argument. When all of the arguments are met/filled, the function runs; when the arguments are not all met/filled, the function stores the values until it is ready.

Neat!

After lecture, we split up into pairs for pair programming. My pair and I worked on exercises emphasizing prototypal inheritance and currying functions. After those exercises, we began work on a browser game - Asteroids.

This was neat as we were able to use chained inheritance and object-oriented programming to create classes - ship, asteroid, game, etc - to make a game. We also used canvas to help us "draw/render" the shapes in the browser. It was very satisfying to see the asteroids on the browser and to see them move based on the vectors we gave them.

Today focused on three big topics: the use of the special arguments variable in JavaScript, class inheritance in JavaScript, and using Canvas to draw shapes and animate a game.

Whenever a function is invoked in JavaScript, a special variable named arguments becomes available within the scope of that function and will contain all of the arguments with which the function was called, indexed in the order in which they appeared in the function invocation. This allows us to build functions that take any number of arguments, such as a function that sums-up every element that is passed in to arguments. However, if we have a nested callback function with which we would like to access the arguments variable of its enclosing function, we have to be careful: when the callback is called, arguments within the callback's scope will be the arguments for the callback itself, not for the enclosing function. We can get around this by employing a similar pattern to the this-that trick: define a local variable in the enclosing scope that is captured by the closure formed by the callback to maintain access to the enclosing function's arguments variable.

Setting up inheritance relationships betwee classes is a bit more complicated in JavaScript than it is in Ruby. We set up inheritance relationships by setting a class's prototype's __proto__ pointer to the desired parent class. However, we cannot just set this directly, since otherwise modifying the prototype of a child class would also alter the parent class's prototype as well. Thus, we introduce a "surrogate", empty object, to which we point the child class's __proto__ property, and whose own __proto__ property we point to the desired parent class. This way, when we try to call methods on the child class, JavaScript will recursively search the inheritance chain for the method in the proper manner.