Also, is there an FAQ for comp.lang.apl?  Pointers to this would also
be appreciated.

Thanks in advance for any info,

Jeff

===================================================================
1.    What's J?
2.    Where can I get it?
3.    What publications are available ? And how much do they cost ?
4.    What are the copyrights ?
5.    Is there an instruction set I can peruse?
6.    What _free_ packages are available?
7.    News
===================================================================
(Thanks to those who have contributed to this FAQ. -Emmett)

1.    What's J?

     J is a functional shareware programming language  
     available via anonymous ftp at watserv1.waterloo.edu.

     Features include list-at-a-time processing, arrays of arrays,
     complex numbers, special features for multiplying polynomials,
     manipulating sets and generating permutations.  Although it
     provides support for numerical modeling, it is not a numerical
     modeling package.  It is a general purpose programming language.

     J was designed and developed by Ken Iverson and Roger Hui.
     It is similar to the language APL, departing from APL in using
     using the ASCII alphabet exclusively, but employing a spelling
     scheme that retains the advantages of the special alphabet
     required by APL. It has added features and control structures
     that extend its power beyond standard APL.  

     Although it can be used as a conventional procedural programming
     language, it can also be used as a pure functional programming
     language.

     J is similar to the programming language A used at Morgan Stanley.
     A is not commerically available.

     J is portable and runs on : Acorn Archimedes, AT&T 3B1,
     Apple Macintosh family, Atari ST, DECstation (MIPS-based),
     DEC VAX (ULTRIX & BSD), Interactive 386/ix, IBM RISC/6000,
     IBM PC family, MIPS R3000, NeXT, Philips P9070, Silicon
     Graphics SGI Irix, Sun 3, Sun 386i, Sun 4 (SPARC), and HP95.

     It is possible to call C from J and J from C .

     If you are programming in an UNIX environment, you may wish to
     run J under j-interation-mode.el in Emacs. To get this package,
     ftp to "cmns.think.com" and get it at "gnu/dist-18.55/standard".
     If you prefer the feel of vi to Emacs, you can run vip-mode as
     a minor mode. This will allow you to use vip's command mode to
     use commands such as z z. z- f F 0 ^ G H M etc. to move around
     the buffer and edit and re-execute commands, and to use vip's
     insertion mode to execute instructions. Not everyone programming
     on a UNIX box takes this approach as some like running J as a
     process under X.

     If you plan on programming on a NeXT you might experiment with the
     NeXT session manager for J at 129.187.236.233 in pub/next/ProgLang/j .

     On the PC, J's session manager is a single edit window. It has a
     standard menu and supports different fonts. You can run multiple
     copies of J simultaneously.

     The window driver supports all standard window classes (button, edit
     box, listbox, combobox, scrollbar, etc.).  It also supports a graphics
     class in which all GDI drawing commands are supported, a picture class
     which can display WWF, BMP, and ICO graphic images, and an ole class
     which can display OLE objects that are connected to servers such as
     Msgraph and Paintbrush.  Ownerdraw buttons and listboxes are also
     supported.  J can act as OLE clients and as DDE clients and servers.
     J in there are no 64K limits. It also has online help.

2.   Where can I get it?

     For an executable version cd to "languages/apl/j/exec/*"

     To look at or compile the source cd to "languages/apl/j/source"

     Sometimes the source has a more recent version.

     To compile set the variable SYS in js.h for your system.
     Set SYS_DOUBLE to one unless when you enter a numeric vector you
     get a core dump. If this occurs set it to zero and remake.
     A shar file which allows you examine the performance of J on

     Alternatively, J, as well as a considerable amount of other J
     info is downloadable from BBS\APL, 703-528-7617, 1200-14400b,
     N-8-1, v.32bis, 24hours.  For further information contact

3.   What publications are available ? And how much do they cost ?

     Documentation is available from :

     Iverson Software Inc.
     33 Major Street
     Toronto, Ontario, M5S 2K9
     Phone : (416)-925-6096
     FAX   : (416)-488-7559

     The prices below are in $US. $CDN at par.
     {DISCOUNTS:  50% for 20 or more copies of any one item;
                  25% for 10 or more.
      BOOKSTORES: 50% discount}

     For $24 + postage ($10 North America , $20 Overseas) you get :

       "A Dictionary of J" a comprehensive definitions of commands
        including a tutorial and ,
       "An Introduction to J" a 45 page outline of the language,
        A 3.5 DD inch system diskette of J is also provided.

     Iverson Software Inc. also sells :

     "Programming in J" - $15 - A general introduction to programming.

     "Calculus" - $25 - This monograph is broader than that found in
     other publications embracing differential, difference, fractional,
     and vector calculus.  

     "An Implementation of J" - $90 - Explanation of the source
     code and information about LinkJ, the utility by which
     C is called from J and J called from C.

4.   What are the copyrights?

     Printed Iverson Software documentation is copyrighted. The copyright
     for the source is shown below.

/* ----------------------------------------------------------------------- */
/* J-Source Version 6.2 - COPYRIGHT 1992 Iverson Software Inc.             */
/* 33 Major Street, Toronto, Ontario, Canada, M5S 2K9, (416) 925 6096      */
/*                                                                         */
/* J-Source is provided "as is" without warranty of any kind.              */
/*                                                                         */
/* J-Source Version 6.2 license agreement:  You may use, copy, and         */
/* modify the source.  You have a non-exclusive, royalty-free right        */
/* to redistribute source and executable files.                            */
/* ----------------------------------------------------------------------- */
/*                                                                         */

5.   Is there an instruction set I can peruse?

     Here is a list. If you would like a pretty printed reference card
     of instructions (beautifully implemented in{*filter*}by Christopher
     Browne) ftp to "watserv1.waterloo.edu" and cd into "languages/apl/j/help
     /reference.card"

     For example, to create the instruction "From" enter "{", to create
     "Head" enter "{." , and to create "Tail" enter "{:" .      
+---------------------------+------------------------+-----------------------+
| Language Summary          | Iverson Software       |                       |
+---------------------------+------------------------+-----------------------+
|                           |.                       |:                      |
+---------------------------+------------------------+-----------------------+
| = SelfClassify Equal      | IsLocal                |Is(Global)             |
| < Box          LessThan   | Floor       LesserOf   |Decrem       LessOrEq  |
| > Open         LargerThan | Ceiling     LargerOf   |Increm       LargerOrEq|
| _ NegativeSign_Infinity   | Indeterminate          |Infinity               |
| + Conjugate    Plus       | Real_Imag   GCD_Or     |Double       NotOr     |
| * Signum       Times      | Polar       LCM_And    |Square       NotAnd    |
| - Negate       Minus      | Not         Less       |Half         Match     |
| % Reciprocal   Divide     | MatrixInv   MatDivide  |SquareRoot   Root      |
| ^ Exponential  Power      | NatLog      Log        |Power        Chain     |
| $ ShapeOf      Shape      | Suite                  |SelfReference          |
| ~ Evoke        Reflex     | Nub                    |NubSieve     NotEq     |
| | Magnitude    Residue    | Reverse     Rotate     |Transpose              |
| . Dot          DotProduct | Even                   |                       |
| : ExplicitDefinition      | Obverse                |Adverse                |
| , Ravel        AppendItems| RavelItems  Append     |Itemize      Laminate  |
| ; Raze         Link       | Cut                    |WordFormation          |
| # Tally        Copy       | Base2       Base       |Antibase2    Antibase  |
| ! Factorial    OutOf      | Fit_Customize          |Foreign                |
| / Insert       Table      | Oblique     Key        |GradeUp      Sort      |
| \ Prefix       Infix      | Suffix      Outfix     |GradeDown    Sort      |
| [ SameLeft                | Lev                    |                       |
| ] SameRight               | Dex                    |                       |
| { Catalogue    From       | Head        Take       |Tail                   |
| } Amend                   | Behead      Drop       |Curtail                |
| " Rank                    | Do          DoLeftIfErr|Format                 |
| ` Tie_Gerund              |                        |                       |

| & Bond_Compose            | Under_Dual             |Appose                 |
| ? Roll         Deal       |                        |                       |
+----------------------------------------------------------------------------+
|)  label                   a. Alphabet                  A. Atomic Permute   |
|b. Boolean                 c. Characteristic            C. Cyc-Dir * Permute|
|e. RazeIn MemberIn         E. Member of Interval        f. Fix Verb         |
|i. Integers IndexOf        o. PiTimes  Circle           p. Polynomial       |
|x. LeftArgument            y. Right
...

read more »

        watserv1.uwaterloo.ca

in the directory

        languages/apl

for an index.  All that you have asked about, and more, is there.

Lee{*filter*}ey

--
Prof. Leroy J.{*filter*}ey, Faculty of Mathematics, U of Waterloo, Canada  N2L 3G1

 I think of J not so much as a programming language, which it is, but
 as portable many-at-time interpreted front end for your applications
 which is itself a programming language.

 It provides an interface which is nicer and more challenging
 than MATLAB or RLaB, for example you can create and develop your
 functions online without ever using an editor. But there are a few
 exceptions, the syntax for amending is kludgy, and a few primitive
 operators haven't yet been optimizied.

 Since there is a lot of high quality numerical analysis software
 already written in fortran and C, if you want high performance and
 also don't want to reinvent the wheel, you'll want to call f2c'd FORTRAN
 or C from J to do serious number crunching. This can done easily.
 Similarly, if you are familiar with calling compiled fortran from C
 on your machine this can be done also but, unlike using f2c's stuff,
 you'll be on your own on working out the details.

   Here is a word of caution. If you purchase ISI's documentation, I
   expect that you will find the Dictionary and Intro to J terse (but
   comprehensive and correct). But unless you already know APL it will
   be difficult to figure out how to write _real_ programs from the
   Dictionary/Intro and other ISI publications. Fortunately, if you
   take a genuine interest there is plenty of help on comp.lang.apl. Also,
   some of ISI's publications on J are not especially well written, maybe
   even badly written, unless you already know APL then its OK. I mention
   this so you don't go out and buy every book on J by ISI and get
   disappointed later.

   And as a number cruncher you won't be impressed by some examples in
   ISI's publications e.g. Kerner's method is hopelessly sensitive to initial
   conditions to be of any use generally. And there is plenty of
   stuff about creating ascii plots of functions like x^3 -5x + 2x -4,
   a total waste! Based on the doc you might conclude that J is an ingenious
   public domain toy, great as a calculator but not ready for prime
   time as a programming language. So don't judge J by the doc. J isn't
   necessarily a toy because you can interface it to anything, making it
   powerhouse program-at-the-speed-of-thought programming tool. So beautiful!

 I've been working on an lapack-J interface. An alpha version,
 which is an addition to the J source, is available at
 waterserv1.waterloo.edu, in languages/apl/j/workspaces. But in
 a much improved version is in the works. You can use this as
 a reference to see how C is called from J.

 I've started writting some on-line documentation for J via emacs.
 Its not completed but it documents much of J. (If you'd like a copy
 of the *.el file email me and I'll send it to you. BTW, when its
 complete I plan on releasing it to the public.) To avoid copyright
 conflicts the written documentation is sparce, but from this you can
 see some example usages.

 While in j mode, type C-hm to get a language summary or C-hj(v) for
 help with a particular verb (aka function). BTW, a monad is a function
 (aka verb in J) which only has a right argument and a dyad has both
 a left argument and a right argument. Type C-hj+ and this is the
 description of usage.

+ verb

         CONJUGATE (monad) (_)

             x =. 3j7
             y =. 2 2 $ 1j1 2j3 4j5 7j1
             x;y
          +---+-------+
          |3j7|1j1 2j3|
          |   |4j5 7j1|
          +---+-------+
             + x
          3j_7
             + y
          1j_1 2j_3
          4j_5 7j_1

          PLUS (dyad) (0 0)

             m =. 10 100 1000
             n =. i. 3 3
             o =. i. 3 2 2
             (m ; n ; o)
          +-----------+-----+-----+
          |10 100 1000|0 1 2| 0  1|
          |           |3 4 5| 2  3|
          |           |6 7 8|     |
          |           |     | 4  5|
          |           |     | 6  7|
          |           |     |     |
          |           |     | 8  9|
          |           |     |10 11|
          +-----------+-----+-----+
             m + n       NB. Add 10, 100 and 1000 to rows
            10   11   12
           103  104  105
          1006 1007 1008
             m +&.|: n   NB. Add 10, 100 and 1000 to columns
          10 101 1002
          13 104 1005
          16 107 1008
             m + o       NB. Add 10, 100, and 100 to layers
            10   11
            12   13

           104  105
           106  107

          1008 1009
          1010 1011
             (10 100) +"(1 2) o  NB. Add 10 and 100 to rows
           10  11
          102 103

           14  15
          106 107

           18  19
          110 111
             (10 100) +"(1 1) o  NB. Add 10 and 100 to columns
          10 101
          12 103

          14 105
          16 107

          18 109
          20 111

   -emmett