Three Talks on Grace

May 1st, 2013

In the next couple of weeks, there are three talks on Grace.

First, a virtual talk — a video Michael Homer’s talk at last year’s Strange Loop is now online

Second, this coming Tuesday, James Noble is talking about Grace in Vancouver at The University of British Columbia — 4pm Tuesday 7 May.

Third, as part of ICSE, James will be talking specifically about Can an Introductory Programming Language Support the Teaching of Software Engineering? at the CSEET conference, at 3pm on the 21st of May.

James is travelling to Vancouver, Pomona, then up to the Bay Area and San Francisco between now and then, if people would like to talk about Grace.

At SIGCSE

March 6th, 2013

Andrew, James, and I are at SIGCSE through Saturday, March 9. We are giving a talk on Grace on Thursday at 1:45 p.m. and would be pleased to talk to anyone interested in Grace afterward.

Kim Bruce

Laissez-parlent l’Eiffel!

January 28th, 2013

The Eiffel language has many features that support software engineering. One of these is a loop statement that allows programmers to specify loop variants and invariants. We hope Grace may also be used to teach about invariants, so it would be useful to write Eiffel-style loops in Grace:

def letters = "ABCDE"
var i : Number := 1

loop { 
    print(letters[i])
    i := i+1
  }
  invariant { i < = (letters.size + 1) }
  until { i > letters.size }
  variant { letters.size - i + 1 }

The key here is the loop/invariant/until/variant control structure — which in Grace is just a method that takes Blocks as arguments. Here’s a simple implementation of this method:

method loop (body) 
       invariant (invariant)
       until (condition) 
       variant (variant) { 

   if (!invariant.apply) then {error "Loop invariant failed before loop"
                               return "ERROR"}
   var variantValue := variant.apply
   while {!condition.apply} do {
       body.apply
        if (!invariant.apply) then {error "Loop invariant failed in loop"
                                    return "ERROR"}
        def variantValue' = variant.apply
        if (variantValue' < 0) then {error "Loop variant has gone negative"
                                     return "ERROR"}
        if ((variantValue - variantValue') < 1) 
                    then {error "Loop variant decreased by less than one"
                          return "ERROR"}
        variantValue := variantValue'                  
   }
}

Of course, in a practical Grace system, this method, like other control structures, would be defined in the system or dialect library. The key features that make this possible are not themselves complex: multi-part method names support defining every control structure (syntatically and semantically) as a method request, and then using blocks to pass code into those methods.

Grace in Serbo-Croatian

December 5th, 2012

Thanks to Jovana Milutinovich, from Webhostinggeeks.com, our article on experimental graphics support (James Bond, Logo, and Trees has been translated to Serbo-Croatian.

Many thanks to Jovana for this translation: if anyone else would like to translate some of our articles, we’re more than keen to do what we can to help.

Grace @ SIGCSE 2013

December 4th, 2012

We’ll be presenting a paper “Seeking Grace: An new object-oriented language for novices” at SIGCSE 2013 in Denver on March 7th.

We are designing a new object-oriented language, Grace, that is designed for novices. It is intended to integrate proven new ideas in programming languages into a conceptually simple language that allows the instructor and students to focus on the essential complexities of programming, while supporting a variety of approaches to teaching.

Hopefully, this opportunity will help us expose Grace to more of the CS education community.