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

Sign in to queue


The Grace Programming Language project is a research effort that aims to make learning how to program easier by baking "educational abstractions" into the language itself - it's an object oriented programming language designed for teaching undergraduate students. This means the language is designed from the ground up as a learning tool for novice adult programmers.

The Grace PL project is led by Kim Bruce, Andrew Black, and James Noble. (Unfortunately, Kim was unable to take part in this conversation. Next time, Kim!) Here, we learn about the need for a programming language that targets novices and what a novice programming language looks like. What does a programming language for novices mean, exactly? How can it be simple enough (conceptually easy to use, to read, to understand) while remaining useful as a programming tool? Can't you learn how to program effectively using objects in an industrial strength general purpose programming language like C# or Java?  What does Grace afford that the more feature-rich languages don't? Tune in. This is a fascinating research topic and one that should yield some very interesting practical results. Great work!

Thanks for joining us on C9, Andrew and James!

Recently, Channel 9 was invited to attend the great SPLASH conference. What is SPLASH? Systems, Programming, Languages and Applications: Software for Humanity. A big thanks to the SPLASH event organizers for inviting me and my camera to engage some key computer scientists and engineers in geeky, fun conversation! SPLASH is a great event! I learned a ton and met many amazing computer scientists and students.

SPLASH is an annual conference that embraces all aspects of software construction and delivery, and that joins all factions of programming technologies. Since 2010 SPLASH is the umbrella for OOPSLA and Onward! [source=splashcon.org]



Download this episode

The Discussion

  • User profile image
  • User profile image

    @felix9: Thanks for the link!


  • User profile image
    Kim Bruce

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

  • User profile image

    @Kim Bruce: Thanks, Kim. That link was also provided in the post's description.


  • User profile image

    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.

  • User profile image
    James Noble

    <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.

  • User profile image
    Andrew Black

    <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.

  • User profile image

    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.


    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.                                                                                                 

Add Your 2 Cents