[Grace-core] comments from Philippe & UBC

[James Noble]

Hi 

last week I talked about Grace at UBC, hosted by Philippe Kruchten - and here are some
comments from my notes about the talk and good discussions with Philippe afterwards.
I'd hoped to do this on wednesday, but... so it goes.

Kim & I also visited Jens Palsberg (currently HOD) and Todd Millstein @ UCLA on 
thursday last week.  So here are my memories from these talks:

UBC was particularly interesting because the CS department recently moved to Racket
(for their first semester programming course) followed by a course on programming & 
maintenance taught in Java -- but with no lectures on the Java language... people just
have to pick it up as they go along. The first session of the 2nd course gives them a 
1500line Java program that they have to modify (this is without even seeing imperative
code before...)

* I should remember to say that "types don't effect execution (except in typecase statements)"
    or something like that --- For the UBC talk, I found some a form of words like 
   "types on method arguments & return values don't affect method dispatch" 
     
* Question: what will we do about Numbers (once we want to teach them)?
 - I said: this is on the todo list, we have some ideas & even some basic implementations

* Question: can people redefine while
 - I said: not without explicitly overriding it, and a dialect checker could check it explicitly

* Exceptions 
 - we've got 'em, I didn't get to my slide about them either time

* Concurrency
 - we don't want to bake anything in to the language, but use libraries or dialects
 - it's hard when we're compiling to JavaScript to do this at all

* Why were there "brackets around {return 0}" ?
 - (perhaps I should fix that slide to move the brackets closer to the else)

* x vs x:= what's the story there?
 - same as Scala/Newspeak/Self, I think. although that's only partly right. 
 - there is  a question as to whether we allow a space after the name, before the :=
     if assignment is a method name, we don't usually allow spaces in method names

* why "!foo" rather than "not foo" 
 - a choice to follow C/Java &co, rather than Ada  

* finalisers
 - we don't officially have them; people writing GCs hate finalisers; 
 - we could have "finalizer {block}"   which could even match "initializer {block}"
    i.e. we have a design but we don't know if we want 'em or not

* sets & tuples & set or collection comprehensions
 - we have yet to do a collection library design, although we have at least two attempts
 - we know we need to do this...

* Why not make list of graded examples (w/ implementations in Java, C, Racket, Grace...)
  to compare these languages
  - this like KWIC, Pascal's Triangle,  stuff from Wirth's Algorithms+Data Structures = Programs
(Kim says that I forgot to mention that he (via students) actually had many worked examples from his book translated into Grace.)


James

PS mostly unrelated, here's a rant about Ruby that I came across

http://madhadron.com/a-criticism-of-ruby