Computer Science #5
RECURSIONS RECURSIONS RECURSIONS

Bursting into the CSC 100 classroom on Tuesday at 10:15 am, I am handed a picture of myself standing in the CSC 100 classroom, the clock reads 10: 15, and I am staring at a picture of myself standing in the CSC 100 classroom and so on... This is how I would conceptualize or rather intuitively describe what a recursion is. A recursion is this idea of repeating items in a "self-similar" way. A fine example of this can be found in the image to the left of this paragraph.
<---------- Sierpinski Triangle
These recursions, like the one shown in the picture, can be pretty mesmerizing and makes me wonder in a general sense, if the world in itself, might be the microcosm of something greater...but I digress...returning back onto the idea of recursions, these self-similar images actually reminded me of something we learnt way back in the first few months of class; Fibonacci numbers. Fibonacci numbers were calculated using a long equation in which you'd have to look back to previous computations in order to calculate the original inputted value. This took a really long time when you'd increase the value inputted into the equation.
After doing the recursion calculations on the handout manually on Tuesday's class (such as the square design, snowflake design, and Sierpinski triangles), I realized the difficulty computers faced having to construct these images within a few seconds. The handouts that were given to us on Tuesday when first glanced, looked like sheets full of incomprehensible functions and operational demands. However, with further inspection, it was a handout of recursions with clear directions which required you to place different values into the functions and predict what image the value would produce.
It took a lot of patience and meticulous speculations to ensure that you inserted the right value into the correct section of the equation. Because recursions usually, maybe always, have conditions, you have you double check your work. After you've securely placed the right value in the correct location of the equation, you'd compute the image based on the functional demands. And, in order for you to find the image created by the recursion equation with larger input values, you'd have to know the image of the previous number and well I found this to be a tiresome job. It was actually at this moment that I was taken back to the first midterm when we had to calculate the Fibonacci values. It the same process of choosing the right equations to input the values and then ensuring that the previous answers would be incorporated into the overall computation.
This process made me wonder that if computers have trouble having to calculate large Fibonacci numbers, wouldn't it take them an extremely long time to calculate large values of Sierpinski triangles? In fact, wouldn't it be even more time-consuming because they are making images? If that's the case, is there a shorter way to calculate these values? As I had written in my previous post, we, computer scientists, are decently lazy and like to make our lives more convenient by finding new and more efficient ways to calculate labor intensive equations. So, I guess for this post, I'll finish it off with a question...are there more effective/shorter ways to produce the value of recursion equations?