SPLASH 2011: Andrew Black and James Noble - The Grace Programming Language Project

MSR Lecture on GRACE

http://research.microsoft.com/apps/video/default.aspx?id=150042&l=i

The Grace web site is at http://gracelang.org/ .

The video is interesting in that it makes me wonder about what makes a language great for instruction - however, can it be said that pedagogical programming languages are like training wheels for bikes, in that they aren't strictly necessary to learn? Taking the example of "method" (as discussed in the video around 14 minutes in) - if a student is having trouble recognising what a method is, even if an alternative syntax helps them learn, will they just keep on having similar difficulties (i.e. that person just isn't cut-out for CS)?

I would like to learn what the duo in the video think of teaching OOP through tooling (e.g. BlueJ / Object Test Bench) as opposed to using a different language.

<i> will they just keep on having similar difficulties (i.e. that person just isn't cut-out for CS)?</i>

This is a very good question and I don't know the answer. Certainly we know people who are able to get to a certain level of competence in Processing, say, but who rapidly drop out of a traditional CS1. The theory of <a href="http://gracelang.org/applications/2011/07/13/learning-edge-momentum/">learning edge momentum</a> simulates one hypothesis for this -- that intro CS course topics are very tightly coupled. As much as possible, we're trying to remove this kind of coupling in Grace.

<i>I would like to learn what the duo in the video think of teaching OOP through tooling (e.g. BlueJ / Object Test Bench) </i>

We think both tooling and languages are important. We're starting with the language, and our first big deliverable will be the language spec (not an implementation). This is a long-term open project: we hope to be in a position to start thinking seriously about tools next year.

BlueJ was of course originally based on Blue, a clean OO language based on Eiffel and designed for education: Blue (and Eiffel) have certainly influenced Grace's design. We think that Java of 2010 is significantly harder to teach than Java of 1999, and that now may be amore propitious time for a new language than 1999.

<blockquote> Taking the example of "method" - if a student is having trouble recognising what a method is, even if an alternative syntax helps them learn ... </blockquote>

There are two points here, and perhaps we didn't distinguish them carefully enough.

The first is to teach the students vocabulary, so that they can read books and articles, and can engage in the discussion of programming concepts that is going on in the community. The language can help in that task by using the same vocabulary. The use of the keyword "method" to define methods is intended to help with that.

The second is to avoid spending teaching time on what we call "accidental complexity". The idea is that there are two sources of complexity in teaching: the "essential complexity", which is what we want the students to master, and the "accidental complexity", which comes from the practicalities of using tools to allow the students to run their programs on a computer. So learning how to login, use an editor, understand the file system hierarchy, and knowing about "public static void main" contribute to the accidental complexity of learning OO with Java.

Understanding that methods belong to objects and represent the response of the object to a request to do something or provide some piece of data is part of the essential complexity of object-orientation. Grace doesn't claim to make that idea any easier to master, but it does free-up time in class to talk about that, and the other the essential ideas of object-orientation, by reducing the amount of accidental complexity. We probably won't succeed in getting rid of all of it, but we are doing our best.

Hi, I was thinking about Grace today, and I came up with an idea for it, its a concept for pointers.
I'll demonstrate the idea using a table

 

 Feature Name     |         Visual Basic/VBA      |     C/C++    | Grace
 __________________________________________________________
    String Var       |         Dim str$                |        char*          |    char^$

                             |                                        |                          |CharPtr
               
   Integer Var     |         Dim num%              |        int*            |  int^%

                                                                                               |   IntPtr

  Pointer to type   |         Dim var as T      |    var<T>           |Ptr<T>                                                                         

  okay I'll explain my thoughts now.
In visual basic or vba, if can define a variable like so :

Dim name$

which is the same as saying Dim name as String.
and In C/C++ you can create a pointer by putting a * after a variable name.

My Idea is to put the variable type in superscript like the asterisk, thereby creating a typed pointer,
you can also create a pointer by saying IntPtr or CharPtr for creating an pointer when you need to.
The superscripted pointer would be of use in function declarations.

You could for example say:
CharPtr cPtr  = nullptr; // States the obvious

But in a function "CharPtr" wouldnt be very effective, so you would do something along the lines of,
Function func(ByVal name^$) instead of Function func(ByVal name CharPtr) although you could say
Function func(ByVal name as CharPtr).

Just an idea/concept.

Tom

P.S The dollar sign and percent sign are supposed to be subscript after char and int in the table under the grace header, also in the above function names.