TITLE: A Few Quick Lessons from Five Small Joy Programs
AUTHOR: Eugene Wallingford
DATE: July 20, 2016 9:16 AM
I recently wrote about some experiences
programming in Joy,
in which I use Joy to solve
that make up a typical homework assignment early in my Programming
Languages course. These problems introduce my students to writing
simple functions in a functional style, using Racket. Here is
if you care to check it out. I'm just getting back to stack
programming, so this code can surely be improved. Feel free to
suggestions or tweet me at @wallingf!
What did these problems teach me about Joy?
It's neat for me to be reminded that even the simplest little
functions raise interesting design questions. In Joy, use of
a stack for all data values means that identifying the most
natural order for the arguments we make available to an
operators can have a big effect on the ability to read and
write code. In what order will arguments generally appear
"in the wild"?
In the course of experimenting and trying to debug my code (or,
even more frustrating, trying to understand why the code I
wrote worked), I even wrote my first general utility operator:
- The language's documentation is sparse. Like my
students, I had to find out which Joy primitives were
available to me. It has a lot of the basic arithmetic
operators you'd expect, but finding them meant searching
through a plain-text file. I should write Racket-caliber
documentation for the language to support my own work.
- The number and order of the arguments to a function
matters a lot. A function that takes several arguments
can become more complicated than the corresponding Racket
function, especially if you need to use them multiple times.
I encountered this on
my first day back to the language.
In Racket, this problem requires a compound expression,
but it is relatively straightforward, because arguments
have names. With all its arguments on the stack, a Joy
function has to do more work simply to access values,
let alone replicate them for multiple uses.
- A slight difference in task can lead to a large change
in the code. For Problem 4, I implemented operators
for modular addition, subtraction, and multiplication.
+mod and *mod were elegant
and straightforward. -mod was a different
story. Joy has a rem operator that operates
like Racket's remainder, but it has no
equivalent to modulo. The fact that
rem returns negative values means that I
need a boolean expression and quoted programs and a new
kind of thinking. This militates for a bigger shift in
programming style right away.
- I miss the freedom of Racket naming style. This
isn't a knock on Joy, because most every programming
language restricts severely the set of characters you can
use in identifiers. But after being able to name functions
+mod, in-range?, and
int->char in Racket, the restrictions
feel even more onerous.
- As in most programming styles, the right answer in Joy
is often to write the correct helpers. The
difference in level of detail between +mod
and *mod on the one hand and
-mod on the other indicates that I am
missing solution. A better approach is to implement a
modulo operator and use it to write all
three mod operators. This will hide lower-level details
in a general-purpose operator. modulo
would make a nice addition to a library of math operators.
- Even simple problems can excite me about the next
step. Several of these solutions, especially the
mod operators, cry out for higher-order operators. In
Racket, we can factor out the duplication in these
operators and create a function that generates these
functions for us. In Joy, we can do it, too, using
quoted programs of the sort you see in the code
for -mod. I'll be moving on to quoted
programs in more detail soon, and I can't wait... I
know that they will push me farther along the transition
to the unique style of stack programming.
DEFINE clear ==  unstack.
It clears the stack so that I can see exactly what the code I'm
about to run creates and consumes. It's the first entry in my
own little user library, named utilities.joy.
Fun, fun, fun. Have I ever said that I like to write programs?