You can write an unreadable program in any language? However unreadable
a language is you can always document it? The relevant question is if J
is as good a notation as it could be, or if it could be improved?
Documentation tends to be wrong or lost and when it is we have to be
able to read the program? That's the main reason we write
self-documented code? Is this not valid for J? If is is how can we make
our J code self-documented? Can J be improved as a notation to make it
easier to read and the code more self-documented? /Erling
On 2014-07-14 01:19, Raul Miller wrote:
This is not unique to APL. I've seen similar issues with .Net
programs, with C programs, with Java programs with Ruby programs, with
CP/M programs, etc. etc.
For that matter, I've seen analogous issues in non-programming contexts.
In the context of APL, I've often found that finding representative
example data, and watching how it gets transformed, tends to help make
clear all sorts of issues. Ideally you want something complex enough
to be interesting but small enough that you can see all of it.
But it really doesn't matter what language I'm working with - I almost
routinely need to review the definitions and reference documentation.
Whenever I feel I don't understand something adequately it's time to
go back and review the basics. It's a good way of getting unstuck (but
not the only way - for example: performing experiments is also
important, and sometimes sketching out details on a piece of paper or
in a text editor or just talking with someone can be the right thing
to do).
FYI,
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
