I have written a grid-based application that displays the execution
of a J sentence in a 2-D grid and allows you to poke around and see
what happened. I hope that this will speed up the learning curve for
new J users. It is a revolutionary way to view J execution. J is
one of the
few languages where such a display would work, and it might help
users overcome the barrier of visualization.
The package is debug/dissect, downloaded from Package Manager. It
works only for J6, and that is why I am asking for a collaborator.
If it just had a better UI, with little boxes and arrows instead of a
grid...
When you download the package, make sure you update your base
library, which has updates needed for dissect.
Once you have loaded the package, you can try it on sentences. Here
is one from recent Forum traffic:
20 5 0(*`%/"2@(,: (%:@* -.))@((,: , 1"1) % +/@[))10
clear, eh? But maybe you'd like to see it in 2D:
ds '20 5 0(*`%/"2@(,: (%:@* -.))@((,: , 1"1) % +/@[))10'
You can click on a cell to get more detail, or CTRL-click to get more
detail for the cell and all its ancestors. With detail, the shapes
are shown, with a slash separating the shape from the frame. When
there is a modifier with a frame, you will get a 'selector' - a
bright green box where you can enter the indexes of the cell you want
to look at. Double-click the selector to edit it, and when you press
ENTER the selected operands, and the corresponding result, will be
displayed.
Individual verbs that have a frame can be inspected by clicking the
verb; rank operators can be drilled into by clicking. You will get
selectors that you can use to go deeper.
If your sentence blew up, ds will show you what was happening just
before the explosion.
left =. 3 2;5 1 3;4 6
right =. 3 2;4;,4
left +&.> right
|length error
| left +&.>right
Where did it blow up?
ds 'left +&.> right'
will take you right to the error.
This is half-finished, pre-alpha code. I am releasing it because, as
indispensable as grid has been for prototyping, I think dissect could
be really great if freed from the formatting requirements of grid.
If the blocks were placed on the screen in pixel positions rather
than grid cells, the layout would be more compact and more stable
during inspection.
On J6, that would mean managing an isigraph. As I understand it, J7
doesn't have isigraph controls, but it sounds like there are other
graphics features that might do the job. (The first step might be to
get the grid version working on J7.) So I am asking for someone to
step up and write the screen interface for J7. This would involve
designing the new look, and then translating my verbs that format the
display (basically, I have one verb for each J modifier) and handling
clicks. I will be working on finishing the engine. The
screen-interface code that I am asking for is a small fraction of the
total code for the project.
As of now, dissect handles verbs, nouns, and the structural modifiers:
@ @: & &: &. &.: " ~ ` hook fork
It also treats ] [ [: as flow control, and removes them from the display.
Missing are the computational modifiers / ;: ^: etc. I need to
handle them one by one: decide the display, decide what selections
will be supported, then implement. This is what I will be doing next
(after I finish fixing display errors and other bugs).
Even in its skeletal form, dissect can make learning J easier. I
will be giving it to my students to try next semester.
Henry Rich
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
