Programming with Grace

June 20th, 2014

We are now working on a textbook for Grace, tentatively titled “Programming with Grace”. A draft of the book as well as information about both built-in libraries and graphics and animation libraries are also available on the site. We expect to put more information to help people learn how to program in Grace.

http://www.cs.pomona.edu/~kim/ProgrammingWithGrace/

The Ackerman Function

June 5th, 2014

Apropos of nothing, here’s a Grace version of Ackermann’s Function inspired by Sam Tobin-Hochstadt’s Racket example:

method ack (m : Number, n : Number) -> Number {
  print "ack {m} {n}"
  if (m <= 0) then {n + 1}
   elseif {n <= 0} then {ack((m -1), 1)}
   else {ack(m -1, ack(m, n-1))}
}

One interesting thing to note is that the condition after the “elseif” is in {brackets}, while the conditions after if is in (parens). This makes logical sense – because the first condition is always evaluated, but is of course inconsistent with every other condition (and sorry for the fixed-with font).

Code as Literature?

January 30th, 2014

Peter Seibel’s blog post Code is not Literature has generated some discussion in our department. I certainly agree with a lot of what Peter writes — when I used to coordinate our final year design patterns course, students would present examples of patterns culled from the Interweb. (Google code search was great until it was switched off). Let’s just say even finding patterns clearly expressed in code was often a bit of a struggle. So I’m quite sympathetic to Peter’s point that “most real code” isn’t really worth reading.

On the other hand, I still like Richard Gabriel’s idea of the “Poetry of Programming”. Donald Knuth’s Tex and Metafont have been published as hardbacks; Kernighan & Plauger’s Software Tools & the John Lions’ Unix book as paperbacks. One of the things I like about Smalltalk and Self was the way the IDE made code easy to read, and that much of the system code had obviously been written to be read. Now Github & SourceForge mean there are millions of lines of code around that can be read anytime: but that still doesn’t make it literature.

I guess this is because literature doesn’t happen by accident. Most writing isn’t literature — this blog post, my university’s assessment handbook, company procedure handbooks or advertising brochures may be grammatically correct and be worth reading for the content they contain: but they aren’t worth reading just for the sake of it. So we shouldn’t be surprised that most of the code isn’t literature: it doesn’t need to be.

What’s this to do with Grace? Two things, I think. First, we hope that Grace is a good language not just for writing code day-to-day, but also for code that aspires to be literature. And second, we hope that at least some of the code we write in Grace, while it may not rise to literature’s exhaled state, will at least be worth reading.

Splash 2013 Grace Tutorial

October 31st, 2013

The link to the tutorial materials is here: http://www.cs.pomona.edu/~kim/GraceStuff/

Grace in one page:

http://gracelang.org/applications/grace-in-one-page/

You should run Grace from here:
http://web.cecs.pdx.edu/~grace/minigrace/js/index.html

Grace is getting Smaller!

October 17th, 2013

In my last blog post, I told you that Grace was growing, and talked a little about GUnit. It’s also growing in other ways: a type checker is under development, and the Graphics libraries now run in the Javascript (Web -based) implementation, as well as in the C implementation.

But notice that all of these developments have been in the libraries. The core of the language has actually shrunk, in at least one way.

We took private fields out of objects.

Before you get too excited, and start calling us up and asking how we expect you to teach about encapsulation if objects can’t have private fields, let me tell you that Grace still does have confidential fields and methods. Confidential attributes are those that can be accessed by an object and by those objects that inherit from it, and confidential is the default for fields (as it is, for example, in Smalltalk).

As originally proposed, private was a bit odd, because it applied only to fields: there were no private methods. Private meant just that: accessible only to the object that contained it, and to no others. It added complexity: three levels of protection are certainly more to explain than two. Moreover, we realized, that because of Grace’s lexical scope, it didn’t really add any power. This is because the effect of a private field can be obtained by removing the field from the object entirely, and putting it in an enclosing scope.

The best way to illustrate this is with an example. Here is a simple one, inspired by a problem in Mark Miller’s dissertation. The problem is to create a counter, and two objects that access it: one object can be used only to increment the counter, and the other only to decrement it.


method counterPair {
    var counter:Number := 0
    def countUp = object {
        method inc { counter := counter + 1 }
        method value { counter }
    }
    def countDown = object {
        method dec { counter := counter - 1 }
        method value { counter }
    }
    object { method up { countUp }; method down { countDown } }
}

def c1 = counterPair
def c2 = counterPair
c1.up.inc
c1.up.inc
print "counter 1 has value {c1.up.value}"
print "counter 2 has value {c2.up.value}"
c2.down.dec
c2.down.dec
print "counter 1 has value {c1.up.value}"
print "counter 2 has value {c2.up.value}"

counterPair makes the two objects, one for incrementing and one for decrementing counter. Because we don’t have tuples built-in, counterPair returns an object with two attributes, up and down, which are the increment and decrement objects. The example code creates two counters, and the output shows that they are independent.

You can run this code yourself here.

The default protection for methods is public, because that is what one wants most of the time; a method can be made confidential by adding the “is confidential” annotation. The default protection for fields is confidential, but a field can be made readable, and, in the case of a variable field, writeable, with the is readable and is writable annotations. To the requestor, accessing a readable or writable field looks exactly like reading from or assigning to a variable, as it always has. So, the line of code above that constructs the result of counterPair could have been written


object { def up is readable = countUp; def down is readable = countDown }

;
in both cases the client object can request the up and down attributes of the newly-created object.