MIDTERM AND STUFF

BEING NEW TO RECURSION THIS YEAR, IT HAS PROVED CHALLENGING TO UNDERSTAND. I MEAN THE BASIC EXAMPLES ARE THERE, BUT UNDERSTANDING THOSE IS ONLY HELPFUL IF YOU TRULY UNDERSTAND THE ENTIRE CONCEPT. THIS IS SIMILAR TO MOST THINGS. FOR WHEN IT IS BROUGHT UP IN SLIGHTLY MORE COMPLICATED EXAMPLES, IT CAN GET CONFSUING. AND THIS IS WHAT I FOUND ON THE MIDTERM. I KNEW HOW TO SET IT UP, BUT THIS WAS WHAT SEEEMED MERELY BY REPETITION BUT NOT TRUE UNDERSTANDING. IT IS AN AREA I WILL BE WORKING TO IMPROVE BECAUSE IT SEEMS LIKE ON OF THE BASIC TOOLS FOR PROGRAMMING. THIS WEEK WE HAVE JUST BEEN TALKING ABOUT RE-IMPLEMENTING CLASSES WITHOUT CHANGING ANYTHING, IT SEEMS SIMPLE ENOUGH AND COULD BE HANDY WHEN UPDATING ALREADY EXISTING CODE.

PRE-MIDTERM

RECENTLY WE HAVE BEEN INTRODUCED TO BIG-O NOTATION. THIS CAN BE A DAUNTING TASK; TO DETERMINE HOW EFFICIENT AN ALGORITHM IS. TO BE ABLE TO LOOK AT SOME CODE FOR A SORTING ALGORITHM CAN PROVE CHALLENGING, AS LOOKING AT WHAT PIECES OF CODE CAN EFFECT THE EFFICENCY IS DIFFICULT. A WAY TO HELP YOU DETERMINE, IS TO LOOK AT THE EXTREME CASES. BASICALLY IN THE CASE WHERE THE LIST YOU ARE SORTING IS VERY SHORT TO GET A FEEL FOR WHAT IT DOES, THEN FOR A LIST THAT IS EXTREMELY LONG, TO SEE HOW IT ACTUALLY SCALES WITH TIME. IT IS IMPORTANT TO REMEBER THAT THE SMALLER LIST, MAY PROVE EASIER TO SORT WITH ALGORITHMS THAT ARE MORE INEFFICIENT FOR LARGER LISTS.

ANOTHER INTERESTING THING I DID, WAS THE WEEK 8, LAB. JUST THE WAY THE RECURSION WAS USED TO PARSE THROUGH THE TREE IN A PREORDER WAY WAS A NEW WAY, AND A LITTLE CONFUSING. TO CREATE VARIABLES IN A TUPLE WITH A HEAD AND TAIL THAT REPRESENT THE PARSING OF THE LEFT TREE AND, SEPARATE, THE RIGHT TREE,  THEN CONNECTING THEM TOGETHER AT THE ROOT. THE BASE CASES WERE ALSO A LITLE DIFFERENT, IT HAD TO ACCOUNT FOR VARIOUS LEVELS OF EMPTY ROOTS ON EACH SIDE, ALSO RESULTED IN THE ANSWERS BEING NON SYMMETRIC. IT ALSO HELPS TO NOTE THAT THE CODE CAN BE EASILY ADJUSTED FOR INORDER AND POSTORDER PARSING. 

WITH THE MIDTERM COMING UP BIG-O NOTATION AND RECURSING THROUGH THE TREES WILL PROVE TO BE THE MOST CHALLENGING. BIG-O NOTATION BECAUSE IT IS NEW AND THE RECURSION BECAUSE I GENERALLY HAVE PROBLEMS DETERMINING THE BASE CASES, AS I STILL HAVE YET TO FULLY COMPREHEND THE MAGIC THAT IS RECURSION AND TEND TO CREATE OVERLY COMPLICATED BASE CASES, OR COMPLETELY FORGET TO DEAL WITH VARIOUS INSTANCES THAT COME UP IN CERTAIN, BUT NOT ALL INSTANCES.

ASSIGNMENT 2 AND EXERCISE 5

THIS NEW CONCEPT OF USING A METHOD RECURSIVELY SIMPLIFIES THE CODE YOU NEED TO USE BY A GREAT DEAL. HOWEVER CALLING IT PROPERLY IS A LITTLE CONFUSING. SOMETIMES YOU HAVE TO CALL IT, FOR EXAMPLE, ON A SELF.RIGHT, WHILE OTHER TIMES SELF.RIGHT HAS TO BE THE ARGUMENT WHILE YOU CALL IT ON A CLASS. THIS IS A GOOD CONCEPT TO USE FOR THE ASSIGNMENT. HOWEVER THE ASSIGNMENT IS MORE A BACKWARDS VERSION, WITH QUITE  A FEW BASE CASES. WHICH MAKES TRYING TO FIGURE OUT THE RECURSION QUITE DIFFICULT. ALSO FIGURING OUT HOW TO PARSE THROUGH THE STRING IS INTERESTING, IT HAS TO AGREE WITH THE BASE CASES PROPERLY, EXECEPT THAT THERE A QUITE A FEW DIFFERENT EXAMPLES YOU HAVE TO TAKE INTO CONSIDERATION.

Midterm/E4

PAST WEEK WE HAD THE MIDTERM AND EXERCISE 4 DUE. THE MIDTERM WAS A GOOD TEST OF ALL THE THINGS WE LEARNED, RECURSION, DEFINING CLASSES AND TEST CASES, AND GOING THROUGH A FUNCTIONS OUTPUT. THE PLACES WHICH WERE THE MOST CHALLENGING WAS IN THE FUNCTIONALLIST, AND ACTUALLY RETURNING A FUNCTIONALLIST, NOT JUST A NORMAL LIST.

E4 IS THE BEGINNING OF STUDYING RECURSIVE DATA STRUCTURES(TREES). I STRUGGLE WITH IMPLEMENTING THE CORRECT WAY TO CREATE MY STRUCTURE WHEN I HAVE THE IDEA IN MY HEAD, AND WHEN I DO, TRYING TO SIMPLIFY THE CODE.

OBJECT ORIENTED PROGRAMMING

OBJECT ORIENTED PROGRAMMING IS BASED ON DEFINING A THING THAT WE CAN PERFORM DIFFERENT ACTIONS ON. IT IS TYPICALLY ASSOCIATED WITHIN A CLASS. IT ALLOWS US TO STORE VARIABLES IN OBJECTS AND THAN PREFORM ACTIONS ON THESE OBJECTS. IT IS HELPFUL BECAUSE WE DONT HAVE TO DEFINE A NEW OBJECT EVERYTIME WE WANT TO PERFORM AN ACTION ON IT, AS LONG AS WE HAVE THOSE OBJECT DEFINED AND THE ACTIONS WE WANT TO PERFORM ALSO DEFINED AND RELATED TO THE OBJECT

RECURSION

RECURSION IS A VERY HELPFUL TOOL TO PROGRAMMERS. IT IS  CALLING A FUNCTION INSIDE ITSELF BUT USING A SLIGHTLY SMALLER CASE, ALONG WITH ITS OWN BASE CASE. IT ALLOWS US TO SOLVE QUITE COMPLEX PROBLEMS WITH RELATIVELY SMALL AMOUNTS OF CODE. INSTEAD OF WRITING CODE FOR EACH INDIVIDUAL STEP WHICH WOULD END UP BEING BASICALLY THE SAME THING, JUST FOR A DIFFERENT CASE, WE CALL THE FUNCTION INSIDE ITSELF TO DO WHAT IT DOES FOR EACH INDIVIDUAL STEP. IT IS A LITTLE CONFUSING TO LEARN AT FIRST. IT FEELS LIKE WE JUST HAVE TO TRUST THAT OUR FEW LINES OF CODE, USING THE FUNCTION INSIDE ITSELF AND OUR BASE CASE, WILL SOMEHOW PRODUCE THE DESIRED OUTPUT. AFTER PLAYING WITH RECURSIVE PROGRAMS FOR A WHILE IT DOESNT SEEM QUITE SO WEIRD.