TITLE: Summer of Joy
AUTHOR: Eugene Wallingford
DATE: June 11, 2019 3:04 PM
DESC:
-----
BODY:
"Elementary" ideas are really hard & need to be revisited
& explored & re-revisited at all levels of mathematical
sophistication. Doing so actually moves math forward.
--
James Tanton
Three summers ago, I spent a couple of weeks re-familiarizing
myself with the concatenative programming language Joy and trying
to go a little deeper with the style. I even wrote a few blog
entries, including
a few quick lessons
I learned in my first week with the language. Several of those
lessons hold up, but please don't look at the code linked there;
it is the raw code of a beginner who doesn't yet get the idioms
of the style or the language. Then other duties at work and home
pulled me away, and I never made the time to get back to my studies.
I have dubbed this the Summer of Joy. I can't devote the entire
summer to concatenative programming, but I'm making a conscious
effort to spend a couple of days each week in real study and
practice. After only one week, I have created enough forward
momentum that I think about problems and solutions at random
times of the day, such as while walking home or making dinner. I
think that's a good sign.
An even better sign is that I'm starting to grok some of the
idioms of the style. Joy is different from other concatenative
languages like Forth and Factor, but it shares the mindset of
using stack operators effectively to shape the data a program
uses. I'm finally starting to think in terms of
dip, an operator that enables a program to
manipulate data just below the top of the stack. As a result,
a lot of my code is getting smaller and beginning to look like
idiomatic Joy. When I really master dip and
begin to think in terms of other "dipping" operators, I'll know
I'm really on my way.
One of my goals for the summer is to write a Joy compiler from
scratch that I can use as a demonstration in my fall compiler
course. Right now, though, I'm still in Joy user mode and am
getting the itch for a different sort of language tool... As my
Joy skills get better, I find myself refactoring short programs
I've written in the past. How can I be sure that I'm not breaking
the code? I need unit tests!
So my first bit of tool building is to implement a simple JoyUnit.
As a tentative step in this direction, I created the simplest
version of RackUnit's
check-equal?
function possible:
DEFINE check-equal == [i] dip i =.
This operator takes two quoted programs (a test expression and an
expected result), executes them, and compares the results. For
example, this test exercises a square function:
[ 2 square ] [ 4 ] check-equal.
This is, of course, only the beginning. Next I'll add a message to
display when a test fails, so that I can tell at a glance which
tests have failed. Eventually I'll want my JoyUnit to support tests
as objects that can be organized into suites, so that their results
can be tallied, inspected, and reported on. But for now, YAGNI.
With even a few simple functions like this one, I am able to run
tests and keep my code clean. That's a good feeling.
To top it all off, implementing JoyUnit will force me to practice
writing Joy and push me to extend my understanding while growing
the set of programming tools I have at my disposal. That's another
good feeling, and one that might help me keep my momentum as a busy
summer moves on.
-----