Stickytext

I am not from Louisville.
I have never been to Louisville.
I don't even like baseball that much.
This blog is a course log for CSC165H1 in the fall 2014 semester.

Friday 24 October 2014

w-VII

WEEKSEVENWEEKSEVENWEEKSEVENWEEKSEVENWEEKSEVENWEEKSEVENWEEKSEVEN
WEEKSEVEN  
WEEKSEVEN              
WEEKSEVEN                     
WEEKSEVEN                            
WEEKSEVEN                                  
WEEKSEVEN                                       
WEEKSEVEN                                           
WEEKSEVEN                                               
WEEKSEVEN                                                   
WEEKSEVEN                                                      
WEEKSEVEN                                                        
WEEKSEVEN                                                         
WEEKSEVEN                                                         
WEEKSEVEN                                                         
WEEKSEVEN                                                         
WEEKSEVEN                                                         
WEEKSEVEN                                                         


Okay, so week seven in the course was really swell. Like, actually. We are basically coming to the end of constructing proofs, and I seem to have learned to understand appropriate logical construction of arguments/proofs much better. I think that attempting to teach proofs alongside new material runs the risk of sweeping the mechanics of proof aside while focusing on the ``meat'' of the material. For example, learning epsilon-delta proofs in a calculus class.  Getting a firm handle on logic and arguments has been an extremely valuable process, and I already have three-or-so years of university-level mathematics education. It is a little embarrassing to admit that that is the case, but it has genuinely been a very valuable process.

As far as new material this week, we did proof by cases and introduction to algorithm analysis. Let's talk about algorithm stuff.

I guess it is fundamentally interesting to have perspective on how scaling factors and lower order terms have no bearing on how we understand the efficiency of code. This makes me think of ``big data'', and what ``big data'' even means. I recall a talk I attended about computational biology where single datasets for single genes are 10's of terabytes or more. One point that I came away with, was that generating new datasets and/or re-generating the same dataset when one wants to look at the data is more efficient/cost effective than storing all produced data in disk storage somewhere. It is easy to imagine mathematically, taking limits of very large numbers, but sometimes it is difficult to comprehend actually using these numbers in real applications. 

On the other hand it is easier to understand our non-interest in scaling factors for small numbers. For an integer, how much longer does it take to simply return that number versus initializing an accumulator and adding one to it until we reach that number? For small numbers, we could not perceive the difference in running time. Even for not-so-small numbers, we would not be particularly disturbed by a few seconds of run time. What is more concerning to us is how much longer it would take if we doubled or tripled that number. Computers are fundamentally important to the utility of large data and are only becoming more important still. As an aside, a great deal of science is currently being held back by reluctance to embrace the power of computers. This is where we really care about computational and algorithmic efficiency. I look forward to learning more about this.

Thanks for the slog, don't roll a log, motorcycle hog, flip a POG, hot hot dog,

J

No comments:

Post a Comment