Arguments are Passed by Value

The parameters, in a function call, are the function's arguments.

JavaScript arguments are passed by value: The function only gets to know the values, not the argument's locations.

If a function changes an argument's value, it does not change the parameter's original value.

Changes to arguments are not visible (reflected) outside the function.

Objects are Passed by Reference

In JavaScript, object references are values.

Because of this, objects will behave like they are passed by reference:

If a function changes an object property, it changes the original value.

Changes to object properties are visible (reflected) outside the function.

Why the hell is it raining so much in SF? They told me it never rains here, so I didn’t bring an umbrella. Oh well, I didn’t want good looking hair for my professional photo anyways.

Today’s lecture was fun, just like yesterday. Although the sample size is small, so far I’ve been quite impressed with both instructor’s ability to hold everyone’s attention. We pretty much spent the entire morning bombarding our teacher with questions about immutable and mutable objects and what would happen to them when some fringe case that would most likely never happen occurs. Typical inquisitive students. We definitely gleaned a great deal of knowledge though.

After a very soggy walk and a very expensive lunch, it was time to pair program. My partner was a really cool and friendly guy, but he was a little behind concerning the material. I tried my very hardest to teach, and hopefully, I was able to show him a few tricks. Unfortunately, at some points, I ended up taking over as a driver and just dumping my thoughts out while ignoring his suggestions. My patience really wasn’t as good as it should have been. I’m sorry for being an awful pair programmer. Bad me. I will make doubly sure to be an understanding partner in the future.

It’s day 2.  The morning lecture today was mostly review for me.  We spent most of our time on the topic of “Pass by reference.” One thing learned today: if you make a copy of an Array with dup, then reassign one of the elements in either Array, both will reflect the change.  That’s because the copy has variables that refer to the same locations in memory, even though the arrays themselves are stored at different addresses.

We also went through the solutions for Assessment 0.  There was one particular problem on the assessment I had trouble with yesterday.  The problem was to sort the letters of a string according to the order of an alternative alphabet supplied as an argument to the function.  Today I learned that it has an elegant solution using the sort_by method of Array.  I had forgotten you can pass a block to sort, and I forgot about sort_by completely. These solutions always stick better after struggling with a problem for a while.

Pair programming is a challenge for me, but I think it is really going to improve my thinking in the long term.  I am used to working alone on coding problems, so it takes some work to put my thoughts in to words, and to work with with someone else’s ideas when I have a different solution in mind.  I’m noticing after only two days that each person has their own unique style of thinking and communicating about these problems.

今天在刷题的时候学了一招，java的引用传递怎么用。因为看答案的时候c++版本的引用传递使用例如 int*& node 可以通过改变node指向的地址去改变node的值，但是在Java里面没有指针，所以我们可以通过新建一个类，然后让node作为该类的成员变量，通过改变成员变量的引用从而改变它的值。下面的例子是同一代码的c++和java版本的对比：

*************** C++ *******************

class Solution {

public:

bool isValidBST(TreeNode* root) {

TreeNode* prev = NULL;

return validate(root, prev);

}

bool validate(TreeNode* node, TreeNode* &prev) {

if (node == NULL) return true;

if (!validate(node->left, prev)) return false;

if (prev != NULL && prev->val >= node->val) return false;

prev = node;

return validate(node->right, prev);

}

};

*************** Java *******************

public class Prev {

TreeNode prev;

public Prev(TreeNode x){prev = x;}

}

public class IsValidBST {

public static boolean Solution(TreeNode root){

Prev prev = new Prev(null);

return Solution(root, prev);

}

public static boolean Solution(TreeNode node, Prev prev){

if(node == null) return true;

if(!Solution(node.left, prev)) return false;

if(prev.prev!=null && prev.prev.val>= node.val) return false;

prev.prev = node;

return Solution(node.right, prev);