From: Matthew Smillie <M.B.Smillie@...>
Date: 2005-11-24T03:29:19+09:00
Subject: Re: teaching ruby as cs intro?


On Nov 23, 2005, at 16:07, Gregory Brown wrote:

> If CS (especially elementary CS) is all about the things that are
> going on under the hood, well... Ruby is downright horrible for that
> because it is designed specifically to seperate us from the low level
> frameworking that needs to be done to do something simple like
> something.sort

> Computer science is about fundamental operations of the
> computer and manipulations of that... that's what makes C ideal for
> such things.

Firstly, it's important to remember that CS is a very, very broad  
topic, taking in material which 50 years ago would have been taught  
in anything from Philosophy (logic) to Mathematics (combinatorics and  
algebra) to Engineering (elrctronics) departments.  I think that part  
of your disagreement stems from what amounts to a naming problem -  
part of the reason they're moving to the term "informatics" at the  
uni here and a few other places in Europe.

I think, though, that you're being to narrow in your definition of CS  
being limited to the fundamental operations of a computer.  Given  
that definition, I'll readily agree that Ruby may not be a  
particularly good tool to study that level of operation of a computer  
(though one of the most informative undergraduate courses I ever did  
was modifying an actual Real World compiler).

I'd argue that more properly, you could define CS as the study of  
fundamental operations of *computation*, which you can then abstract  
to any given level, whether it's the physical level of logic gates or  
the abstract heights (or depths, depending on your predilections) of  
the lambda calculus.

Given this definition (which is closer to what's called "informatics"  
here), it's for the exact same reasons you think Ruby is a bad  
language, that I think Ruby is a good language.  Ruby (and languages  
like it) let you focus on a particular level of abstraction without  
the burdensome externalia of pointers, memory allocation, etc.  I  
find Ruby particularly good because it can be useful across a large  
section of this set of abstractions.  It can be usefully simple for  
teaching things like quicksort, binary search, and the like, while  
being rich enough to be illustrate (and implement) domain-specific  
languages, metaprogramming and the like.

> I originally thought when entering my university, wow, CS is going to
> make me a better programmer.   It doesn't.   In fact, the limited
> scope of the courses would actually hinder people from becoming good
> programmers if they did not go beyond what was taught in class.

Hereafter is my own little rant, because I hear this sort of  
complaint all too often, usually phrased as "If I'll never have to  
implement quicksort, why should we do it in class?"

One of my professors once said something to a (first-year) class I  
was in that has stuck with me ever since, not just in reference to  
university, but actually as very good advice on how to live your life  
in general.  It went like this:

"In high school, you went to classes to be taught.  In university,  
you go to classes to learn."

The implication is that being taught is passive, whereas learning is  
active.  One is done to you, and the other one you do for yourself.   
By extension, what goes on in class is the *beginning* of what you  
should learn, not the end.  This active approach to learning (whether  
in a university setting or not) is something that you will find in  
anyone who excels in their field, whether that's informatics,  
medicine, or fine art.

(as a closing note, I'll add that this isn't meant to reflect on the  
original poster, since it's fairly obvious that he's quite active in  
his own education)

matthew smillie.