Week 4 Reflection

Reflection on Week 4

Here is a basic Markdown template you can use for this week (and most of the quarter).

Part I: Reflection — Things I learned this week from the readings, videos, assignments, and/or in-class activities

(Don't just list things. Reflect. For example, you might think about the following questions, or others that occur to you:

Was there anything this week that was new or surprised you?
Are there things you learned about this week that you feel you still don't really understand?
Did you learn anything new that changes or deepens your understanding of computers or computing?
How do the topics from this week connect to other things you have learned in this class, other classes, other experiences?
How do you think they might apply or be useful in some future class or activity?

Etc. From week to week, different questions might strike you as useful prompts to help you reflect on your learning experience.)

Part II: Specific Questions for this Week

The array indexing syntax you are used to from C or Java is just "syntactic sugar" for some pointer arithmetic:
A[i] is equivalent to *(A+i)
where (A + i) really means A + (i * sizeof(itemtype)) (because pointer arithmetic). Does knowing this help you understand the MIPS code required to access an array element, or does understanding the MIPS code help you to understand the C pointer arithmetic version? (Or neither!?)
Reflecting on the recursive and non-recursive assembly language implementations you wrote for the Triangular Number function, what does that tell you about the overhead involved in function calls?

Optional: If you also implemented the optional tail-recursive algorithm, why did the tail-recursive version require fewer Stack push and pop operations than the non-tail-recursive version?

Use what you learned implementing the two Triangular Number functions to explain why the code on the left is more efficient than the code on the right.

            int i;
            int dec = 0, powOf2 = 1;
            for ( i = end; i >= begin; i-- )
            {
                if ( input[i] == '1' )
                    dec += powOf2;
                powOf2 *= 2;
            }

            int i;
            int dec = 0, exp = 0;
            for ( i = end; i >= begin; i-- )
            {
                if ( input[i] == '1' )
                    dec += pow(2, exp);
                exp++;
            }

Optional: If you want, describe why the code below is even more efficient than the code on the left above.

            int * ptr;
            int * beginAddr = &input[begin];
            int dec = 0, powOf2 = 1;
            for ( ptr = &input[end]; ptr >= beginAddr; ptr-- )
            {
                if ( *ptr == '1' )
                    dec += powOf2;
                powOf2 = powOf2 << 1;
            }