Hi Alan,
Thanks for your extremely interesting input. I think Jsoftware should be
looking at the ideas you propose. However, my objectives are somewhat less
challenging. I am aiming at amateurs, not dedicated professionals.
J really serves two disciplines, Mathematics and Computer Science (it
serves other disciplines through Mathematics and Computer Science). My
interest is solely in the application to Mathematics as a means of
experimenting with Mathematics.
My education taught me to believe that Mathematics was fundamentally
elegant. If it wasn't elegant, something was wrong. Tacit J is about
Mathematics and it isn't elegant, so I set out to find something that was
elegant. I found tacit S. While I knew it was simpler than tacit J, I didn't
realize until last night that would be trivial to use.
It has never been my intention to change the habits of experienced J
programmers. I want a parallel system only. I am sure that there are
Computer Science applications where tacit S would not suffice. The fact that
experienced J programmers are so dedicated to it demonstrates its value. But
in common Mathematical applications, I am certain tacit S would suffice.
I also knew that implementation of S had to be a reasonable sized task
or it wouldn't get done. What I didn't realize until today was that its
implementation would also be trivial. So I know that if its value is
accepted, it will get implemented. And if it gets implemented, it will
spread quickly. This will benefit commercial users as well as teachers and
university professors.
The why, what and how of creating Tacit S are outlined below:
1)Why: "[" and "]" in effect jump over intervening code to reach the
right argument or left argument. It is important to know how
far to jump in the J expression - the J expression can be
broader than the tacit expression.
What: Define the extent of the tacit S expression.
How: Place the tacit S expression in parentheses - except
when it is named and stored.
The parentheses serve other purposes, but we only need one
to prove that they are needed.
2)Why: For implicit definition, tacit S will consist only of verbs, so
that the nouns x and y must be removed. The system has
to know where they came from at execution time.
What: Markers must be put in the place from which they came.
How: Use "[" as a marker for x and "]" as a marker for y. At
execution time, the implicit rules bring an x and a y to the
right of these verbs.
3)Why: The system has to be able to tell that this is tacit code, not a
regular S (or J) expression.
What : Something special needs to be to the left of the extreme right
parenthesis.
How: The "]" that would have been placed inside the extreme right
parenthesis should not be used. This places a verb against
the right parenthesis, which does not happen for explicit J.
This is enough to identify it as tacit.
4) Why: At execution time, the system has to have an expression it can
parse to produce a correct result.
What: There is no need to produce a special parser and execute
routine or to convert tacit S to tacit J. Tacit S uses the
same right to left rules as explicit J.
How: Parse and execute the tacit S expression with the regular
explicit J routines, but for every "[" and "]", bring in the
correct argument to their right and bring in the right
argument to the left of the last right parenthesis.
Thus we have a tacit language that is easy to use, easy to
implement and able to serve Mathematics well. It isn't worth
not implementing it to sit beside tacit J.
Don
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
